gsd-pi 2.81.0 → 2.82.0-dev.ed17d078d

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,17 +1,21 @@
 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();
   autoSession.active = true;
   autoSession.basePath = "/tmp/project";
   autoSession.orchestration = {
-    async start() { return { kind: "advanced" as const }; },
-    async advance() { return { kind: "advanced" as const }; },
-    async resume() { return { kind: "advanced" as const }; },
-    async stop() { return { kind: "stopped" as const }; },
+    async start() { return { kind: "stopped" as const, reason: "test" }; },
+    async advance() { return { kind: "stopped" as const, reason: "test" }; },
+    async resume() { return { kind: "stopped" as const, reason: "test" }; },
+    async stop() { return { kind: "stopped" as const, reason: "test" }; },
     getStatus() {
       return { phase: "running" as const, transitionCount: 3, lastTransitionAt: 123 };
     },
@@ -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/browser-tools-compatibility-declarations.test.ts

@@ -0,0 +1,62 @@
+// GSD-2 — ADR-005 Phase 2: Verify browser tool compatibility declarations.
+//
+// Locks in the declarations that always-image-producing browser tools
+// (browser_screenshot, browser_zoom_region) carry `producesImages: true` so
+// the model-router filters them out on providers without imageToolResults
+// (OpenAI completions/responses, Azure, Mistral, Ollama). Conditional-image
+// browser tools (navigation, forms, refs, intent, interaction) must NOT
+// declare producesImages — they only attach error screenshots and filtering
+// them would lose the whole tool surface for OpenAI users.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+
+import { registerScreenshotTools } from "../../browser-tools/tools/screenshot.ts";
+import { registerZoomTools } from "../../browser-tools/tools/zoom.ts";
+
+interface CapturedToolDef {
+  name: string;
+  compatibility?: { producesImages?: boolean; schemaFeatures?: string[] };
+}
+
+function makeCapturingPi(): { pi: ExtensionAPI; tools: CapturedToolDef[] } {
+  const tools: CapturedToolDef[] = [];
+  const pi = {
+    registerTool(def: CapturedToolDef): void {
+      tools.push({ name: def.name, compatibility: def.compatibility });
+    },
+  } as unknown as ExtensionAPI;
+  return { pi, tools };
+}
+
+// Browser tool registration functions accept a `deps` object. None of the
+// declarations under test reach for these deps at registration time — they
+// only run inside execute(), which we never invoke. A bare object satisfies
+// the type signature.
+const stubDeps = {} as Parameters<typeof registerScreenshotTools>[1];
+
+test("browser_screenshot declares producesImages: true", () => {
+  const { pi, tools } = makeCapturingPi();
+  registerScreenshotTools(pi, stubDeps);
+  const screenshot = tools.find((t) => t.name === "browser_screenshot");
+  assert.ok(screenshot, "browser_screenshot should be registered");
+  assert.equal(
+    screenshot.compatibility?.producesImages,
+    true,
+    "browser_screenshot must declare producesImages so it is filtered on providers without imageToolResults",
+  );
+});
+
+test("browser_zoom_region declares producesImages: true", () => {
+  const { pi, tools } = makeCapturingPi();
+  registerZoomTools(pi, stubDeps);
+  const zoom = tools.find((t) => t.name === "browser_zoom_region");
+  assert.ok(zoom, "browser_zoom_region should be registered");
+  assert.equal(
+    zoom.compatibility?.producesImages,
+    true,
+    "browser_zoom_region must declare producesImages so it is filtered on providers without imageToolResults",
+  );
+});