From a05546cddc8365a197b84a07d18bba7b58bd8cfb Mon Sep 17 00:00:00 2001 From: Garry Tan Date: Thu, 21 May 2026 09:40:06 -0700 Subject: [PATCH] test(retro): regression for #1624 stale-base pre-flight guard MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 13 static-invariant tests pinning the four ordered pre-check branches in retro/SKILL.md.tmpl:Step 0.5: A. no-remote skip — must check origin presence + set verdict B. detached-HEAD skip — must gate behind prior verdict (ordering) C. fetch-fail warn — must match `if !` or `||` shape, gate by verdict D. stale-base BLOCK — must read latest-commit ISO date, cite remediation Plus a disclosure-survives-to-narrative invariant: skip-path verdicts must be named in prose so the retro output carries the cited reason rather than silently misreporting. Failing build if Step 0.5 is removed, branches re-ordered (no-remote no longer wins), or the BLOCK message stops citing today/latest-commit/remediation path. Co-Authored-By: Claude Opus 4.7 (1M context) --- test/regression-1624-retro-stale-base.test.ts | 146 ++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 test/regression-1624-retro-stale-base.test.ts 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/ 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 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 |git fetch origin [^\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/ 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\//); + }); + + 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 /); + 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)/); + }); +});