gsd-pi 2.81.0 → 2.82.0

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

@@ -2,12 +2,14 @@
 // File Purpose: Behavior tests for auto-loop cleanup after paused provider exits.
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { cleanupAfterLoopExit, rerootCommandSession } from "../auto.ts";
+import { cleanupAfterLoopExit, rerootCommandSession, stopAuto } from "../auto.ts";
 import { autoSession } from "../auto-runtime-state.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { WorktreeLifecycle } from "../worktree-lifecycle.ts";
 
 test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
@@ -41,7 +43,7 @@ test("cleanupAfterLoopExit preserves paused auto badge after provider pause", as
   }
 });
 
-test("cleanupAfterLoopExit clears status and widget when auto is not paused", async () => {
+test("cleanupAfterLoopExit clears status without replacing the last auto surface", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -60,7 +62,16 @@ test("cleanupAfterLoopExit clears status and widget when auto is not paused", as
     } as any);
 
     assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
-    assert.deepEqual(widgetCalls, [["gsd-progress", undefined]]);
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
+      false,
+      "cleanup must not clear the last meaningful auto progress surface",
+    );
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-outcome"),
+      false,
+      "cleanup must not replace the auto deck with a generic loop-ended card",
+    );
     assert.equal(autoSession.active, false);
     assert.equal(autoSession.paused, false);
   } finally {
@@ -68,6 +79,122 @@ test("cleanupAfterLoopExit clears status and widget when auto is not paused", as
   }
 });
 
