gsd-pi 2.81.0 → 2.82.0

package/src/resources/extensions/gsd/tests/notifications-handler.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Tests for /gsd notifications command handling and overlay launch behavior.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { join } from "node:path";
@@ -58,6 +61,47 @@ test("notifications command falls back to text output when overlay returns undef
   assert.match(notices[0].message, /Recent notifications:/);
 });
 
+test("notifications command opens a compact bounded overlay", async (t) => {
+  const base = makeTempDir("overlay-options");
+  initNotificationStore(base);
+  appendNotification("Build complete", "success");
+
+  t.after(() => {
+    _resetNotificationStore();
+    cleanup(base);
+  });
+
+  const notices: Array<{ message: string; level?: string }> = [];
+  let capturedOptions: any;
+  await handleNotificationsCommand(
+    "",
+    {
+      hasUI: true,
+      ui: {
+        custom: async (_factory: any, options: any) => {
+          capturedOptions = options;
+          return true;
+        },
+        notify: (message: string, level?: string) => {
+          notices.push({ message, level });
+        },
+      },
+    } as any,
+    {} as any,
+  );
+
+  assert.deepEqual(capturedOptions?.overlayOptions, {
+    width: "58%",
+    minWidth: 68,
+    maxHeight: "52%",
+    anchor: "top-center",
+    row: "24%",
+    margin: { top: 2, right: 2, bottom: 6, left: 2 },
+    backdrop: true,
+  });
+  assert.equal(notices.length, 0, "successful overlay should not emit text fallback");
+});
+
 test("notifications tail caps inline output and hints to open overlay", async (t) => {
   const base = makeTempDir("tail-cap");
   initNotificationStore(base);

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -33,43 +33,6 @@ import {
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
-import {
-  WorktreeLifecycle,
-  type WorktreeLifecycleDeps,
-  type NotifyCtx,
-} from "../worktree-lifecycle.ts";
-import { WorktreeStateProjection } from "../worktree-state-projection.ts";
-import { resolveWorktreeProjectRoot } from "../worktree-root.ts";
-import { AutoSession } from "../auto/session.ts";
-
-// Test-local: LegacyTestDeps had three fields Lifecycle does not need
-// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
-// Permit them in test fixtures so existing override patterns keep working —
-// Lifecycle ignores the extras via structural typing.
-type LegacyTestDeps = WorktreeLifecycleDeps & {
-  shouldUseWorktreeIsolation?: () => boolean;
-  syncWorktreeStateBack?: (
-    mainBasePath: string,
-    worktreePath: string,
-    milestoneId: string,
-  ) => { synced: string[] };
-  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
-};
-
-/** Shim factory preserving the legacy WorktreeResolver throw shape for tests. */
-function makeResolver(s: AutoSession, deps: LegacyTestDeps) {
-  const lifecycle = new WorktreeLifecycle(s, deps);
-  return {
-    get workPath(): string { return s.basePath; },
-    get projectRoot(): string {
-      return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
-    },
-    mergeAndExit: (mid: string, ctx: NotifyCtx) => {
-      const r = lifecycle.exitMilestone(mid, { merge: true }, ctx);
-      if (!r.ok && r.cause instanceof Error) throw r.cause;
-    },
-  };
-}
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -91,97 +54,6 @@ function createTempRepo(t: { after: (fn: () => void) => void }): string {
   return dir;
 }
 
-function makeSession(overrides?: Partial<{ basePath: string; originalBasePath: string }>): AutoSession {
-  const s = new AutoSession();
-  s.basePath = overrides?.basePath ?? "/project";
-  s.originalBasePath = overrides?.originalBasePath ?? "/project";
-  return s;
-}
-
-interface CallLog { fn: string; args: unknown[] }
-
-function makeDeps(overrides?: Partial<LegacyTestDeps>): LegacyTestDeps & { calls: CallLog[] } {
-  const calls: CallLog[] = [];
-
-  const deps: LegacyTestDeps & { calls: CallLog[] } = {
-    calls,
-    isInAutoWorktree: (basePath: string) => {
-      calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-      return basePath.includes("worktrees");
-    },
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: (basePath: string, milestoneId: string, roadmapContent: string) => {
-      calls.push({ fn: "mergeMilestoneToMain", args: [basePath, milestoneId, roadmapContent] });
-      return { pushed: false, codeFilesChanged: true };
-    },
-    syncWorktreeStateBack: (mainBasePath: string, worktreePath: string, milestoneId: string) => {
-      calls.push({ fn: "syncWorktreeStateBack", args: [mainBasePath, worktreePath, milestoneId] });
-      return { synced: [] };
-    },
-    teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-      calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-    },
-    createAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "createAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    enterAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "enterAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    getAutoWorktreePath: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "getAutoWorktreePath", args: [basePath, milestoneId] });
-      return null;
-    },
-    autoCommitCurrentBranch: (basePath: string, reason: string, milestoneId: string) => {
-      calls.push({ fn: "autoCommitCurrentBranch", args: [basePath, reason, milestoneId] });
-    },
-    getCurrentBranch: (basePath: string) => {
-      calls.push({ fn: "getCurrentBranch", args: [basePath] });
-      return "main";
-    },
-    checkoutBranch: (basePath: string, branch: string) => {
-      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
-    },
-    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
-    resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-      calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-      return null;
-    },
-    readFileSync: (path: string, _enc: string) => {
-      calls.push({ fn: "readFileSync", args: [path] });
-      return "# Roadmap\n";
-    },
-    GitServiceImpl: class {
-      constructor(_basePath: string, _gitConfig: unknown) {}
-    } as unknown as LegacyTestDeps["GitServiceImpl"],
-    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
-    invalidateAllCaches: () => { calls.push({ fn: "invalidateAllCaches", args: [] }); },
-    captureIntegrationBranch: (_basePath: string, _mid: string | undefined) => {},
-    enterBranchModeForMilestone: (_basePath: string, _milestoneId: string) => {},
-    worktreeProjection: new WorktreeStateProjection(),
-    ...overrides,
-  };
-
-  if (overrides) {
-    for (const [key, val] of Object.entries(overrides)) {
-      if (key !== "calls") (deps as unknown as Record<string, unknown>)[key] = val;
-    }
-  }
-  return deps;
-}
-
-function makeNotifyCtx(): NotifyCtx & { messages: Array<{ msg: string; level?: string }> } {
-  const messages: Array<{ msg: string; level?: string }> = [];
-  return {
-    messages,
-    notify: (msg: string, level?: "info" | "warning" | "error" | "success") => {
-      messages.push({ msg, level });
-    },
-  };
-}
-
 // ─── Suite 1: getAutoWorktreeOriginalBase() returns realpath-canonical path ──
 
 describe("getAutoWorktreeOriginalBase() is realpath-normalised", () => {
@@ -273,92 +145,15 @@ describe("normalizeWorktreePathForCompare equalises canonical vs non-canonical f
 // resolveMilestoneFile call against the "worktree" path that is actually the
 // same directory). The new code correctly skips the fallback.
 
-describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physical path as originalBase", () => {
-  test("with trailing-slash basePath equal to originalBase: resolveMilestoneFile called once", () => {
-    // originalBase is canonical (as returned by workspace registry)
-    const canonicalBase = "/tmp/m5-test-project";
-    // s.basePath has a trailing slash — same physical dir, non-canonical string
-    const trailingSlashBase = canonicalBase + "/";
-
-    const s = makeSession({
-      basePath: trailingSlashBase,
-      originalBasePath: canonicalBase,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      // isInAutoWorktree: basePath has trailing slash but is NOT a worktree
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return false;
-      },
-      // resolveMilestoneFile always returns null (no roadmap found)
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null;
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-
-    // Override calls ref so we can inspect it directly
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    // mergeAndExit → _mergeWorktreeMode
-    // originalBase = s.originalBasePath = canonicalBase
-    // s.basePath = trailingSlashBase — physically same as canonicalBase
-    // Post-fix: isSamePath(trailingSlashBase, canonicalBase) is true
-    //   → roadmap fallback branch is skipped (resolveMilestoneFile called once)
-    // Pre-fix (bug): trailingSlashBase !== canonicalBase → fallback entered
-    //   → resolveMilestoneFile called twice
-
-    resolver.mergeAndExit("M001", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 1,
-      "resolveMilestoneFile must be called exactly once — fallback should be skipped when " +
-      "s.basePath is the same physical path as originalBase (isSamePath fix)");
-  });
-
-  test("with genuinely different basePath (inside worktree): resolveMilestoneFile called twice", () => {
-    // originalBase is the project root
-    const projectRoot = "/tmp/m5-test-project";
-    // s.basePath is inside a worktree — a physically different path
-    const worktreePath = projectRoot + "/.gsd/worktrees/M002";
-
-    const s = makeSession({
-      basePath: worktreePath,
-      originalBasePath: projectRoot,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return basePath.includes("worktrees");
-      },
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null; // no roadmap in either location
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    resolver.mergeAndExit("M002", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 2,
-      "resolveMilestoneFile must be called twice when basePath is a genuine worktree path " +
-      "(fallback should run for different physical paths)");
-  });
-});
+// ADR-016 phase 2 / C2 + C3 (#5625, #5626): the prior two tests in this
+// suite asserted call counts on `deps.resolveMilestoneFile` /
+// `deps.isInAutoWorktree` / `deps.teardownAutoWorktree` to verify that the
+// roadmap-fallback branch was skipped when basePath was a non-canonical
+// form of originalBase (trailing slash). After C2/C3 those fields are
+// inlined into worktree-lifecycle.ts as direct imports — the mocks no
+// longer fire and the call-count assertions test nothing meaningful. The
+// underlying invariant (isSamePathPhysical normalises trailing slashes,
+// canonical/non-canonical pairs, and case differences) is preserved
+// inside worktree-lifecycle.ts and covered indirectly by the merge-area
+// integration tests, which exercise real worktree merges where the
+// fallback choice matters.

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -1,11 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for parallel monitor overlay rendering and input handling.
+
 import { describe, it } from "node:test";
-import assert from "node:assert";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
 
-/**
- * Basic tests for the parallel monitor overlay data helpers.
- * The overlay is primarily a rendering component that reads existing
- * status files — these tests verify the helper logic in isolation.
- */
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
 
 describe("parallel-monitor-overlay", () => {
   it("progressBar generates correct width", async () => {
@@ -37,6 +45,7 @@ describe("parallel-monitor-overlay", () => {
     const lines = overlay.render(80);
     assert.ok(Array.isArray(lines), "render should return an array");
     assert.ok(lines.length > 0, "render should return at least one line");
+    assertLinesFit(lines, 80);
 
     // Should contain header text
     const joined = lines.join("\n");
@@ -79,4 +88,27 @@ describe("parallel-monitor-overlay", () => {
     assert.equal((overlay as any).scrollOffset, 0, "empty overlays clamp scroll to zero");
     overlay.dispose();
   });
+
+  it("ParallelMonitorOverlay empty state fits narrow and wide widths", async () => {
+    const mod = await import("../parallel-monitor-overlay.js");
+
+    const mockTui = { requestRender: () => {} };
+    const mockTheme = {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const overlay = new mod.ParallelMonitorOverlay(
+      mockTui,
+      mockTheme as any,
+      () => {},
+      "/nonexistent/path",
+    );
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
+    }
+
+    overlay.dispose();
+  });
 });

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -250,14 +250,14 @@ describe("Post-execution blocking failure retry bypass", () => {
     const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
     
     // Pre-set some retry state
-    s.verificationRetryCount.set("M001/S01/T01", 2);
+    s.verificationRetryCount.set("execute-task:M001/S01/T01", 2);
 
     const vctx: VerificationContext = { s, ctx, pi };
     const result = await runPostUnitVerification(vctx, pauseAutoMock);
 
     // On success, retry count should be cleared
     assert.equal(result, "continue");
-    assert.equal(s.verificationRetryCount.has("M001/S01/T01"), false);
+    assert.equal(s.verificationRetryCount.has("execute-task:M001/S01/T01"), false);
   });
 
   test("post-exec failure notification mentions cross-task consistency", async () => {

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -14,9 +14,9 @@ import {
   insertMilestone,
   insertSlice,
   setSliceSketchFlag,
-  autoHealSketchFlags,
   getSlice,
 } from "../gsd-db.ts";
+import { autoHealSketchFlags } from "../state-reconciliation/drift/sketch-flag.ts";
 import { deriveStateFromDb } from "../state.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -64,6 +64,16 @@ test("discuss prompt allows implementation questions when they materially matter
   assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
 });
 
+test("discuss prompt ends milestone planning with next-step handoff", () => {
+  const prompt = readPrompt("discuss");
+  assert.match(prompt, /Next steps:/);
+  assert.match(prompt, /\/gsd auto/);
+  assert.match(prompt, /\/gsd status/);
+  assert.match(prompt, /\/gsd visualize/);
+  assert.match(prompt, /\/gsd notifications/);
+  assert.doesNotMatch(prompt, /nothing else\. Auto-mode will start automatically/);
+});
+
 test("guided discussion prompts avoid wrap-up prompts after every round", () => {
   const milestonePrompt = readPrompt("guided-discuss-milestone");
   const slicePrompt = readPrompt("guided-discuss-slice");
@@ -217,6 +227,17 @@ test("complete-slice prompt does not instruct LLM to toggle checkboxes manually"
   assert.doesNotMatch(prompt, /change \[ \] to \[x\]/);
 });
 
+test("complete-slice prompt keeps source fixes in execution units", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(prompt, /Do not use direct `bash` for verification commands/i);
+  assert.match(prompt, /do \*\*not\*\* edit source files in this unit/i);
+  assert.match(prompt, /do \*\*not\*\* call `gsd_slice_complete`/i);
+  assert.match(prompt, /gsd_task_reopen/);
+  assert.match(prompt, /gsd_replan_slice/);
+  assert.match(prompt, /needs execution follow-up/i);
+  assert.doesNotMatch(prompt, /Fix failures before marking done/i);
+});
+
 test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
@@ -363,7 +384,9 @@ test("execute-task prompt uses camelCase parameter names matching TypeBox schema
 test("complete-slice prompt uses camelCase parameter names matching TypeBox schema", () => {
   const prompt = readPrompt("complete-slice");
   // The gsd_complete_slice tool schema uses camelCase: milestoneId, sliceId
-  const toolCallLine = prompt.split("\n").find((l) => /gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l));
+  const toolCallLine = prompt.split("\n").find((l) =>
+    (/gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l)) && /milestoneId/.test(l) && /sliceId/.test(l)
+  );
   assert.ok(toolCallLine, "prompt must contain a gsd_complete_slice or gsd_slice_complete tool call line");
   assert.doesNotMatch(toolCallLine!, /milestone_id/, "must use milestoneId, not milestone_id");
   assert.doesNotMatch(toolCallLine!, /slice_id/, "must use sliceId, not slice_id");

package/src/resources/extensions/gsd/tests/resume-dispatch-worktree.test.ts

@@ -10,7 +10,11 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { _resolvePausedResumeBasePathForTest } from "../auto.ts";
+// ADR-016 phase 2 / B3 (#5621): the legacy `resolvePausedResumeBasePath`
+// helper was retired and folded into `WorktreeLifecycle.resumeFromPausedSession`.
+// The pure path-resolution function lives in `worktree-lifecycle.ts` for tests
+// that exercise the path-resolution invariant without constructing a session.
+import { resolvePausedResumeBasePath } from "../worktree-lifecycle.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-resume-wt-${randomUUID()}`);
@@ -59,7 +63,7 @@ test("resume base path uses paused-session worktreePath when the worktree exists
   try {
     setupWorktreeOnDisk(wt);
     assert.equal(
-      _resolvePausedResumeBasePathForTest(base, wt),
+      resolvePausedResumeBasePath(base, wt),
       wt,
     );
   } finally {
@@ -72,7 +76,7 @@ test("resume base path falls back to project root when paused worktree is missin
   const wt = makeWorktreePath(base, "M001-test");
   try {
     assert.equal(
-      _resolvePausedResumeBasePathForTest(base, wt),
+      resolvePausedResumeBasePath(base, wt),
       base,
     );
   } finally {

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -42,16 +42,19 @@ test("State Reconciliation invalidates cache and returns reconciled state", asyn
   assert.equal(result.ok && result.stateSnapshot, state);
 });
 
-test("State Reconciliation blocks when derived state carries blockers", async () => {
+test("State Reconciliation surfaces terminal blockers in result (ADR-017)", async () => {
+  // Under ADR-017, blockers are terminal but do not throw — they ride along
+  // in the result so the orchestrator adapter can map them to ok=false.
   const result = await reconcileBeforeDispatch("/project", {
     invalidateStateCache() {},
     async deriveState() {
       return makeState({ phase: "blocked", blockers: ["slice lock missing"] });
     },
+    registry: [],
   });
 
-  assert.equal(result.ok, false);
-  assert.equal(!result.ok && result.reason, "slice lock missing");
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["slice lock missing"]);
 });
 
 test("Tool Contract compiles known Unit prompt and tool policy", () => {

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -188,6 +188,30 @@ test("empty-content aborted during session-switch is silently ignored", () => {
   assert.equal(cancelledWith, null);
 });
 
+test("completed assistant content with aborted stopReason during session-switch is ignored", () => {
+  // newSession() can abort the just-finished provider stream while the last
+  // assistant message still carries the completed unit summary. That is a
+  // session-transition artifact, not a cancellation for the next unit.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{
+        type: "text",
+        text: "Implemented T01 and verified the slice task is complete.",
+      }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
 test("non-abort errors during session-switch are not propagated through this helper", () => {
   // Real provider errors (rate-limit, network, unsupported-model) are handled
   // by the post-switch retry pipeline — not by the in-flight switch handler.