gsd-pi 2.76.0-dev.82e249f7b → 2.76.0-dev.97f5583d9

package/src/resources/extensions/gsd/tests/issue-4540-regressions.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Regression tests for issue #4540:
+ *   Bug 1 — Invalid quality_gates migration bricks gsd.db
+ *   Bug 2 — Artifact retries emit no journal event, look like stuck loops
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertGateRow,
+  getPendingGates,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+import { emitJournalEvent, queryJournal } from "../journal.ts";
+
+const _require = createRequire(import.meta.url);
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function tmpDb(): { dir: string; dbPath: string } {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-4540-"));
+  return { dir, dbPath: join(dir, "gsd.db") };
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+/**
+ * Builds a v12 database with the broken quality_gates DDL:
+ * task_id is nullable and there is no proper multi-column PK.
+ * This simulates a DB that was created before the v12 fix was applied.
+ */
+function createBrokenV12Db(dbPath: string): void {
+  const sqlite = _require("node:sqlite");
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+
+  db.exec(`CREATE TABLE schema_version (version INTEGER NOT NULL, applied_at TEXT NOT NULL)`);
+  db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(12, "2025-01-01T00:00:00.000Z");
+
+  db.exec(`
+    CREATE TABLE decisions (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+      when_context TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT '',
+      decision TEXT NOT NULL DEFAULT '', choice TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '', revisable TEXT NOT NULL DEFAULT '',
+      made_by TEXT NOT NULL DEFAULT 'agent', superseded_by TEXT DEFAULT NULL
+    );
+    CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL;
+    CREATE TABLE requirements (
+      id TEXT PRIMARY KEY, class TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '', why TEXT NOT NULL DEFAULT '',
+      source TEXT NOT NULL DEFAULT '', primary_owner TEXT NOT NULL DEFAULT '',
+      supporting_slices TEXT NOT NULL DEFAULT '', validation TEXT NOT NULL DEFAULT '',
+      notes TEXT NOT NULL DEFAULT '', full_content TEXT NOT NULL DEFAULT '',
+      superseded_by TEXT DEFAULT NULL
+    );
+    CREATE TABLE artifacts (
+      path TEXT PRIMARY KEY, artifact_type TEXT NOT NULL DEFAULT '',
+      milestone_id TEXT DEFAULT NULL, slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      full_content TEXT NOT NULL DEFAULT '', imported_at TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE memories (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+      category TEXT NOT NULL, content TEXT NOT NULL, confidence REAL NOT NULL DEFAULT 0.8,
+      source_unit_type TEXT, source_unit_id TEXT, created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL, superseded_by TEXT DEFAULT NULL,
+      hit_count INTEGER NOT NULL DEFAULT 0,
+      scope TEXT NOT NULL DEFAULT 'project', tags TEXT NOT NULL DEFAULT '[]',
+      structured_fields TEXT DEFAULT NULL
+    );
+    CREATE TABLE memory_sources (
+      id TEXT PRIMARY KEY, kind TEXT NOT NULL DEFAULT '', path TEXT DEFAULT NULL,
+      imported_at TEXT NOT NULL DEFAULT '',
+      scope TEXT NOT NULL DEFAULT 'project', tags TEXT NOT NULL DEFAULT '[]'
+    );
+    CREATE TABLE memory_relations (
+      from_id TEXT NOT NULL, to_id TEXT NOT NULL, relation TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (from_id, to_id)
+    );
+    CREATE TABLE memory_processed_units (
+      unit_key TEXT PRIMARY KEY, activity_file TEXT, processed_at TEXT NOT NULL
+    );
+    CREATE TABLE milestones (
+      id TEXT PRIMARY KEY, title TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'active',
+      depends_on TEXT NOT NULL DEFAULT '[]', created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL, vision TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '[]', key_risks TEXT NOT NULL DEFAULT '[]',
+      proof_strategy TEXT NOT NULL DEFAULT '[]', verification_contract TEXT NOT NULL DEFAULT '',
+      verification_integration TEXT NOT NULL DEFAULT '',
+      verification_operational TEXT NOT NULL DEFAULT '', verification_uat TEXT NOT NULL DEFAULT '',
+      definition_of_done TEXT NOT NULL DEFAULT '[]', requirement_coverage TEXT NOT NULL DEFAULT '',
+      boundary_map_markdown TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE slices (
+      milestone_id TEXT NOT NULL, id TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending', risk TEXT NOT NULL DEFAULT 'medium',
+      depends TEXT NOT NULL DEFAULT '[]', demo TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '', completed_at TEXT DEFAULT NULL,
+      full_summary_md TEXT NOT NULL DEFAULT '', full_uat_md TEXT NOT NULL DEFAULT '',
+      goal TEXT NOT NULL DEFAULT '', success_criteria TEXT NOT NULL DEFAULT '',
+      proof_level TEXT NOT NULL DEFAULT '', integration_closure TEXT NOT NULL DEFAULT '',
+      observability_impact TEXT NOT NULL DEFAULT '', sequence INTEGER DEFAULT 0,
+      replan_triggered_at TEXT DEFAULT NULL,
+      is_sketch INTEGER NOT NULL DEFAULT 0, sketch_scope TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (milestone_id, id), FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE tasks (
+      milestone_id TEXT NOT NULL, slice_id TEXT NOT NULL, id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'pending',
+      one_liner TEXT NOT NULL DEFAULT '', narrative TEXT NOT NULL DEFAULT '',
+      verification_result TEXT NOT NULL DEFAULT '',
+      escalation_pending INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (milestone_id, slice_id, id),
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    );
+    CREATE TABLE assessments (
+      path TEXT PRIMARY KEY, milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT '',
+      full_content TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT '',
+      FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE replan_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, milestone_id TEXT NOT NULL,
+      slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      reason TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE verification_evidence (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT NOT NULL DEFAULT '', task_id TEXT NOT NULL DEFAULT '',
+      unit_type TEXT NOT NULL DEFAULT '', unit_id TEXT NOT NULL DEFAULT '',
+      evidence_type TEXT NOT NULL DEFAULT '', content TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '',
+      command TEXT NOT NULL DEFAULT '', verdict TEXT NOT NULL DEFAULT ''
+    );
+  `);
+
+  // Broken quality_gates: task_id nullable, no multi-column PK
+  db.exec(`
+    CREATE TABLE quality_gates (
+      milestone_id TEXT NOT NULL, slice_id TEXT NOT NULL, gate_id TEXT NOT NULL,
+      scope TEXT NOT NULL DEFAULT 'slice', task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT 'pending', verdict TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '', findings TEXT NOT NULL DEFAULT '',
+      evaluated_at TEXT DEFAULT NULL,
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    )
+  `);
+
+  // Parent rows + gate row with NULL task_id
+  db.prepare("INSERT INTO milestones (id, title, status) VALUES (?, ?, ?)").run("M001", "Milestone 1", "active");
+  db.prepare("INSERT INTO slices (milestone_id, id, title, status, risk, depends) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Slice 1", "pending", "medium", "[]");
+  db.prepare("INSERT INTO quality_gates (milestone_id, slice_id, gate_id, scope, task_id, status) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Q3", "slice", null, "pending");
+
+  db.close();
+}
+
+// ─── Bug 1 tests ─────────────────────────────────────────────────────────────
+
+describe("Bug 1 — quality_gates migration repair (#4540)", () => {
+  let dir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    ({ dir, dbPath } = tmpDb());
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    cleanup(dir);
+  });
+
+  test("fresh DB: quality_gates task_id is NOT NULL with empty-string default", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    const col = cols.find((c) => c["name"] === "task_id");
+    assert.ok(col, "task_id column must exist");
+    assert.equal(col["notnull"], 1, "task_id must be NOT NULL");
+    assert.equal(col["dflt_value"], "''", "task_id default must be ''");
+  });
+
+  test("fresh DB: insertGateRow with no taskId stores '' and is idempotent", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    adapter.prepare("INSERT OR IGNORE INTO milestones (id, title, status) VALUES (?, ?, ?)").run("M001", "Test", "active");
+    adapter.prepare("INSERT OR IGNORE INTO slices (milestone_id, id, title, status, risk, depends) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Slice", "pending", "medium", "[]");
+
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    const rows = getPendingGates("M001", "S01");
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].task_id, "");
+  });
+
+  test("v22 repair: broken v12 DB opens without error", () => {
+    createBrokenV12Db(dbPath);
+    assert.doesNotThrow(() => openDatabase(dbPath));
+  });
+
+  test("v22 repair: task_id becomes NOT NULL after healing broken v12 DB", () => {
+    createBrokenV12Db(dbPath);
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    const col = cols.find((c) => c["name"] === "task_id");
+    assert.ok(col, "task_id column must exist after repair");
+    assert.equal(col["notnull"], 1, "task_id must be NOT NULL after repair");
+  });
+
+  test("v22 repair: existing NULL task_id row is COALESCE'd to '' during repair", () => {
+    createBrokenV12Db(dbPath);
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      "SELECT task_id FROM quality_gates WHERE milestone_id = 'M001' AND slice_id = 'S01' AND gate_id = 'Q3'"
+    ).get() as Record<string, unknown> | undefined;
+    assert.ok(row, "original gate row must survive the repair migration");
+    assert.equal(row["task_id"], "", "NULL task_id must be repaired to ''");
+  });
+
+  test("v22 repair: scope column present on quality_gates after open", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    assert.ok(cols.some((c) => c["name"] === "scope"), "quality_gates.scope must exist");
+  });
+
+  test("v22 repair: scope column present on assessments after open", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(assessments)").all() as Array<Record<string, unknown>>;
+    assert.ok(cols.some((c) => c["name"] === "scope"), "assessments.scope must exist");
+  });
+});
+
+// ─── Bug 2 tests ─────────────────────────────────────────────────────────────
+
+describe("Bug 2 — artifact-verification-retry journal event (#4540)", () => {
+  test("emitJournalEvent accepts artifact-verification-retry event type", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-journal-4540-"));
+    try {
+      mkdirSync(join(basePath, ".gsd"), { recursive: true });
+      emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: "flow-4540",
+        seq: 1,
+        eventType: "artifact-verification-retry",
+        data: { unitType: "plan-slice", unitId: "M001/S01", attempt: 1 },
+      });
+      const entries = queryJournal(basePath, { flowId: "flow-4540" });
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].eventType, "artifact-verification-retry");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("artifact-verification-retry event carries attempt count", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-journal-4540b-"));
+    try {
+      mkdirSync(join(basePath, ".gsd"), { recursive: true });
+      emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: "flow-4540b",
+        seq: 1,
+        eventType: "artifact-verification-retry",
+        data: { unitType: "exec-slice", unitId: "M002/S02", attempt: 2 },
+      });
+      const entries = queryJournal(basePath, { flowId: "flow-4540b", eventType: "artifact-verification-retry" });
+      assert.equal(entries.length, 1);
+      const payload = entries[0].data as Record<string, unknown>;
+      assert.equal(payload["attempt"], 2);
+      assert.equal(payload["unitId"], "M002/S02");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -77,6 +77,8 @@ function makeMockDeps(
     autoWorktreeBranch: () => "auto/M001",
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
+    preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
+    postflightPopStash: () => {},
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -143,6 +143,13 @@ test("PROVIDER_REGISTRY includes all major LLM providers", () => {
   assert.ok(ids.includes("groq"));
 });
 
+test("PROVIDER_REGISTRY includes claude-code as a first-class LLM provider (#4541)", () => {
+  const entry = PROVIDER_REGISTRY.find((p) => p.id === "claude-code");
+  assert.ok(entry, "claude-code must be in PROVIDER_REGISTRY");
+  assert.equal(entry!.category, "llm");
+  assert.ok(entry!.hasOAuth, "claude-code uses OAuth (CLI auth)");
+});
+
 test("PROVIDER_REGISTRY includes all tool/search providers", () => {
   const ids = PROVIDER_REGISTRY.map((p) => p.id);
   assert.ok(ids.includes("tavily"));

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 21, 'new DB should be at schema version 21');
+  assert.deepStrictEqual(version?.v, 22, 'new DB should be at schema version 22');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 21 (ADR-013 structured_fields column included)
+  // Verify schema version is 22 (v22 quality_gates DDL fix included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.["v"], 21, 'schema version should be 21');
+  assert.deepStrictEqual(version?.["v"], 22, 'schema version should be 22');
 
   closeDatabase();
 });

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -110,6 +110,25 @@ test("template: parallel-research-slices.md has required variables", () => {
   assert.ok(templateSrc.includes("{{subagentPrompts}}"), "template should use subagentPrompts");
 });
 
