gsd-pi 2.80.0-dev.c5f2443b3 → 2.80.0-dev.d4fc28e6b

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -15,10 +15,11 @@
  * (the fix) and verifies it does not crash.
  */
 
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -39,6 +40,14 @@ function makeMockPi() {
   } as any;
 }
 
+function makeRecordingPi() {
+  const messages: unknown[] = [];
+  return {
+    messages,
+    sendMessage: (message: unknown) => { messages.push(message); },
+  } as any;
+}
+
 // ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
 
 {
@@ -63,6 +72,45 @@ function makeMockPi() {
   assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
 }
 
+// ═══ DB-complete execute-task recovery advances without steering ═════════════
+
+{
+  console.log("\n=== execute-task timeout recovery trusts closed DB status ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-db-complete-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "Task", status: "complete" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      "# S01\n\n## Tasks\n\n- [ ] **T01: Task** `est:10m`\n",
+      "utf-8",
+    );
+    writeFileSync(join(base, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S01: Task\n", "utf-8");
+
+    const ctx = makeMockCtx();
+    const pi = makeRecordingPi();
+    const result = await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    });
+
+    assert.equal(result, "recovered", "db-complete task should recover immediately");
+    assert.equal(pi.messages.length, 0, "db-complete task should not send steering recovery");
+    const runtime = JSON.parse(readFileSync(join(base, ".gsd", "runtime", "units", "execute-task-M001-S01-T01.json"), "utf-8"));
+    assert.equal(runtime.phase, "finalized", "db-complete task should be finalized");
+    assert.equal(runtime.recovery.dbComplete, true, "runtime recovery should record DB completion");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {

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

@@ -3,6 +3,9 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
+import { _scheduleAutoStartAfterIdleForTest } from "../guided-flow.ts";
+
 const gsdDir = resolve(import.meta.dirname, "..");
 
 function readGsdFile(relativePath: string): string {
@@ -94,6 +97,23 @@ test("auto bootstrap validates blocked directories before touching .gsd migratio
   );
 });
 
+test("fresh start registers the auto worker before bootstrap enters worktree flow (#5405)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
+  const startAutoBody = autoSrc.slice(startAutoIdx);
+
+  const preBootstrapRegisterIdx = startAutoBody.indexOf("registerAutoWorkerForSession(s, base);");
+  const bootstrapCallIdx = startAutoBody.indexOf("const ready = await bootstrapAutoSession(");
+
+  assert.ok(startAutoIdx > -1, "startAuto should exist");
+  assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
+  assert.ok(bootstrapCallIdx > -1, "startAuto should call bootstrapAutoSession");
+  assert.ok(
+    preBootstrapRegisterIdx < bootstrapCallIdx,
+    "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",
+  );
+});
+
 test("startAutoDetached reports failures asynchronously (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
 
@@ -102,8 +122,8 @@ test("startAutoDetached reports failures asynchronously (#3733)", () => {
     "auto.ts should export startAutoDetached",
   );
   assert.ok(
-    autoSrc.includes("void startAuto(ctx, pi, base, verboseMode, options).catch"),
-    "startAutoDetached should launch startAuto without awaiting it",
+    autoSrc.includes("void withDetachedAutoKeepalive(startAuto(ctx, pi, base, verboseMode, options)).catch"),
+    "startAutoDetached should launch startAuto without awaiting it and keep the process alive",
   );
   assert.ok(
     autoSrc.includes("ctx.ui.notify(`Auto-start failed: ${message}`, \"error\")"),
@@ -111,6 +131,48 @@ test("startAutoDetached reports failures asynchronously (#3733)", () => {
   );
 });
 
+test("detached auto-start keeps a ref'ed handle until the run settles", async () => {
+  const originalSetInterval = globalThis.setInterval;
+  const originalClearInterval = globalThis.clearInterval;
+  let intervalCreated = false;
+  let intervalCleared = false;
+  let createdHandle: NodeJS.Timeout | undefined;
+  let resolveRun!: () => void;
+  const run = new Promise<void>((resolve) => {
+    resolveRun = resolve;
+  });
+
+  globalThis.setInterval = ((handler: TimerHandler, timeout?: number, ...args: unknown[]) => {
+    intervalCreated = true;
+    assert.equal(timeout, 30_000);
+    void handler;
+    void args;
+    createdHandle = originalSetInterval(() => {}, 1_000_000);
+    assert.equal(createdHandle.hasRef(), true, "detached auto keepalive must be ref'ed");
+    return createdHandle;
+  }) as unknown as typeof setInterval;
+
+  globalThis.clearInterval = ((handle?: NodeJS.Timeout | number | string) => {
+    if (handle === createdHandle) intervalCleared = true;
+    return originalClearInterval(handle);
+  }) as unknown as typeof clearInterval;
+
+  try {
+    const heldRun = _withDetachedAutoKeepaliveForTest(run);
+    assert.equal(intervalCreated, true, "keepalive interval should start immediately");
+    assert.equal(intervalCleared, false, "keepalive should remain active while auto-mode is running");
+
+    resolveRun();
+    await heldRun;
+
+    assert.equal(intervalCleared, true, "keepalive interval should clear when auto-mode settles");
+  } finally {
+    if (createdHandle) originalClearInterval(createdHandle);
+    globalThis.setInterval = originalSetInterval;
+    globalThis.clearInterval = originalClearInterval;
+  }
+});
+
 test("detached auto-start preserves milestone lock across pause/stop cleanup (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
   const sessionSrc = readGsdFile("auto/session.ts");
@@ -141,3 +203,40 @@ test("detached auto-start preserves milestone lock across pause/stop cleanup (#3
     "AutoSession should track the detached milestone lock explicitly",
   );
 });
+
+test("discussion auto-start waits for the current command context to become idle", async () => {
+  let releaseIdle!: () => void;
+  const idle = new Promise<void>((resolveIdle) => {
+    releaseIdle = resolveIdle;
+  });
+  const launches: unknown[][] = [];
+  const ctx = {
+    waitForIdle: () => idle,
+    ui: {
+      notify: () => {},
+    },
+  } as any;
+
+  _scheduleAutoStartAfterIdleForTest(
+    ctx,
+    {} as any,
+    "/tmp/gsd-auto-start-idle-test",
+    false,
+    { step: true },
+    (...args: unknown[]) => {
+      launches.push(args);
+    },
+  );
+
+  await Promise.resolve();
+  assert.equal(launches.length, 0, "auto-start must not launch before waitForIdle resolves");
+
+  releaseIdle();
+  await Promise.resolve();
+  assert.equal(launches.length, 0, "auto-start should defer launch to the next timer turn");
+
+  await new Promise((resolveTimer) => setTimeout(resolveTimer, 0));
+  assert.equal(launches.length, 1);
+  assert.equal(launches[0][2], "/tmp/gsd-auto-start-idle-test");
+  assert.deepEqual(launches[0][4], { step: true });
+});

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -291,6 +291,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       getAutoWorktreePath: () => null,
       autoCommitCurrentBranch: () => {},
       getCurrentBranch: () => "main",
+      checkoutBranch: () => {},
       autoWorktreeBranch: () => "gsd/M001",
       resolveMilestoneFile: () => "/mock/roadmap.md",
       readFileSync: () => "# Roadmap content",

package/src/resources/extensions/gsd/tests/status-db-open.test.ts

@@ -44,4 +44,13 @@ describe('status opens DB before deriveState (#3691)', () => {
     assert.match(quickSrc, /getIsolationMode\(\)\s*!==\s*"none"/,
       'quick.ts should compare isolation mode against "none"');
   });
+
+  test('quick task prompt handles external .gsd without staging quick files', () => {
+    assert.match(quickSrc, /isExternalGsdRoot/,
+      'quick.ts should detect whether .gsd resolves outside the project repo');
+    assert.match(quickSrc, /do not stage or commit `\.gsd\/quick\/\.\.\.`/,
+      'external-state quick tasks must tell the agent not to stage .gsd/quick files');
+    assert.match(quickSrc, /nothing in the project repo to commit/,
+      'external-state quick tasks should allow summary-only work without a git commit');
+  });
 });