+test("cleanupAfterLoopExit preserves completion roll-up after stopAuto reset", async () => {
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.completionStopInProgress = true;
+  autoSession.resetAfterStop({ preserveCompletionSurface: true });
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        setHeader: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
+      false,
+      "completion cleanup must not clear the roll-up progress widget",
+    );
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-outcome"),
+      false,
+      "completion cleanup must not replace the roll-up with a generic outcome card",
+    );
+    assert.equal(autoSession.completionStopInProgress, false);
+  } finally {
+    autoSession.reset();
+  }
+});
+
+test("cleanupAfterLoopExit restores project root through lifecycle and preserves chdir", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-lifecycle-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  let restoreCalls = 0;
+  const originalRestore = WorktreeLifecycle.prototype.restoreToProjectRoot;
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
+    restoreCalls += 1;
+    return originalRestore.call(this);
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(restoreCalls, 1);
+    assert.equal(autoSession.basePath, base);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit keeps cleanup best-effort when lifecycle restore throws", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-restore-throw-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  let restoreCalls = 0;
+  // ADR-016 phase 3 (#5693): the real `restoreToProjectRoot` assigns
+  // `s.basePath = s.originalBasePath` BEFORE any throwable work
+  // (rebuildGitService, cache invalidation). Mirror that ordering in the
+  // mock so the throw scenario reflects production: basePath is restored
+  // even when the verb throws partway through.
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
+    restoreCalls += 1;
+    (this as unknown as { s: { basePath: string; originalBasePath: string } })
+      .s.basePath = (this as unknown as { s: { originalBasePath: string } }).s.originalBasePath;
+    throw new Error("restore failed");
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(restoreCalls, 1);
+    assert.equal(autoSession.basePath, base);
+    assert.equal(realpathSync(process.cwd()), realpathSync(base));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("rerootCommandSession refreshes command workspace to project root", async () => {
   const calls: string[] = [];
   const result = await rerootCommandSession(
@@ -83,3 +210,163 @@ test("rerootCommandSession refreshes command workspace to project root", async (
   assert.deepEqual(result, { status: "ok" });
   assert.deepEqual(calls, ["/project/root"]);
 });
+
+test("stopAuto completion closeout reroots session, restores cwd, and preserves final widget", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-completion-stop-"));
+  const previousCwd = process.cwd();
+  const widgetCalls: Array<[string, unknown]> = [];
+  const notifications: string[] = [];
+  const newSessionWorkspaces: string[] = [];
+  let restoreCalls = 0;
+  const originalRestore = WorktreeLifecycle.prototype.restoreToProjectRoot;
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
+    restoreCalls += 1;
+    return originalRestore.call(this);
+  });
+  const milestoneDir = join(base, ".gsd", "milestones", "M003");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "M003-SUMMARY.md"), [
+    "---",
+    "id: M003",
+    'title: "Budget tracking"',
+    "status: complete",
+    "key_decisions:",
+    "  - Keep completion closeout in the same TUI surface.",
+    "key_files:",
+    "  - src/resources/extensions/gsd/auto-dashboard.ts",
+    "lessons_learned:",
+    "  - Milestone endings need report output, not auto-loop status.",
+    "---",
+    "",
+    "# M003: Budget tracking",
+    "",
+    "**Added budget warning output and provider roll-up details.**",
+    "",
+    "## Success Criteria Results",
+    "",
+    "Budget warnings appear at milestone completion.",
+    "",
+    "## Definition of Done Results",
+    "",
+    "Completion leaves the report surface visible.",
+    "",
+    "## Requirement Outcomes",
+    "",
+    "Users can see what shipped without opening a fresh session.",
+    "",
+    "## Deviations",
+    "",
+    "None.",
+    "",
+    "## Follow-ups",
+    "",
+    "None.",
+    "",
+  ].join("\n"), "utf-8");
+
+  autoSession.reset();
+  openDatabase(join(base, "gsd-test.db"));
+  insertMilestone({ id: "M003", title: "Budget tracking", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Complete slice", status: "complete", sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M003", title: "Done slice", status: "done", sequence: 2 });
+  insertSlice({ id: "S03", milestoneId: "M003", title: "Pending slice", status: "active", sequence: 3 });
+
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.basePath = join(base, ".gsd", "worktrees", "M003");
+  autoSession.originalBasePath = base;
+  autoSession.currentMilestoneId = "M003";
+  autoSession.autoStartTime = Date.now() - 60_000;
+  autoSession.cmdCtx = {
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      widgetCalls.push(["gsd-progress", undefined]);
+      return { cancelled: false };
+    },
+    sessionManager: {
+      getEntries: () => [
+        {
+          type: "message",
+          message: {
+            role: "assistant",
+            usage: { input: 100, cacheRead: 900 },
+          },
+        },
+      ],
+    },
+    getContextUsage: () => ({ percent: 0.9, contextWindow: 1_000_000 }),
+    model: { contextWindow: 1_000_000 },
+  } as any;
+
+  try {
+    await stopAuto(
+      {
+        hasUI: true,
+        ui: {
+          setStatus: () => {},
+          setWidget: (key: string, value: unknown) => {
+            widgetCalls.push([key, value]);
+          },
+          setHeader: () => {},
+          notify: (message: string) => {
+            notifications.push(message);
+          },
+        },
+        modelRegistry: { find: () => null },
+      } as any,
+      { events: { emit: () => {} } } as any,
+      "Milestone M003 complete",
+      {
+        completionWidget: {
+          milestoneId: "M003",
+          milestoneTitle: "Budget tracking",
+        },
+      },
+    );
+
+    assert.deepEqual(newSessionWorkspaces, [base], "completion stop must reroot command session to original project root");
+    assert.equal(restoreCalls, 1, "completion stop must restore project root through lifecycle");
+    assert.equal(realpathSync(process.cwd()), realpathSync(base), "completion stop must chdir back to project root");
+    assert.ok(
+      widgetCalls.some(([key, value]) => key === "gsd-progress" && typeof value === "function"),
+      "completion stop must install a final progress widget",
+    );
+    const lastProgressWidget = widgetCalls.filter(([key]) => key === "gsd-progress").at(-1);
+    assert.equal(typeof lastProgressWidget?.[1], "function", "completion stop must leave the final progress widget installed after reroot");
+    const factory = lastProgressWidget?.[1] as any;
+    const component = factory(
+      { requestRender() {} },
+      { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+    );
+    const output = component.render(140).join("\n");
+    assert.match(output, /Milestone M003 roll-up/);
+    assert.match(output, /Outcome/);
+    assert.match(output, /Added budget warning output/);
+    assert.match(output, /Verification/);
+    assert.match(output, /Files: src\/resources\/extensions\/gsd\/auto-dashboard\.ts/);
+    assert.match(output, /Lessons: Milestone endings need report output/);
+    assert.match(output, /2\/3 slices/);
+    assert.match(output, /Next/);
+    assert.match(output, /Review the roll-up/);
+    assert.match(output, /\/gsd auto for next milestone/);
+    assert.doesNotMatch(output, /COMPLETE-MILESTONE/);
+    assert.doesNotMatch(output, /\/gsd auto to resume/);
+    assert.ok(
+      notifications.some(message => message.includes("Milestone M003 complete. Auto-mode finished this milestone.")),
+      "completion stop notification should describe completion, not an aborted pause",
+    );
+    assert.ok(
+      notifications.every(message => !message.includes("/gsd auto to resume")),
+      "completion stop notification must not tell users to resume a finished auto run",
+    );
+    assert.ok(
+      widgetCalls.every(([key, value]) => key !== "gsd-outcome" || value === undefined),
+      "completion stop should use the roll-up as the single final surface",
+    );
+  } finally {
+    try { closeDatabase(); } catch { /* noop */ }
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -1,7 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
+import {
+  autoSession,
+  clearToolInvocationError,
+  getAutoRuntimeSnapshot,
+} from "../auto-runtime-state.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
@@ -28,6 +32,17 @@ test("getAutoRuntimeSnapshot includes orchestration phase when available", () =>
   autoSession.reset();
 });
 
+test("clearToolInvocationError clears stale tool error state for active auto sessions", () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.lastToolInvocationError = "gsd_task_complete: simulated transient tool error";
+
+  clearToolInvocationError();
+
+  assert.equal(autoSession.lastToolInvocationError, null);
+  autoSession.reset();
+});
+
 test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
   autoSession.reset();
 

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -100,6 +100,14 @@ test("bootstrap aborts before starting next milestone when completed orphan merg
         registerSigtermHandler: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
           exitMilestone: (milestoneId: string) => {
             mergeCalls.push(milestoneId);
             return {
@@ -109,6 +117,16 @@ test("bootstrap aborts before starting next milestone when completed orphan merg
             };
           },
           enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          // ADR-016 phase 2 / B4 (#5622): the orphan-merge dance now goes
+          // through `adoptOrphanWorktree`. The mock invokes the callback
+          // and returns its result without exercising the swap-revert
+          // protocol — this test only cares about the merge call being
+          // recorded and the bootstrap returning `false` on failure.
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
         }) as any,
       },
       {

package/src/resources/extensions/gsd/tests/auto-unit-closeout.test.ts

@@ -0,0 +1,68 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for auto-unit closeout activity classification.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  isSuspiciousGhostCompletion,
+  snapshotUnitActivity,
+} from "../auto-unit-closeout.ts";
+
+function makeCtx(entries: unknown[]) {
+  return {
+    sessionManager: {
+      getEntries: () => entries,
+    },
+  } as any;
+}
+
+test("isSuspiciousGhostCompletion rejects fast completions with no assistant output or tools", () => {
+  const startedAt = Date.now();
+  const ctx = makeCtx([]);
+
+  assert.equal(isSuspiciousGhostCompletion(ctx, startedAt, 500), true);
+});
+
+test("isSuspiciousGhostCompletion allows fast completions with assistant output", () => {
+  const startedAt = Date.now();
+  const ctx = makeCtx([
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [{ type: "text", text: "Done." }],
+      },
+    },
+  ]);
+
+  assert.equal(isSuspiciousGhostCompletion(ctx, startedAt, 500), false);
+});
+
+test("snapshotUnitActivity counts assistant messages and tool calls", () => {
+  const ctx = makeCtx([
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Working." },
+          { type: "toolCall", name: "read_file" },
+        ],
+      },
+    },
+    {
+      type: "message",
+      message: {
+        role: "user",
+        content: "continue",
+      },
+    },
+  ]);
+
+  assert.deepEqual(snapshotUnitActivity(ctx, 1_000, 1_250), {
+    elapsedMs: 250,
+    toolCalls: 1,
+    assistantMessages: 1,
+  });
+});

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -182,7 +182,6 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     pruneQueueOrder: () => {},
     isInAutoWorktree: () => false,
     shouldUseWorktreeIsolation: () => false,
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: false }),
     teardownAutoWorktree: () => {},
     createAutoWorktree: () => "/tmp/wt",
     captureIntegrationBranch: () => {},