+test("#4068: template: parallel-research-slices retry cap prevents infinite subagent loop", () => {
+  // The template must cap retries at 1 ("retry it once") and instruct the
+  // agent to write a BLOCKER note on the second failure rather than looping.
+  // Without this, a timing-out subagent causes the orchestrating agent to
+  // retry indefinitely (issue #4068 / #4355).
+  assert.ok(
+    templateSrc.includes("once") || templateSrc.includes("one retry") || templateSrc.match(/retry.{0,20}once/),
+    "template should cap subagent retries at one",
+  );
+  assert.ok(
+    templateSrc.toLowerCase().includes("blocker"),
+    "template should instruct writing a BLOCKER note instead of infinite retries",
+  );
+  assert.ok(
+    !templateSrc.match(/re-run it individually\s*\n/),
+    "template must not have unbounded re-run instruction without a retry cap",
+  );
+});
+
 // ─── Validate milestone prompt ────────────────────────────────────────────
 
 test("template: validate-milestone uses parallel reviewers", () => {

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -30,6 +30,20 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
     assert.equal(normalizeFilePath('``src/foo.ts`` (current state)'), 'src/foo.ts')
   })
 
+  it('strips stray backticks from dash-annotated bare paths (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('.gsd/KNOWLEDGE.md` — append-only S05 lessons section'),
+      '.gsd/KNOWLEDGE.md',
+    )
+  })
+
+  it('prefers a backticked path inside a dash-annotated prefix (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('Input `src/foo.ts` — current state'),
+      'src/foo.ts',
+    )
+  })
+
   it('strips backticks even when mixed with other normalization', () => {
     assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
   })

package/src/resources/extensions/gsd/tests/pre-exec-gate-loop.test.ts

@@ -0,0 +1,272 @@
+/**
+ * pre-exec-gate-loop.test.ts — Regression tests for #4551.
+ *
+ * Verifies that when a pre-execution gate fails on a plan-slice unit:
+ *   1. `s.lastPreExecFailure` is populated on the AutoSession with the blocking
+ *      findings and a verdict excerpt.
+ *   2. The `planning → plan-slice` dispatch rule reads that field and injects a
+ *      "Fix these specific issues" section into the prompt.
+ *   3. The field is cleared (consumed) after the prompt is built so that stale
+ *      context does not bleed into an unrelated future plan-slice run.
+ *   4. When the failure belongs to a *different* unit ID, the dispatch rule
+ *      does NOT inject the stale context into the prompt.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { AutoSession } from "../auto/session.ts";
+import { resolveDispatch } from "../auto-dispatch.ts";
+import type { DispatchContext } from "../auto-dispatch.ts";
+import { buildPlanSlicePrompt } from "../auto-prompts.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+import { deriveStateFromDb } from "../state.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeTempBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-4551-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function seedPlanningState(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Core Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "demo",
+    sequence: 1,
+    isSketch: false,
+  });
+  // Write minimal ROADMAP so state derivation doesn't error
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# Roadmap\n",
+  );
+}
+
+function cleanup(base: string, originalCwd: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { process.chdir(originalCwd); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("#4551: AutoSession.lastPreExecFailure defaults to null", () => {
+  const s = new AutoSession();
+  assert.equal(s.lastPreExecFailure, null, "lastPreExecFailure must start null");
+});
+
+test("#4551: AutoSession.reset() clears lastPreExecFailure", () => {
+  const s = new AutoSession();
+  s.lastPreExecFailure = {
+    unitId: "M001/S01",
+    blockingFindings: ["[file] src/foo.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+  s.reset();
+  assert.equal(s.lastPreExecFailure, null, "reset() must clear lastPreExecFailure");
+});
+
+test("#4551: buildPlanSlicePrompt injects fix section when priorPreExecFailure provided", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const prompt = await buildPlanSlicePrompt(
+    "M001", "Test Milestone", "S01", "Core Slice", base,
+    undefined,
+    {
+      priorPreExecFailure: {
+        blockingFindings: [
+          "[file] src/utils/helper.ts: file not found",
+          "[package] nonexistent-pkg: package not found on npm",
+        ],
+        verdictExcerpt: "status=fail; 2 blocking issues detected",
+      },
+    },
+  );
+
+  assert.ok(
+    prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must contain the fix section heading",
+  );
+  assert.ok(
+    prompt.includes("src/utils/helper.ts: file not found"),
+    "prompt must include the specific file finding",
+  );
+  assert.ok(
+    prompt.includes("nonexistent-pkg: package not found on npm"),
+    "prompt must include the specific package finding",
+  );
+  assert.ok(
+    prompt.includes("status=fail; 2 blocking issues detected"),
+    "prompt must include the verdict excerpt",
+  );
+});
+
+test("#4551: buildPlanSlicePrompt with no priorPreExecFailure does NOT include fix section", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const prompt = await buildPlanSlicePrompt(
+    "M001", "Test Milestone", "S01", "Core Slice", base,
+    undefined,
+    { /* no priorPreExecFailure */ },
+  );
+
+  assert.ok(
+    !prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must NOT include the fix section when no failure context is given",
+  );
+});
+
+test("#4551: dispatch rule injects failure context and clears session field", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  // Write a RESEARCH file so the dispatch rule skips research-slice and reaches
+  // plan-slice (which is the phase we're testing).
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+    "# Research\n",
+  );
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const state = await deriveStateFromDb(base);
+  assert.equal(state.phase, "planning", "state must be in planning phase");
+
+  const session = new AutoSession();
+  session.basePath = base;
+  session.active = true;
+  session.lastPreExecFailure = {
+    unitId: "M001/S01",
+    blockingFindings: ["[file] src/missing.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+
+  const ctx: DispatchContext = {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { phases: { reassess_after_slice: false, skip_research: true } } as any,
+    session,
+  };
+
+  const result = await resolveDispatch(ctx);
+  assert.equal(result.action, "dispatch", "must dispatch a unit");
+  if (result.action !== "dispatch") throw new Error("unreachable");
+  assert.equal(result.unitType, "plan-slice", "must be a plan-slice unit");
+
+  // The fix section must appear in the prompt
+  assert.ok(
+    result.prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "dispatched prompt must include the fix section",
+  );
+  assert.ok(
+    result.prompt.includes("src/missing.ts: file not found"),
+    "dispatched prompt must include the specific blocking finding",
+  );
+
+  // Field must be cleared after consumption
+  assert.equal(
+    session.lastPreExecFailure,
+    null,
+    "lastPreExecFailure must be cleared after being consumed by the dispatch rule",
+  );
+});
+
+test("#4551: dispatch rule does NOT inject stale failure for a different slice", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  // Write a RESEARCH file so dispatch reaches plan-slice, making the assertion
+  // about the prompt meaningful (we can check it's a plan-slice prompt without
+  // the fix section rather than a research-slice prompt without it).
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+    "# Research\n",
+  );
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const state = await deriveStateFromDb(base);
+
+  const session = new AutoSession();
+  session.basePath = base;
+  session.active = true;
+  // Failure belongs to a different slice (S02), not the active one (S01)
+  session.lastPreExecFailure = {
+    unitId: "M001/S02",
+    blockingFindings: ["[file] src/other.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+
+  const ctx: DispatchContext = {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { phases: { reassess_after_slice: false, skip_research: true } } as any,
+    session,
+  };
+
+  const result = await resolveDispatch(ctx);
+  assert.equal(result.action, "dispatch");
+  if (result.action !== "dispatch") throw new Error("unreachable");
+
+  // The stale fix section must NOT appear
+  assert.ok(
+    !result.prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must NOT include fix section for a mismatched unit ID",
+  );
+  assert.ok(
+    !result.prompt.includes("src/other.ts"),
+    "prompt must NOT include findings from a different slice",
+  );
+
+  // Field must remain untouched (not consumed)
+  assert.notEqual(
+    session.lastPreExecFailure,
+    null,
+    "lastPreExecFailure must NOT be cleared when unit IDs don't match",
+  );
+});