package/src/resources/extensions/gsd/tests/system-context-memory.test.ts

@@ -0,0 +1,112 @@
+// Project/App: GSD-2
+// File Purpose: System context memory gating regression tests.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildContextMessage, isLowEntropyResumePrompt, loadMemoryBlock } from "../bootstrap/system-context.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
+
+test("buildContextMessage marks hidden guided context when memory is supplied", () => {
+  const message = buildContextMessage({
+    memoryBlock: "\n\n[MEMORY]\n\n- keep this",
+    injection: "[GSD Guided Execute Context]\nUse the task plan.",
+    forensicsInjection: null,
+  });
+
+  assert.ok(message, "expected hidden context message");
+  assert.equal(message.customType, "gsd-guided-context");
+  assert.equal(message.display, false);
+  assert.match(message.content, /\[GSD Context Metadata\]\n- Memory supplied: yes/);
+  assert.ok(
+    message.content.indexOf("Memory supplied: yes") < message.content.indexOf("[GSD Guided Execute Context]"),
+    "memory marker should appear before guided context",
+  );
+});
+
+test("buildContextMessage caps hidden context by default", () => {
+  const original = process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  try {
+    const message = buildContextMessage({
+      memoryBlock: "",
+      injection: `[GSD Guided Execute Context]\n${"large context\n".repeat(500)}`,
+      forensicsInjection: null,
+    });
+
+    assert.ok(message, "expected hidden context message");
+    assert.equal(message.customType, "gsd-guided-context");
+    assert.ok(message.content.length <= 4000);
+    assert.match(message.content, /\[GSD Context Truncated\]/);
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+    else process.env.PI_GSD_CONTEXT_MAX_CHARS = original;
+  }
+});
+
+test("buildContextMessage supports explicit context cap override", () => {
+  const original = process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  process.env.PI_GSD_CONTEXT_MAX_CHARS = "1200";
+  try {
+    const message = buildContextMessage({
+      memoryBlock: "",
+      injection: `[GSD Guided Execute Context]\n${"large context\n".repeat(200)}`,
+      forensicsInjection: null,
+    });
+
+    assert.ok(message, "expected hidden context message");
+    assert.equal(message.customType, "gsd-guided-context");
+    assert.ok(message.content.length <= 1200);
+    assert.match(message.content, /\[GSD Context Truncated\]/);
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+    else process.env.PI_GSD_CONTEXT_MAX_CHARS = original;
+  }
+});
+
+test("buildContextMessage does not add memory marker when only guided context is supplied", () => {
+  const message = buildContextMessage({
+    memoryBlock: "",
+    injection: "[GSD Guided Execute Context]\nUse the task plan.",
+    forensicsInjection: null,
+  });
+
+  assert.ok(message, "expected guided context message");
+  assert.equal(message.customType, "gsd-guided-context");
+  assert.doesNotMatch(message.content, /Memory supplied: yes/);
+});
+
+test("loadMemoryBlock keeps critical memories while gating prompt-relevant query hits", async () => {
+  closeDatabase();
+  assert.equal(openDatabase(":memory:"), true);
+  try {
+    createMemory({
+      category: "gotcha",
+      content: "Always preserve critical resume safety context.",
+      confidence: 0.95,
+    });
+    createMemory({
+      category: "preference",
+      content: "React dashboard preference should only appear for a React prompt query.",
+      confidence: 0.95,
+    });
+
+    const withPromptRelevant = await loadMemoryBlock("React dashboard", { includePromptRelevant: true });
+    assert.match(withPromptRelevant, /critical resume safety context/);
+    assert.match(withPromptRelevant, /React dashboard preference/);
+
+    const withoutPromptRelevant = await loadMemoryBlock("React dashboard", { includePromptRelevant: false });
+    assert.match(withoutPromptRelevant, /critical resume safety context/);
+    assert.doesNotMatch(withoutPromptRelevant, /React dashboard preference/);
+  } finally {
+    closeDatabase();
+  }
+});
+
+test("isLowEntropyResumePrompt identifies bare resume prompts only", () => {
+  assert.equal(isLowEntropyResumePrompt("continue"), true);
+  assert.equal(isLowEntropyResumePrompt("Go ahead."), true);
+  assert.equal(isLowEntropyResumePrompt("run the tests"), false);
+  assert.equal(isLowEntropyResumePrompt("/gsd auto"), false);
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -1,9 +1,5 @@
-// GSD bootstrap + system-context-message-routing.test — regression coverage
-// for #5019. `memoryBlock` is FTS-queried against the user prompt and changes
-// per call; embedding it in the cached system prefix invalidates Anthropic
-// prompt-cache hits on every request. The fix routes memory through the
-// existing context-message channel (volatile user-message suffix) and combines
-// it with any active guided-execute or forensics injection.
+// Project/App: GSD-2
+// File Purpose: Regression coverage for volatile system-context message routing.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
@@ -11,6 +7,8 @@ import assert from "node:assert/strict";
 import { buildContextMessage } from "../bootstrap/system-context.ts";
 
 describe("buildContextMessage (#5019 — memory routing)", () => {
+  const markedMemory = "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one";
+
   test("returns null when nothing to inject", () => {
     const result = buildContextMessage({
       memoryBlock: "",
@@ -37,7 +35,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result, "expected a context message");
     assert.equal(result.customType, "gsd-memory");
-    assert.equal(result.content, "[MEMORY]\nrule one\nrule two");
+    assert.equal(result.content, "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two");
     assert.equal(result.display, false);
   });
 
@@ -71,7 +69,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[MEMORY]\nrule one\n\n[GUIDED]\nexecute T01");
+    assert.equal(result.content, `${markedMemory}\n\n[GUIDED]\nexecute T01`);
   });
 
   test("memory + forensics: memory prepended, customType is gsd-forensics", () => {
@@ -82,7 +80,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, "[MEMORY]\nrule one\n\n[FORENSICS]\ninvestigation context");
+    assert.equal(result.content, `${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
   });
 
   test("guided takes precedence over forensics when both are somehow present", () => {

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -0,0 +1,291 @@
+// Project/App: GSD-2
+// File Purpose: Tests for opt-in GSD tool surface reduction.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+
+test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
+  const result = buildMinimalGsdToolSet([
+    "bash",
+    "read",
+    "browser_open",
+    "gsd_plan_milestone",
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+    "gsd_graph",
+  ]);
+
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("browser_open"));
+  for (const toolName of MINIMAL_GSD_TOOL_NAMES) {
+    assert.ok(result.includes(toolName), `expected ${toolName}`);
+  }
+  assert.ok(!result.includes("gsd_plan_milestone"));
+  assert.ok(!result.includes("gsd_task_complete"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildMinimalGsdToolSet deduplicates preserved and minimal tools", () => {
+  const result = buildMinimalGsdToolSet(["bash", "bash", "memory_query"]);
+
+  assert.deepEqual(result.filter((toolName) => toolName === "bash"), ["bash"]);
+  assert.deepEqual(result.filter((toolName) => toolName === "memory_query"), ["memory_query"]);
+});
+
+test("buildMinimalGsdToolSet does not reintroduce provider-filtered GSD tools", () => {
+  const result = buildMinimalGsdToolSet(["bash", "read", "memory_query"]);
+
+  assert.deepEqual(result, ["bash", "read", "memory_query"]);
+  assert.ok(!result.includes("gsd_exec"));
+});
+
+test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without aliases", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "read",
+    "lsp",
+    "browser_click",
+    "gsd_task_complete",
+    "gsd_complete_task",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_slice_complete",
+    "gsd_complete_slice",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task");
+
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("memory_query"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("browser_click"));
+  assert.ok(!result.includes("gsd_complete_task"));
+  assert.ok(!result.includes("gsd_slice_complete"));
+  assert.ok(!result.includes("gsd_complete_slice"));
+});
+
+test("buildMinimalAutoGsdToolSet keeps only the auto base non-GSD tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "browser_wait_for",
+    "edit",
+    "glob",
+    "grep",
+    "lsp",
+    "ls",
+    "mac_find",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task");
+
+  for (const toolName of MINIMAL_AUTO_BASE_TOOL_NAMES) {
+    assert.ok(result.includes(toolName), `expected ${toolName}`);
+  }
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("mac_find"));
+  assert.ok(!result.includes("subagent"));
+});
+
+test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "subagent",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_task_complete",
+    "gsd_slice_complete",
+    "gsd_complete_slice",
+    "memory_query",
+    "capture_thought",
+  ], "complete-slice");
+
+  assert.ok(result.includes("gsd_slice_complete"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("capture_thought"));
+  assert.ok(!result.includes("gsd_task_complete"));
+  assert.ok(!result.includes("gsd_complete_slice"));
+});
+
+test("buildMinimalAutoGsdToolSet covers execute-task-simple", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_task_complete",
+    "gsd_decision_save",
+    "gsd_plan_task",
+    "memory_query",
+    "capture_thought",
+  ], "execute-task-simple");
+
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("gsd_decision_save"));
+  assert.ok(!result.includes("gsd_plan_task"));
+});
+
+test("buildMinimalGsdWorkflowToolSet keeps workflow GSD tools but drops broad non-GSD tools", () => {
+  const result = buildMinimalGsdWorkflowToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "browser_wait_for",
+    "edit",
+    "lsp",
+    "mac_find",
+    "read",
+    "subagent",
+    "write",
+    "gsd_plan_milestone",
+    "gsd_complete_milestone",
+    "gsd_task_complete",
+    "gsd_summary_save",
+    "memory_query",
+    "capture_thought",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "gsd_graph",
+  ]);
+
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("bg_shell"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("write"));
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_complete_milestone"));
+  assert.ok(result.includes("gsd_task_complete"));
+  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("mac_find"));
+  assert.ok(!result.includes("subagent"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildRequestScopedGsdToolSet scopes queued workflow custom-message requests", () => {
+  const result = buildRequestScopedGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "browser_wait_for",
+    "lsp",
+    "read",
+    "write",
+    "gsd_plan_milestone",
+    "gsd_complete_milestone",
+    "gsd_task_complete",
+    "gsd_graph",
+    "memory_query",
+    "capture_thought",
+  ], [{ customType: "gsd-run" }, { customType: "gsd-memory" }]);
+
+  assert.ok(result);
+  assert.ok(result.includes("ask_user_questions"));
+  assert.ok(result.includes("bash"));
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("write"));
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_complete_milestone"));
+  assert.ok(!result.includes("browser_wait_for"));
+  assert.ok(!result.includes("lsp"));
+  assert.ok(!result.includes("gsd_graph"));
+});
+
+test("buildRequestScopedGsdToolSet ignores stale workflow messages outside the current request tail", () => {
+  assert.equal(buildRequestScopedGsdToolSet(["bash", "gsd_plan_milestone"], []), undefined);
+});
+
+test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
+  const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
+  let activeTools = [
+    "bash",
+    "read",
+    "lsp",
+    "gsd_plan_milestone",
+    "gsd_decision_save",
+    "memory_query",
+    "capture_thought",
+  ];
+  let visibleSkills: string[] | undefined = ["previous-skill"];
+
+  const state = scopeGsdWorkflowToolsForDispatch({
+    getActiveTools: () => activeTools,
+    setActiveTools: (names) => {
+      activeTools = names;
+      calls.push({ kind: "tools", value: names });
+    },
+    getVisibleSkills: () => visibleSkills,
+    setVisibleSkills: (names) => {
+      visibleSkills = names;
+      calls.push({ kind: "skills", value: names });
+    },
+  }, "plan-milestone");
+
+  assert.ok(state);
+  assert.deepEqual(visibleSkills, [
+    "write-milestone-brief",
+    "decompose-into-slices",
+    "design-an-interface",
+    "grill-me",
+    "write-docs",
+    "api-design",
+    "tdd",
+    "verify-before-complete",
+  ]);
+  assert.ok(!activeTools.includes("lsp"));
+
+  restoreGsdWorkflowTools({
+    setActiveTools: (names) => {
+      activeTools = names;
+      calls.push({ kind: "tools", value: names });
+    },
+    setVisibleSkills: (names) => {
+      visibleSkills = names;
+      calls.push({ kind: "skills", value: names });
+    },
+  }, state);
+
+  assert.deepEqual(activeTools, [
+    "bash",
+    "read",
+    "lsp",
+    "gsd_plan_milestone",
+    "gsd_decision_save",
+    "memory_query",
+    "capture_thought",
+  ]);
+  assert.deepEqual(visibleSkills, ["previous-skill"]);
+  assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
+});