@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -21,6 +21,14 @@ function runGit(args: string[], cwd: string): void {
   });
 }
 
+function renderOutcomeWidget(widget: unknown): string {
+  const component = (widget as any)(
+    { requestRender() {} },
+    { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+  );
+  return component.render(100).join("\n");
+}
+
 test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
   const previousCwd = process.cwd();
@@ -167,13 +175,17 @@ test("cleanupAfterLoopExit preserves completion closeout surface after stopAuto
       false,
       "completion cleanup must not replace the closeout surface with a generic outcome card",
     );
-    assert.equal(autoSession.completionStopInProgress, false);
+    assert.equal(
+      autoSession.completionStopInProgress,
+      true,
+      "completion closeout preservation must survive post-loop cleanup until the next agent turn",
+    );
   } finally {
     autoSession.reset();
   }
 });
 
-test("cleanupAfterLoopExit clears completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
+test("cleanupAfterLoopExit preserves completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -196,8 +208,8 @@ test("cleanupAfterLoopExit clears completionStopInProgress even when preserveSte
 
     assert.equal(
       autoSession.completionStopInProgress,
-      false,
-      "completionStopInProgress must be cleared even when preserveStepSurfaceAfterLoopExit was also set",
+      true,
+      "completionStopInProgress must survive cleanup even when preserveStepSurfaceAfterLoopExit was also set",
     );
     assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
   } finally {
@@ -641,6 +653,10 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       false,
       "foreground completion stop must not install a replacement roll-up widget over the transcript",
     );
+    assert.ok(
+      widgetCalls.some(([key, value]) => key === "gsd-progress" && value === undefined),
+      "foreground completion stop must clear stale progress controls in the rerooted session",
+    );
     assert.ok(
       notifications.every(message => !message.includes("/gsd auto to resume")),
       "completion stop notification must not tell users to resume a finished auto run",
@@ -649,10 +665,15 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       notifications.every(message => !message.includes("Auto-mode stopped") && !message.includes("Session:") && !message.includes("Debug log written")),
       "completion stop must not append generic stop/session/debug notifications after the report",
     );
-    assert.ok(
-      widgetCalls.every(([key, value]) => key !== "gsd-outcome" || value === undefined),
-      "foreground completion stop must not replace the transcript with a generic outcome card",
+    const outcome = widgetCalls.find(([key, value]) => key === "gsd-outcome" && typeof value === "function")?.[1];
+    assert.equal(
+      typeof outcome,
+      "function",
+      "foreground completion stop must install a durable closeout outcome in the rerooted session",
     );
+    const rendered = renderOutcomeWidget(outcome);
+    assert.match(rendered, /Milestone M003 complete/);
+    assert.match(rendered, /Review the closeout/);
 
     const widgetCallCountBeforePostLoopCleanup = widgetCalls.length;
     await cleanupAfterLoopExit(ctx);
@@ -822,7 +843,7 @@ test("stopAuto closeout-transcript preservation suppresses generic stop widgets"
   }
 });
 
