diff --git a/test/regression-1624-retro-stale-base.test.ts b/test/regression-1624-retro-stale-base.test.ts
new file mode 100644
index 000000000..0e4800c86
--- /dev/null
+++ b/test/regression-1624-retro-stale-base.test.ts
@@ -0,0 +1,146 @@
+/**
+ * Regression tests for #1624 — /retro silently produced empty/misleading
+ * output when "today" anchor was wrong or origin/<default> was stale.
+ *
+ * The fix is Step 0.5 in retro/SKILL.md.tmpl: four ordered pre-check
+ * branches before any window analysis. These tests are static invariants
+ * against the template body — they fail the build if the guard is removed,
+ * weakened, or its ordering broken.
+ *
+ * Branches under test:
+ *   1. no-remote skip          — git remote returns empty
+ *   2. detached-HEAD skip      — git symbolic-ref --quiet HEAD returns empty
+ *   3. fetch-fail warn         — git fetch origin <default> exits non-zero
+ *   4. stale-base BLOCK        — fetch ok, latest commit older than window
+ *
+ * Each branch must short-circuit further checks (only one verdict wins) and
+ * must surface a disclosure line on stderr so the narrative carries the
+ * reason rather than silently misreporting.
+ */
+import { describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const ROOT = path.resolve(import.meta.dir, "..");
+const RETRO_TMPL = path.join(ROOT, "retro", "SKILL.md.tmpl");
+const RETRO_MD = path.join(ROOT, "retro", "SKILL.md");
+
+function readTmpl(): string {
+  return fs.readFileSync(RETRO_TMPL, "utf-8");
+}
+
+function readMd(): string {
+  return fs.readFileSync(RETRO_MD, "utf-8");
+}
+
+describe("#1624 retro stale-base guard — Step 0.5 exists and is ordered before Step 1", () => {
+  test("Step 0.5 header is present in template", () => {
+    const body = readTmpl();
+    expect(body).toMatch(/### Step 0\.5: Stale-base \+ bad-today-anchor pre-flight guard/);
+  });
+
+  test("Step 0.5 appears before Step 1: Gather Raw Data", () => {
+    const body = readTmpl();
+    const step05 = body.indexOf("### Step 0.5:");
+    const step1 = body.indexOf("### Step 1: Gather Raw Data");
+    expect(step05).toBeGreaterThan(-1);
+    expect(step1).toBeGreaterThan(-1);
+    expect(step05).toBeLessThan(step1);
+  });
+
+  test("regenerated SKILL.md carries the Step 0.5 guard", () => {
+    const md = readMd();
+    expect(md).toMatch(/Step 0\.5: Stale-base \+ bad-today-anchor pre-flight guard/);
+  });
+});
+
+describe("#1624 retro guard — branch A: no-remote skip", () => {
+  test("template checks for 'origin' remote absence and skips with disclosure", () => {
+    const body = readTmpl();
+    // Must check git remote for 'origin' and short-circuit
+    expect(body).toMatch(/git remote[^|]*\|\s*grep -c '\^origin\$'/);
+    expect(body).toMatch(/RETRO_GUARD: no 'origin' remote/);
+  });
+
+  test("no-remote skip sets a verdict variable that gates later checks", () => {
+    const body = readTmpl();
+    // The verdict variable must be set so later branches short-circuit
+    expect(body).toMatch(/_RETRO_GUARD_VERDICT="skip-no-remote"/);
+  });
+});
+
+describe("#1624 retro guard — branch B: detached-HEAD skip", () => {
+  test("template checks for detached HEAD via git symbolic-ref", () => {
+    const body = readTmpl();
+    expect(body).toMatch(/git symbolic-ref --quiet HEAD/);
+    expect(body).toMatch(/RETRO_GUARD: detached HEAD/);
+  });
+
+  test("detached-HEAD branch is gated by prior verdict check (ordering)", () => {
+    const body = readTmpl();
+    // The detached-HEAD block must be guarded by the verdict check so
+    // no-remote always wins if both are true.
+    const branchBStart = body.indexOf("# Pre-check B: detached HEAD");
+    expect(branchBStart).toBeGreaterThan(-1);
+    const branchBSlice = body.slice(branchBStart, branchBStart + 500);
+    expect(branchBSlice).toMatch(/if \[ -z "\$_RETRO_GUARD_VERDICT" \]/);
+  });
+});
+
+describe("#1624 retro guard — branch C: fetch-fail warn", () => {
+  test("template warns and proceeds against last-known origin when fetch fails", () => {
+    const body = readTmpl();
+    // Match either `git fetch ... ||` or `if ! git fetch ...` shape.
+    expect(body).toMatch(/(?:if !\s+|[^\n]*\|\|\s*)git fetch origin <default>|git fetch origin <default>[^\n]*--quiet 2>\/dev\/null; then/);
+    expect(body).toMatch(/fetch[^\n]*failed[^\n]*offline/);
+    expect(body).toMatch(/_RETRO_GUARD_VERDICT="warn-fetch-failed"/);
+  });
+
+  test("fetch-fail warn is gated by prior verdict check (ordering)", () => {
+    const body = readTmpl();
+    const branchCStart = body.indexOf("# Pre-check C: fetch origin");
+    expect(branchCStart).toBeGreaterThan(-1);
+    const branchCSlice = body.slice(branchCStart, branchCStart + 500);
+    expect(branchCSlice).toMatch(/if \[ -z "\$_RETRO_GUARD_VERDICT" \]/);
+  });
+});
+
+describe("#1624 retro guard — branch D: stale-base BLOCK", () => {
+  test("template extracts latest origin/<default> commit date via git log -1 --format=%ci", () => {
+    const body = readTmpl();
+    // The BLOCK check must read the actual latest-commit date so the
+    // disclosure is concrete (not generic).
+    expect(body).toMatch(/git log -1 --format=%ci origin\/<default>/);
+  });
+
+  test("BLOCK prose names latest-commit date and instructs user remediation", () => {
+    const body = readTmpl();
+    // The BLOCK message must cite the date AND tell the user how to recover.
+    // "Retro window is stale" is the canonical first line.
+    expect(body).toMatch(/Retro window is stale/);
+    expect(body).toMatch(/git fetch origin <default>/);
+    expect(body).toMatch(/Confirm today's date/);
+  });
+
+  test("BLOCK branch is gated by prior verdict checks (ordering)", () => {
+    const body = readTmpl();
+    const branchDStart = body.indexOf("# Pre-check D:");
+    expect(branchDStart).toBeGreaterThan(-1);
+    const branchDSlice = body.slice(branchDStart, branchDStart + 800);
+    expect(branchDSlice).toMatch(/if \[ -z "\$_RETRO_GUARD_VERDICT" \]/);
+  });
+});
+
+describe("#1624 retro guard — disclosure must reach the narrative", () => {
+  test("template names the skip paths that must carry a disclosure line", () => {
+    const body = readTmpl();
+    // The post-bash prose must explicitly tell the model to surface
+    // these reasons in the retro output rather than silently dropping them.
+    expect(body).toMatch(/skip-no-remote/);
+    expect(body).toMatch(/skip-detached/);
+    expect(body).toMatch(/warn-fetch-failed/);
+    // The prose names disclosure + narrative together (either order) so the
+    // retro output is never silently confidently-wrong.
+    expect(body).toMatch(/(?:disclosure[\s\S]{0,200}narrative|narrative[\s\S]{0,200}disclosure)/);
+  });
+});