@@ -420,6 +419,10 @@ describe("Custom engine loop integration", () => {
     await autoLoop(ctx, pi, s, deps);
 
     assert.deepEqual(turnResults, [{ status: "completed", failureClass: "none", error: undefined }]);
+    assert.ok(
+      deps.callLog.includes("journal:iteration-end"),
+      `complete workflow should emit iteration-end; log=${deps.callLog.join(",")}`,
+    );
     assert.ok(
       deps.callLog.indexOf("turnResult:completed") < deps.callLog.indexOf("stopAuto:Workflow complete"),
       `turn should finalize before stopAuto; log=${deps.callLog.join(",")}`,
@@ -472,6 +475,10 @@ describe("Custom engine loop integration", () => {
     assert.equal(turnResults[0].status, "stopped");
     assert.equal(turnResults[0].failureClass, "manual-attention");
     assert.match(turnResults[0].error ?? "", /custom-engine-dispatch-stop/);
+    assert.ok(
+      deps.callLog.includes("journal:iteration-end"),
+      `blocked workflow should emit iteration-end; log=${deps.callLog.join(",")}`,
+    );
     assert.equal(s.currentTraceId, null);
     assert.equal(s.currentTurnId, null);
     assert.equal(pi.calls.length, 0, "blocked workflow should not dispatch a custom step");
@@ -664,11 +671,16 @@ describe("Custom engine loop integration", () => {
       activeRunDir: runDir,
       basePath: runDir,
     });
+    const journalEvents: Array<{ eventType: string; data?: any }> = [];
     const deps = makeMockDeps({
       stopAuto: async (_ctx, _pi, reason) => {
         deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
         s.active = false;
       },
+      emitJournalEvent: (entry: any) => {
+        journalEvents.push(entry);
+        deps.callLog.push(`journal:${entry.eventType}`);
+      },
     });
 
     const resolver = setInterval(() => {
@@ -700,6 +712,21 @@ describe("Custom engine loop integration", () => {
     assert.match(stopEntry ?? "", /requested retry 4 times without passing/);
     const finalGraph = readGraph(runDir);
     assert.equal(finalGraph.steps[0]?.status, "active", "failed verification must not reconcile the step complete");
+
+    const unitEndIndexes = journalEvents
+      .map((entry, index) => entry.eventType === "unit-end" ? index : -1)
+      .filter((index) => index >= 0);
+    const iterationEndIndexes = journalEvents
+      .map((entry, index) => entry.eventType === "iteration-end" ? index : -1)
+      .filter((index) => index >= 0);
+    assert.equal(unitEndIndexes.length, 4, "each custom verification retry/stop attempt must emit unit-end");
+    assert.equal(iterationEndIndexes.length, 4, "each custom verification retry/stop iteration must close after unit-end");
+    for (const [i, unitEndIndex] of unitEndIndexes.entries()) {
+      assert.ok(
+        iterationEndIndexes[i]! > unitEndIndex,
+        `custom verification attempt ${i + 1} should emit iteration-end after unit-end`,
+      );
+    }
   });
 
   it("persists custom verification retry budget across a session restart", async () => {

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -273,7 +273,16 @@ test("deep project setup: bootstrap can start auto-mode without an active milest
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildLifecycle: () => ({}) as any,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+        }) as any,
       },
       {
         classification: "none",
@@ -378,7 +387,16 @@ test("deep project setup: bootstrap continues queued M002 without milestone cont
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildLifecycle: () => ({}) as any,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+        }) as any,
       },
       {
         classification: "none",

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for complete-milestone dispatch guards.
+
 /**
  * dispatch-complete-milestone-guard.test.ts — #4324
  */
@@ -74,3 +77,44 @@ describe("completing-milestone dispatch guard (#4324)", () => {
     assert.equal(result?.unitId, "M001");
   });
 });
+
+describe("complete phase dispatch guard (#5683)", () => {
+  let base = "";
+  const rule = DISPATCH_RULES.find((candidate) => candidate.name === "complete → stop");
+  assert.ok(rule, "complete phase terminal rule should exist");
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
+  });
+
+  test("dispatches complete-milestone when derived state is complete but DB milestone is still open", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "in_progress" });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
+  });
+
+  test("stops when derived state is complete and DB milestone is closed", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "stop");
+    assert.equal(result?.reason, "All milestones complete.");
+  });
+});

