gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import { autoLoop } from "../auto/loop.js";
 import { resolveAgentEnd, _hasPendingResolveForTest, _resetPendingResolve } from "../auto/resolve.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
+import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import type { SessionLockStatus } from "../session-lock.js";
 import { writeGraph, readGraph, type WorkflowGraph, type GraphStep } from "../graph.ts";
 import { writeFileSync } from "node:fs";
@@ -172,7 +173,6 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     rebuildState: async () => {},
     loadEffectiveGSDPreferences: () => undefined,
     preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
-    syncProjectRootToWorktree: () => {},
     checkResourcesStale: () => null,
     validateSessionLock: () => ({ valid: true } as SessionLockStatus),
     updateSessionLock: () => {},
@@ -192,7 +192,11 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => null,
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,
@@ -224,15 +228,19 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     readFileSync: () => "",
     atomicWriteSync: () => {},
     GitServiceImpl: class {} as any,
-    resolver: {
-      get workPath() { return "/tmp/project"; },
-      get projectRoot() { return "/tmp/project"; },
-      get lockPath() { return "/tmp/project"; },
-      enterMilestone: () => {},
-      exitMilestone: () => {},
-      mergeAndExit: () => {},
-      mergeAndEnterNext: () => {},
+    lifecycle: {
+      enterMilestone: () => ({ ok: true, mode: "none", path: "/tmp/project" }),
+      exitMilestone: (_mid: string, opts: { merge: boolean }) => ({
+        ok: true,
+        merged: opts.merge,
+        codeFilesChanged: false,
+      }),
+      degradeToBranchMode: () => {},
+      restoreToProjectRoot: () => {},
+      isInMilestone: () => true,
+      getCurrentMilestoneIfAny: () => "M001",
     } as any,
+    worktreeProjection: new WorktreeStateProjection(),
     postUnitPreVerification: async () => "continue" as const,
     runPostUnitVerification: async () => "continue" as const,
     postUnitPostVerification: async () => "continue" as const,

package/src/resources/extensions/gsd/tests/cwd-fallback-hardening.test.ts

@@ -0,0 +1,138 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for deleted-cwd fallback handling.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import { registerDynamicTools, ensureDbOpen, safeWorkspaceCwd } from "../bootstrap/dynamic-tools.ts";
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { registerJournalTools } from "../bootstrap/journal-tools.ts";
+import { registerMemoryTools } from "../bootstrap/memory-tools.ts";
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+
+async function withDeletedCwd(fn: (projectRoot: string) => Promise<void> | void): Promise<void> {
+  const previousCwd = process.cwd();
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-safe-cwd-project-"));
+  const removedCwd = mkdtempSync(join(tmpdir(), "gsd-removed-cwd-"));
+
+  process.env.GSD_PROJECT_ROOT = projectRoot;
+  process.chdir(removedCwd);
+  rmSync(removedCwd, { recursive: true, force: true });
+
+  try {
+    assert.throws(() => process.cwd(), /ENOENT/);
+    await fn(projectRoot);
+  } finally {
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+}
+
+function collectTools(register: (pi: any) => void): any[] {
+  const tools: any[] = [];
+  register({
+    registerTool(tool: any) {
+      tools.push(tool);
+    },
+  });
+  return tools;
+}
+
+test("safeWorkspaceCwd falls back to captured project root when cwd was removed", async () => {
+  await withDeletedCwd((projectRoot) => {
+    assert.equal(safeWorkspaceCwd(), projectRoot);
+  });
+});
+
+test("ensureDbOpen default path does not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    assert.equal(await ensureDbOpen(), false);
+  });
+});
+
+test("dynamic tools register when cwd was removed", async () => {
+  await withDeletedCwd(() => {
+    const tools = collectTools(registerDynamicTools);
+    assert.equal(tools.length, 4);
+  });
+});
+
+test("db-backed tool fallbacks return normal unavailable-db errors when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const tools = collectTools(registerDbTools);
+    const decisionSave = tools.find((tool) => tool.name === "gsd_decision_save");
+
+    const result = await decisionSave.execute(
+      "call-1",
+      {
+        scope: "test",
+        decision: "Handle deleted cwd",
+        choice: "Use captured project root",
+        rationale: "The worktree cwd may disappear during cleanup.",
+      },
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    assert.equal(result.details.error, "db_unavailable");
+  });
+});
+
+test("memory and query tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const memoryTools = collectTools(registerMemoryTools);
+    const queryTools = collectTools(registerQueryTools);
+
+    await assert.doesNotReject(() =>
+      memoryTools.find((tool) => tool.name === "memory_query").execute(
+        "call-1",
+        { query: "cwd fallback" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      queryTools.find((tool) => tool.name === "gsd_milestone_status").execute(
+        "call-2",
+        { milestoneId: "M001" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});
+
+test("journal and exec tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const journalTools = collectTools(registerJournalTools);
+    const execTools = collectTools(registerExecTools);
+
+    await assert.doesNotReject(() =>
+      journalTools.find((tool) => tool.name === "gsd_journal_query").execute(
+        "call-1",
+        { limit: 1 },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      execTools.find((tool) => tool.name === "gsd_resume").execute(
+        "call-2",
+        {},
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});

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

@@ -1,21 +1,12 @@
 /**
- * dashboard-custom-engine.test.ts — Tests that the custom engine path
- * calls updateProgressWidget and that unitLabel handles "custom-step".
- *
- * Uses source-level assertions for the non-exported unitLabel function
- * and the updateProgressWidget call placement. Tests exported helpers
- * (unitVerb, unitPhaseLabel) directly.
+ * dashboard-custom-engine.test.ts — custom-step dashboard labels.
  */
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { unitVerb, unitPhaseLabel } from "../auto-dashboard.js";
-
-// ─── Tests ───────────────────────────────────────────────────────────────
+import { unitLabel } from "../dashboard-overlay.ts";
 
 describe("Dashboard custom-engine: unitLabel and related helpers", () => {
   it('unitVerb("custom-step") returns "executing workflow step"', () => {
@@ -26,62 +17,7 @@ describe("Dashboard custom-engine: unitLabel and related helpers", () => {
     assert.equal(unitPhaseLabel("custom-step"), "WORKFLOW");
   });
 
-  it('dashboard-overlay.ts contains a case for "custom-step" returning "Workflow Step"', () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const overlayPath = resolve(__filename, "../../dashboard-overlay.ts");
-    const source = readFileSync(overlayPath, "utf-8");
-    assert.ok(
-      source.includes('"custom-step"') && source.includes('"Workflow Step"'),
-      'dashboard-overlay.ts should contain case "custom-step": return "Workflow Step"',
-    );
-  });
-});
-
-describe("Dashboard custom-engine: updateProgressWidget in custom engine path", () => {
-  it("loop.ts custom engine path includes updateProgressWidget call before runGuards", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    // Find the custom engine block
-    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
-    assert.ok(customEngineStart > -1, "Should find custom engine path in loop.ts");
-
-    // The updateProgressWidget call should appear after the custom engine block start
-    // and before the runGuards call in that block
-    const afterCustomEngine = source.slice(customEngineStart);
-    const widgetCallIndex = afterCustomEngine.indexOf(
-      "deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state)",
-    );
-    const guardsCallIndex = afterCustomEngine.indexOf("runGuards(ic,");
-    assert.ok(widgetCallIndex > -1, "updateProgressWidget should be called in custom engine path");
-    assert.ok(
-      widgetCallIndex < guardsCallIndex,
-      "updateProgressWidget should be called before runGuards in custom engine path",
-    );
-  });
-
-  it("updateProgressWidget call is placed after iterData is built", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
-    const afterCustomEngine = source.slice(customEngineStart);
-
-    // Verify custom engine path has iterData built before the widget call
-    const iterDataIndex = afterCustomEngine.indexOf("buildCustomEngineIterationData({");
-    const widgetIndex = afterCustomEngine.indexOf("deps.updateProgressWidget");
-    assert.ok(iterDataIndex > -1 && widgetIndex > -1, "Both iterData and widget call should exist");
-    assert.ok(
-      iterDataIndex < widgetIndex,
-      "iterData should be built before updateProgressWidget is called",
-    );
-
-    // Verify the call uses iterData.state (which holds the derived GSD state)
-    assert.ok(
-      afterCustomEngine.includes("iterData.state"),
-      "Custom engine updateProgressWidget should reference iterData.state",
-    );
+  it('unitLabel("custom-step") returns "Workflow Step"', () => {
+    assert.equal(unitLabel("custom-step"), "Workflow Step");
   });
 });

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

@@ -20,6 +20,7 @@ import {
   clearPendingAutoStart,
   checkDeepProjectSetupAfterTurn,
   clearPendingDeepProjectSetup,
+  FOREGROUND_DEEP_SETUP_RULE_NAMES,
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
@@ -272,7 +273,7 @@ test("deep project setup: bootstrap can start auto-mode without an active milest
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildResolver: () => ({}) as any,
+        buildLifecycle: () => ({}) as any,
       },
       {
         classification: "none",
@@ -377,7 +378,7 @@ test("deep project setup: bootstrap continues queued M002 without milestone cont
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildResolver: () => ({}) as any,
+        buildLifecycle: () => ({}) as any,
       },
       {
         classification: "none",
@@ -1013,15 +1014,9 @@ test("deep project setup: same project advances when agent_end session id change
 });
 
 test("deep project setup: foreground dispatcher does not probe research-project rule", () => {
-  const source = readFileSync(new URL("../guided-flow.ts", import.meta.url), "utf-8");
-  const match = source.match(/const FOREGROUND_DEEP_SETUP_RULE_NAMES = new Set\(\[([\s\S]*?)\]\);/);
-  assert.ok(match, "foreground deep setup rule allowlist should be present");
-  assert.doesNotMatch(
-    match![1]!,
-    /research-project/,
-    "foreground setup must not evaluate research-project because that rule claims the inflight marker",
-  );
-  assert.match(source, /research-project have dispatch-time side effects/);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT) → discuss-project"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no research decision) → research-decision"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT research) → research-project"), false);
 });
 
 test("deep project setup: project-level units verify their real artifacts", () => {

package/src/resources/extensions/gsd/tests/deferred-milestone-dir-4996.test.ts

@@ -1,14 +1,10 @@
 // GSD Extension — Regression test for #4996: deferred milestone dir creation
-// Verifies that showHeadlessMilestoneCreation does not pre-create the milestone
-// directory before the discuss flow runs. The dir should only appear after a
-// writer (saveArtifactToDb / atomicWriteAsync) emits the first artifact.
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, existsSync, rmSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdtempSync, mkdirSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
 import { isReusableGhostMilestone } from "../state.ts";
 import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
@@ -16,47 +12,12 @@ import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts
 import { invalidateAllCaches } from "../cache.ts";
 import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
-
-function getShowHeadlessBody(): string {
-  const source = readFileSync(GUIDED_FLOW_PATH, "utf-8");
-  const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
-  assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist in guided-flow.ts");
-  const nextExport = source.indexOf("\nexport ", fnStart + 1);
-  return source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
-}
-
 function makeBase(prefix = "gsd-deferred-dir-"): string {
   const base = mkdtempSync(join(tmpdir(), prefix));
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
   return base;
 }
 
-describe("showHeadlessMilestoneCreation source guard (#4996)", () => {
-  it("does not call mkdirSync in the headless milestone creation path", () => {
-    const body = getShowHeadlessBody();
-    assert.doesNotMatch(
-      body,
-      /\bmkdirSync\s*\(/,
-      "showHeadlessMilestoneCreation must not pre-create milestone directories",
-    );
-  });
-
-  it("does not call mkdir or mkdirp before dispatchWorkflow", () => {
-    const body = getShowHeadlessBody();
-    const dispatchIdx = body.indexOf("dispatchWorkflow");
-    assert.ok(dispatchIdx > -1, "dispatchWorkflow must be present");
-
-    const beforeDispatch = body.slice(0, dispatchIdx);
-    assert.doesNotMatch(
-      beforeDispatch,
-      /\b(?:mkdir|mkdirp)\s*\(/,
-      "showHeadlessMilestoneCreation must defer directory creation until artifact write",
-    );
-  });
-});
-
 describe("deferred milestone dir creation (#4996)", () => {
   let base: string;
 
@@ -74,43 +35,31 @@ describe("deferred milestone dir creation (#4996)", () => {
   it("(a) fresh project: milestones dir has no M001 entry before any discuss flow", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should choose M001 for a fresh project");
+    assert.equal(nextId, "M001");
 
     const ids = findMilestoneIds(base);
-    assert.equal(ids.length, 0, "no milestone dirs should exist before any discuss flow");
-
-    // And specifically M001 should not exist
-    const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "M001 dir must not exist before the discuss flow runs");
+    assert.equal(ids.length, 0);
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M001")));
   });
 
-  it("(b) abandoned discuss flow leaves no orphan: isReusableGhostMilestone returns false for non-existent dir", () => {
+  it("(b) abandoned discuss flow leaves no orphan", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should not require a pre-created directory");
+    assert.equal(nextId, "M001");
 
     const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "no M001 dir should exist");
-    assert.equal(isReusableGhostMilestone(base, "M001"), false, "non-existent milestone should not be reusable");
-    // findMilestoneIds only returns dirs that exist
-    const ids = findMilestoneIds(base);
-    assert.ok(!ids.includes("M001"), "M001 should not appear in findMilestoneIds when no dir exists");
+    assert.ok(!existsSync(m001Dir));
+    assert.equal(isReusableGhostMilestone(base, "M001"), false);
+    assert.ok(!findMilestoneIds(base).includes("M001"));
   });
 
-  it("(c) a stub dir left from a previous bug IS reusable but a newly-generated ID with no dir is not in the ghost list", () => {
+  it("(c) a stub dir left from a previous bug is reusable", () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
-    // Create a stub to represent a pre-existing phantom
     mkdirSync(join(base, ".gsd", "milestones", "M001", "slices"), { recursive: true });
 
-    // isReusableGhostMilestone identifies the orphaned stub
-    assert.ok(isReusableGhostMilestone(base, "M001"), "pre-existing stub should be identified as reusable ghost");
-    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should reuse the pre-existing ghost");
-
-    // The new ID (M002, which would be max+1 in this scenario but ghost reuse returns M001)
-    // should not have a dir
-    const m002Dir = join(base, ".gsd", "milestones", "M002");
-    assert.ok(!existsSync(m002Dir), "a freshly-requested ID should have no dir until first artifact write");
+    assert.equal(isReusableGhostMilestone(base, "M001"), true);
+    assert.equal(nextMilestoneIdReserved(findMilestoneIds(base), false, base), "M001");
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M002")));
   });
 });

package/src/resources/extensions/gsd/tests/discuss-tool-scoping.test.ts

@@ -16,15 +16,12 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const promptsDir = join(__dirname, "..", "prompts");
-const guidedFlowPath = join(__dirname, "..", "guided-flow.ts");
+import { _dispatchWorkflowForTest } from "../guided-flow.ts";
 
 // ─── Heavy tools that should NOT be in discuss scope ─────────────────────────
 
@@ -95,36 +92,46 @@ describe("discuss tool scoping (#2949)", () => {
     );
   });
 
-  test("guided-discuss-slice.md references gsd_summary_save", () => {
-    const prompt = readFileSync(join(promptsDir, "guided-discuss-slice.md"), "utf-8");
-    assert.ok(
-      prompt.includes("gsd_summary_save"),
-      "guided-discuss-slice.md should reference gsd_summary_save",
-    );
-  });
-
-  test("discuss.md references gsd_plan_milestone and gsd_decision_save", () => {
-    const prompt = readFileSync(join(promptsDir, "discuss.md"), "utf-8");
-    assert.ok(
-      prompt.includes("gsd_plan_milestone"),
-      "discuss.md should reference gsd_plan_milestone",
-    );
-    assert.ok(
-      prompt.includes("gsd_decision_save"),
-      "discuss.md should reference gsd_decision_save",
-    );
-  });
+  test("dispatchWorkflow scopes and restores tools for discuss unit types", async () => {
+    const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-tools-"));
+    const workflowPath = join(tmp, "GSD-WORKFLOW.md");
+    writeFileSync(workflowPath, "# Workflow\n");
+    const setCalls: string[][] = [];
+    const sent: unknown[] = [];
+    let sentTools: string[] = [];
+    let activeTools = ["gsd_summary_save", "gsd_complete_task", "bash"];
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    try {
+      await _dispatchWorkflowForTest(
+        {
+          getActiveTools: () => [...activeTools],
+          setActiveTools: (tools: string[]) => {
+            setCalls.push([...tools]);
+            activeTools = [...tools];
+          },
+          sendMessage: (message: unknown) => {
+            sent.push(message);
+            sentTools = [...activeTools];
+          },
+        } as any,
+        "Discuss the project",
+        "gsd-run",
+        undefined,
+        "discuss-milestone",
+      );
+    } finally {
+      if (originalWorkflowPath === undefined) delete process.env.GSD_WORKFLOW_PATH;
+      else process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+      rmSync(tmp, { recursive: true, force: true });
+    }
 
-  test("dispatchWorkflow source code scopes tools for discuss unit types", () => {
-    const source = readFileSync(guidedFlowPath, "utf-8");
-    // Verify that dispatchWorkflow references the allowlist for tool scoping
-    assert.ok(
-      source.includes("DISCUSS_TOOLS_ALLOWLIST"),
-      "guided-flow.ts should reference DISCUSS_TOOLS_ALLOWLIST for tool scoping",
-    );
-    assert.ok(
-      source.includes("setActiveTools"),
-      "guided-flow.ts should call setActiveTools to scope tools during discuss",
-    );
+    assert.deepEqual(setCalls[0], ["gsd_summary_save", "bash"]);
+    assert.deepEqual(setCalls.at(-1), ["gsd_summary_save", "gsd_complete_task", "bash"]);
+    assert.ok(sentTools.length > 0, "dispatch should queue a message");
+    assert.ok(sentTools.includes("gsd_summary_save"), "dispatch keeps the discuss save tool");
+    assert.ok(!sentTools.includes("gsd_complete_task"), "dispatch removes heavy completion tools");
+    assert.equal(sent.length, 1);
+    assert.match(String((sent[0] as { content?: unknown }).content), /Discuss the project/);
   });
 });