-test("stopAuto foreground all-complete closeout preserves the transcript surface", async () => {
+test("stopAuto foreground all-complete closeout installs a durable terminal outcome", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-all-complete-closeout-"));
   const previousCwd = process.cwd();
   const widgetCalls: Array<[string, unknown]> = [];
@@ -875,8 +896,15 @@ test("stopAuto foreground all-complete closeout preserves the transcript surface
       false,
       "foreground all-complete closeout must not replace the visible transcript with a roll-up widget",
     );
-    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1);
-    assert.equal(finalOutcome?.[1], undefined, "foreground all-complete closeout must not add an outcome replacement");
+    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1)?.[1];
+    assert.equal(
+      typeof finalOutcome,
+      "function",
+      "foreground all-complete closeout must install a durable terminal outcome",
+    );
+    const rendered = renderOutcomeWidget(finalOutcome);
+    assert.match(rendered, /All milestones complete/);
+    assert.match(rendered, /start new work/);
   } finally {
     try { closeDatabase(); } catch { /* noop */ }
     autoSession.reset();

package/src/resources/extensions/gsd/tests/auto-runtime-state.test.ts

@@ -6,12 +6,15 @@ import assert from "node:assert/strict";
 
 import {
   autoSession,
+  clearAutoToolSurfaceSnapshot,
   clearToolInvocationError,
   getAutoRuntimeSnapshot,
+  recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
   autoSession.active = true;
   autoSession.basePath = "/tmp/project";
   autoSession.orchestration = {
@@ -33,10 +36,40 @@ test("getAutoRuntimeSnapshot includes orchestration phase when available", () =>
   assert.equal(snap.orchestrationPhase, "running");
   assert.equal(snap.orchestrationTransitionCount, 3);
   assert.equal(snap.orchestrationLastTransitionAt, 123);
+  assert.equal(snap.toolSurface, null);
 
   autoSession.reset();
 });
 
+test("getAutoRuntimeSnapshot includes the active typed tool-surface snapshot", () => {
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+  autoSession.active = true;
+
+  recordAutoToolSurfaceSnapshot({
+    source: "dispatch-scope",
+    unitType: "run-uat",
+    modelFacingToolNames: ["read", "read", "gsd_uat_exec"],
+    registeredToolNames: ["read", "browser_navigate"],
+    scopedToolNames: ["read", "browser_navigate"],
+    presentedToolNames: ["gsd_uat_exec"],
+    capturedAt: 123,
+  });
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.toolSurface?.source, "dispatch-scope");
+  assert.equal(snap.toolSurface?.unitType, "run-uat");
+  assert.deepEqual(snap.toolSurface?.modelFacingToolNames, ["read", "gsd_uat_exec"]);
+  assert.deepEqual(snap.toolSurface?.registeredToolNames, ["read", "browser_navigate"]);
+  assert.deepEqual(snap.toolSurface?.scopedToolNames, ["read", "browser_navigate"]);
+  assert.deepEqual(snap.toolSurface?.presentedToolNames, ["gsd_uat_exec"]);
+  assert.equal(snap.toolSurface?.capturedAt, 123);
+
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+});
+
 test("clearToolInvocationError clears stale tool error state for active auto sessions", () => {
   autoSession.reset();
   autoSession.active = true;
@@ -56,4 +89,5 @@ test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", ()
   assert.equal(snap.orchestrationPhase, undefined);
   assert.equal(snap.orchestrationTransitionCount, undefined);
   assert.equal(snap.orchestrationLastTransitionAt, undefined);
+  assert.equal(snap.toolSurface, null);
 });

package/src/resources/extensions/gsd/tests/canonical-milestone-root.test.ts

@@ -17,6 +17,7 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.ts";
+import { resolveCloseoutArtifactProjection } from "../artifact-projection.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-canon-test-${randomUUID()}`);
@@ -106,3 +107,22 @@ test("only returns the worktree for the requested milestone, not siblings", () =
     cleanup(base);
   }
 });
+
+test("resolveCloseoutArtifactProjection names project and canonical artifact roots", () => {
+  const base = makeTmpBase();
+  try {
+    const wtPath = makeLiveWorktree(base, "M001");
+    const projection = resolveCloseoutArtifactProjection({
+      milestoneId: "M001",
+      basePath: wtPath,
+      originalBasePath: base,
+    });
+
+    assert.equal(projection.projectRoot, base);
+    assert.equal(projection.canonicalMilestoneRoot, wtPath);
+    assert.equal(projection.summaryArtifactBasePath, wtPath);
+    assert.equal(projection.gateEvidenceBasePath, wtPath);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -696,3 +696,25 @@ test("ensureCodebaseMapFresh: does not rewrite expired metadata when fingerprint
     cleanup(base);
   }
 });
+
+test("ensureCodebaseMapFresh: detects file changes within the TTL window", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    // Generate initial map with a long TTL so the cache is still active.
+    const initial = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+    assert.equal(initial.status, "generated");
+
+    // Add a new tracked file while the TTL is still active.
+    addFile(base, "src/new.ts");
+
+    // Must detect the change even though the TTL has not expired.
+    const refreshed = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+    assert.equal(refreshed.status, "updated");
+    assert.equal(refreshed.reason, "files-changed");
+    const written = readCodebaseMap(base);
+    assert.ok(written?.includes("`src/new.ts`"));
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-dispatcher-workspace-git.test.ts

@@ -64,3 +64,14 @@ test("getWorkspaceGitBlockMessageForBase allows doctor on product conflicts", as
     cleanup(base);
   }
 });