package/src/resources/extensions/gsd/tests/header-renderer.test.ts

@@ -0,0 +1,40 @@
+// Project/App: GSD-2
+// File Purpose: Visual contract tests for the GSD watch header renderer.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { stripVTControlCharacters } from "node:util";
+import { renderHeaderLines } from "../watch/header-renderer.ts";
+import { splashPalette } from "../watch/splash-palette.ts";
+
+function rgbPattern(hex: string): RegExp {
+  const cleaned = hex.replace("#", "");
+  const r = Number.parseInt(cleaned.slice(0, 2), 16);
+  const g = Number.parseInt(cleaned.slice(2, 4), 16);
+  const b = Number.parseInt(cleaned.slice(4, 6), 16);
+  return new RegExp(`\\x1b\\[38;2;${r};${g};${b}m`);
+}
+
+test("renderHeaderLines uses the command-center splash layout", () => {
+  const lines = renderHeaderLines(
+    {
+      model: "claude-sonnet-4-6",
+      provider: "anthropic",
+      directory: "~/Github/gsd-2",
+      branch: "feat/tui-refresh",
+      mcpServers: ["context7"],
+    },
+    120,
+  );
+
+  const raw = lines.join("\n");
+  const plain = stripVTControlCharacters(raw);
+
+  assert.match(raw, rgbPattern(splashPalette.border), "logo and divider should use the recommended olive border");
+  assert.match(raw, rgbPattern(splashPalette.accent), "header accents should use the recommended blue");
+  assert.match(plain, /Project Console/);
+  assert.match(plain, /\/gsd start/);
+  assert.match(plain, /\/gsd templates/);
+  assert.match(plain, /claude-sonnet-4-6/);
+  assert.match(plain, /Context7 ✓/);
+});