+
+test("getWorkspaceGitBlockMessageForBase allows forensics on product conflicts", async () => {
+  const base = makeTempRepo("gsd-dispatch-ws-git-forensics-");
+  try {
+    seedProductConflict(base);
+    const blocked = await getWorkspaceGitBlockMessageForBase(base, "forensics");
+    assert.equal(blocked, null);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -10,7 +10,7 @@
  */
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -486,3 +486,40 @@ test("state.ts needs-remediation blocker messages reference /gsd verdict", async
     `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
   );
 });
+
+// ─── WAL checkpoint regression (#563) ───────────────────────────────────
+
+test("handleVerdict pass checkpoints WAL so subsequent processes see the updated verdict (#563)", async () => {
+  // Regression: before the fix, executeValidateMilestone wrote the assessment
+  // only into the WAL file.  The next /gsd auto invocation (a new process)
+  // opened gsd.db directly and saw stale pre-verdict data because the WAL
+  // had not been flushed.  The fix adds checkpointDatabase() after a
+  // successful verdict so the WAL is truncated and gsd.db is self-contained.
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Checkpoint Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    writeValidation(base, "M001", "needs-attention");
+
+    const { ctx } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    // After handleVerdict succeeds, PRAGMA wal_checkpoint(TRUNCATE) must have
+    // run.  The WAL file is truncated to zero bytes — a new process reading
+    // gsd.db directly sees the updated verdict without needing the WAL.
+    const walPath = join(base, ".gsd", "gsd.db-wal");
+    if (existsSync(walPath)) {
+      const { size } = statSync(walPath);
+      assert.equal(
+        size,
+        0,
+        "WAL must be zero bytes after handleVerdict pass — checkpointDatabase() was not called (#563)",
+      );
+    }
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/debug-logger.test.ts

@@ -115,6 +115,21 @@ test('debugCount increments counters', () => {
   assert.strictEqual(summary.dispatches, 5);
 });
 
+test('debugCount tracks gitInvocations and writeDebugSummary reports it', () => {
+  const tmp = createTempGsdDir();
+  enableDebug(tmp);
+
+  debugCount('gitInvocations');
+  debugCount('gitInvocations', 13);
+
+  const logPath = writeDebugSummary()!;
+  const lines = readLogLines(logPath);
+
+  const summary = lines.find(l => l.event === 'debug-summary') as any;
+  assert.ok(summary, 'should have debug-summary event');
+  assert.strictEqual(summary.gitInvocations, 14);
+});
+
 test('debugPeak tracks max values', () => {
   const tmp = createTempGsdDir();
   enableDebug(tmp);

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -14,7 +14,15 @@ import { execFileSync } from "node:child_process";
 
 import { DISPATCH_RULES, resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
-import { closeDatabase, insertAssessment, insertGateRow, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import {
+  closeDatabase,
+  getPendingGates,
+  insertAssessment,
+  insertGateRow,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
@@ -243,7 +251,7 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.reason, "All milestones complete.");
   });
 
-  test("blocks terminal stop when closed milestone still has pending gates", async () => {
+  test("closes stale pending gates from milestone validation before terminal stop", async () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
@@ -268,10 +276,33 @@ describe("complete phase dispatch guard (#5683)", () => {
 
     const result = await rule.match(ctx);
 
+    assert.equal(result?.action, "stop");
+    assert.equal(result?.reason, "All milestones complete.");
+    assert.deepEqual(getPendingGates("M001", "S01"), []);
+  });
+
+  test("blocks terminal stop when pending gates have no closeout evidence", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertGateRow({
+      milestoneId: "M001",
+      sliceId: "S01",
+      gateId: "Q3",
+      scope: "slice",
+      status: "pending",
+    });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
     assert.equal(result?.action, "stop");
     assert.equal(result?.level, "warning");
     assert.match(result?.reason ?? "", /closeout-consistency-blocked/);
-    assert.match(result?.reason ?? "", /quality gate Q3 is still pending/);
+    assert.match(result?.reason ?? "", /latest milestone validation is "absent"/);
   });
 });
 

package/src/resources/extensions/gsd/tests/dispatch-run-uat-browser-tools.test.ts

@@ -0,0 +1,88 @@
+// Project/App: gsd-pi
+// File Purpose: Regression coverage for run-uat browser tool availability checks.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+type DispatchRuleEntry = (typeof DISPATCH_RULES)[number];
+
+function runUatRule(): DispatchRuleEntry {
+  const rule = DISPATCH_RULES.find((entry) => entry.name === "run-uat (post-completion)");
+  assert.ok(rule, "run-uat dispatch rule must exist");
+  return rule;
+}
+
+function makeState(): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Browser UAT" },
+    activeSlice: { id: "S02", title: "Next Slice" },
+    activeTask: null,
+    phase: "verifying",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+function scaffoldRunUatProject(basePath: string): void {
+  const milestoneDir = join(basePath, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+
+  writeFileSync(join(milestoneDir, "M001-ROADMAP.md"), [
+    "# M001: Browser UAT",
+    "",
+    "## Slices",
+    "",
+    "- [x] **S01: Completed browser slice** `risk:low` `depends:[]`",
+    "- [ ] **S02: Next slice** `risk:low` `depends:[S01]`",
+    "",
+  ].join("\n"), "utf-8");
+
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# S01 Summary\n\nDone.\n", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), [
+    "# S01 UAT",
+    "",
+    "## UAT Type",
+    "- UAT mode: human-experience",
+    "",
+    "Open the app in a browser and verify the completed user flow.",
+    "",
+  ].join("\n"), "utf-8");
+}
+
+function makeContext(basePath: string, overrides: Partial<DispatchContext> = {}): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Browser UAT",
+    state: makeState(),
+    prefs: undefined,
+    activeTools: ["read", "gsd_uat_exec", "gsd_uat_result_save"],
+    ...overrides,
+  };
+}
+
+test("run-uat browser preflight uses registered tools when the active surface is scoped", async (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-run-uat-browser-tools-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  scaffoldRunUatProject(basePath);
+
+  const blocked = await runUatRule().match(makeContext(basePath));
+  assert.equal(blocked?.action, "stop");
+  assert.match(blocked?.action === "stop" ? blocked.reason : "", /run-uat tool surface has none/);
+
+  const dispatched = await runUatRule().match(makeContext(basePath, {
+    registeredTools: ["browser_navigate"],
+  }));
+  assert.equal(dispatched?.action, "dispatch");
+  assert.equal(dispatched?.action === "dispatch" ? dispatched.unitType : undefined, "run-uat");
+  assert.equal(dispatched?.action === "dispatch" ? dispatched.unitId : undefined, "M001/S01");
+});

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -26,6 +26,24 @@ test("filterDoctorIssues keeps project and environment issues in scoped reports"
   );
 });
 
+test("filterDoctorIssues keeps invalid_preferences issues regardless of preferences file scope", () => {
+  // Both global and project preference diagnostics should survive scope filtering.
+  // doctor.ts uses unitId: "project" for all invalid_preferences issues so they
+  // pass through the scope filter the same way other project-level issues do.
+  const issues = [
+    { severity: "error", code: "invalid_preferences", scope: "project", unitId: "project", message: "global PREFERENCES.md parse error", fixable: false },
+    { severity: "error", code: "invalid_preferences", scope: "project", unitId: "project", message: "project PREFERENCES.md parse error", fixable: false },
+    { severity: "error", code: "invalid_preferences", scope: "project", unitId: "global", message: "stale unitId — should be filtered out", fixable: false },
+  ] as const;
+
+  const filtered = filterDoctorIssues([...issues], { scope: "M016", includeWarnings: true });
+  assert.deepEqual(
+    filtered.map((issue) => issue.message),
+    ["global PREFERENCES.md parse error", "project PREFERENCES.md parse error"],
+    "invalid_preferences issues with unitId: project survive scope filtering; unitId: global is dropped",
+  );
+});
+
 test("checkEngineHealth reports db_unavailable when gsd.db exists but the DB is closed", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-db-unavailable-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/execute-summary-save-empty-project.test.ts

@@ -6,7 +6,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { openDatabase, closeDatabase, getAllMilestones } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, getAllMilestones, getArtifact } from "../gsd-db.ts";
+import { parseProject } from "../schemas/parsers.ts";
 import { markApprovalGateVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
 import { executeSummarySave } from "../tools/workflow-tool-executors.ts";
 
@@ -107,3 +108,65 @@ test("executeSummarySave registers milestones when PROJECT.md uses canonical em-
   assert.deepEqual(result.details.registeredMilestones, ["M001", "M002"]);
   assert.equal(getAllMilestones().length, 2);
 });
+
+test("executeSummarySave self-heals the Milestone Sequence when DB already has milestones but content parses zero", async (t) => {
+  const base = setupBase(t);
+
+  // 1) First save registers M001 as complete; DB now holds the milestone with
+  //    authoritative status.
+  const canonical = [
+    "# Project",
+    "",
+    "## Milestone Sequence",
+    "",
+    "<!-- Check off milestones as they complete. -->",
+    "",
+    "- [x] M001: Foo — bar",
+    "",
+  ].join("\n");
+  await inProjectDir(base, () => executeSummarySave({ artifact_type: "PROJECT", content: canonical }, base));
+  assert.equal(getAllMilestones().length, 1);
+
+  // 2) A completion re-save reflows the sequence with an en-dash separator the
+  //    canonical parser rejects → zero parseable lines, but the DB is intact.
+  //    (A trailing non-bullet section prevents MILESTONE_LINE_RE from bridging
+  //    onto a later bullet.) The checkbox here is deliberately WRONG (unchecked)
+  //    to prove the rebuild takes status from the DB, not the malformed content.
+  const malformed = [
+    "# Project",
+    "",
+    "## Milestone Sequence",
+    "",
+    "<!-- Check off milestones as they complete. -->",
+    "",
+    "- [ ] M001: Foo – shipped bar", // en-dash U+2013, not accepted by MILESTONE_LINE_RE
+    "",
+    "## Notes",
+    "",
+    "Trailing prose with no list bullets.",
+    "",
+  ].join("\n");
+
+  const result = await inProjectDir(base, () => executeSummarySave({ artifact_type: "PROJECT", content: malformed }, base));
+
+  // Non-fatal: the save succeeds and reports the self-heal.
+  assert.notEqual(result.isError, true);
+  assert.equal(result.details.milestoneSequenceSelfHealed, true);
+  assert.deepEqual(result.details.registeredMilestones, ["M001"]);
+  assert.equal(getAllMilestones().length, 1);
+
+  // The persisted PROJECT.md now parses canonically and preserves status + prose.
+  const persisted = getArtifact("PROJECT.md");
+  assert.ok(persisted);
+  const parsed = parseProject(persisted!.full_content);
+  assert.equal(parsed.milestones.length, 1);
+  const m001 = parsed.milestones.find(m => m.id === "M001");
+  assert.ok(m001);
+  // Status comes from the DB (M001 complete), not the unchecked box in the
+  // malformed content.
+  assert.equal(m001!.done, true);
+  assert.equal(m001!.title, "Foo");
+  assert.match(m001!.oneLiner, /shipped bar/);
+  // The HTML comment hint survives the rebuild.
+  assert.match(persisted!.full_content, /Check off milestones as they complete/);
+});

package/src/resources/extensions/gsd/tests/execute-task-rendering.test.ts

@@ -38,6 +38,7 @@ test("execute-task prompt renders compact execution and completion gates", async
     planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md",
     taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
     priorTaskLines: "- None",
+    onDemandContext: "",
     skillActivation: "Load relevant skills.",
     inlinedTemplates: "### Output Template: Task Summary\nSource: `templates/task-summary.md`",
     templatesDir: join(fixtureRoot, "templates"),

package/src/resources/extensions/gsd/tests/fixtures/pr-body/swarm-lane-no-blockers.md

@@ -48,8 +48,4 @@ Closes #123
 
 ## Rollback And Compatibility
 
-- Disable writer sequence enrichment
-
-## AI Assistance Disclosure
-
-This PR was prepared with AI assistance.
+- Disable writer sequence enrichment

package/src/resources/extensions/gsd/tests/fixtures/pr-body/swarm-lane-with-blockers.md

@@ -53,8 +53,4 @@ Closes #123
 
 ## Rollback And Compatibility
 
-- Disable writer sequence enrichment
-
-## AI Assistance Disclosure
-
-This PR was prepared with AI assistance.
+- Disable writer sequence enrichment

package/src/resources/extensions/gsd/tests/gate-state-canonicalization.test.ts

@@ -3,7 +3,7 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -18,6 +18,7 @@ import {
   insertSlice,
 } from "../gsd-db.ts";
 import type { GateVerdict } from "../types.ts";
+import { closeQualityGatesFromEvidence } from "../quality-gate-closure.ts";
 
 describe("gate-state canonicalization (#4950)", () => {
   let tmpDir: string;
@@ -99,4 +100,50 @@ describe("gate-state canonicalization (#4950)", () => {
       assert.notEqual(g.verdict, "", `gate ${g.gate_id} verdict must not be empty string`);
     }
   });
+
+  test("closeQualityGatesFromEvidence repairs pending gate from durable section", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    mkdirSync(join(tmpDir, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    writeFileSync(
+      join(tmpDir, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      [
+        "# S01",
+        "",
+        "## Threat Surface",
+        "",
+        "- Credential stuffing is rate-limited.",
+      ].join("\n"),
+    );
+
+    const result = closeQualityGatesFromEvidence("M001", { artifactBasePath: tmpDir });
+
+    assert.deepEqual(result.unresolved, []);
+    assert.deepEqual(result.repaired, [{ gateId: "Q3", sliceId: "S01", verdict: "pass" }]);
+    assert.equal(getPendingGates("M001", "S01").length, 0);
+    assert.equal(getGateResults("M001", "S01")[0].verdict, "pass");
+  });
+
+  test("closeQualityGatesFromEvidence omits stale pending gate after validation pass", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    const result = closeQualityGatesFromEvidence("M001", {
+      artifactBasePath: tmpDir,
+      milestoneValidationPassed: true,
+    });
+
+    assert.deepEqual(result.unresolved, []);
+    assert.deepEqual(result.repaired, [{ gateId: "Q4", sliceId: "S01", verdict: "omitted" }]);
+    assert.equal(getGateResults("M001", "S01")[0].verdict, "omitted");
+  });
+
+  test("closeQualityGatesFromEvidence leaves pending gate unresolved without evidence", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+
+    const result = closeQualityGatesFromEvidence("M001", { artifactBasePath: tmpDir });
+
+    assert.deepEqual(result.repaired, []);
+    assert.equal(result.unresolved.length, 1);
+    assert.equal(result.unresolved[0].gate_id, "Q3");
+    assert.equal(getPendingGates("M001", "S01").length, 1);
+  });
 });