package/src/resources/extensions/gsd/tests/headless-milestone-parity.test.ts

@@ -85,6 +85,11 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /Do not announce the ready phrase as something you are "about to" do/.test(section),
       "single-milestone pre-condition must include the 'do not announce intent' guard",
     );
+    assert.ok(/Next steps:/.test(section), "single-milestone handoff must include next steps");
+    assert.ok(/\/gsd auto/.test(section), "single-milestone handoff must mention /gsd auto");
+    assert.ok(/\/gsd status/.test(section), "single-milestone handoff must mention /gsd status");
+    assert.ok(/\/gsd visualize/.test(section), "single-milestone handoff must mention /gsd visualize");
+    assert.ok(/\/gsd notifications/.test(section), "single-milestone handoff must mention /gsd notifications");
   });
 
   test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
@@ -113,5 +118,10 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /gates_completed === total/.test(multiSection),
       "multi-milestone pre-condition must still enforce gates_completed === total",
     );
+    assert.ok(/Next steps:/.test(multiSection), "multi-milestone handoff must include next steps");
+    assert.ok(/\/gsd auto/.test(multiSection), "multi-milestone handoff must mention /gsd auto");
+    assert.ok(/\/gsd status/.test(multiSection), "multi-milestone handoff must mention /gsd status");
+    assert.ok(/\/gsd visualize/.test(multiSection), "multi-milestone handoff must mention /gsd visualize");
+    assert.ok(/\/gsd notifications/.test(multiSection), "multi-milestone handoff must mention /gsd notifications");
   });
 });