@opengsd/gsd-pi 1.0.2-dev.e9a1b49 → 1.0.2-dev.fb7ddf1

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

@@ -191,6 +191,32 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   assert.deepEqual(result.event, event);
 });
 
+test("runUnit clears scoped skill visibility after a manifest-scoped unit completes", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const skillVisibilityCalls: Array<string[] | undefined> = [];
+  let visibleSkills: string[] | undefined;
+  pi.setVisibleSkills = (names: string[] | undefined) => {
+    visibleSkills = names;
+    skillVisibilityCalls.push(names);
+  };
+  const s = makeMockSession();
+
+  const resultPromise = runUnit(ctx, pi, s, "plan-slice", "M001/S01", "prompt");
+
+  await new Promise((r) => setTimeout(r, 10));
+  assert.ok(Array.isArray(visibleSkills), "unit dispatch should scope skills before the turn starts");
+
+  resolveAgentEnd(makeEvent());
+
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.equal(visibleSkills, undefined);
+  assert.equal(skillVisibilityCalls.at(-1), undefined);
+});
+
 test("runUnit honors ScheduleWakeup by continuing the same unit session", async () => {
   _resetPendingResolve();
   _resetAutoWakeupsForTest();
@@ -1773,6 +1799,11 @@ test("autoLoop dev path dispatches orchestration.advance results without legacy
   const ctx = makeMockCtx();
   ctx.ui.setStatus = () => {};
   ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+  ctx.modelRegistry = {
+    getAvailable: () => [{ provider: "test", id: "hook-model" }],
+    getProviderAuthMode: () => undefined,
+    isProviderRequestReady: () => true,
+  };
   const pi = makeMockPi();
   const stateSnapshot = {
     phase: "executing",
@@ -1784,6 +1815,7 @@ test("autoLoop dev path dispatches orchestration.advance results without legacy
   } as any;
   let advanceCalls = 0;
   const finalizedUnits: string[] = [];
+  const journalEvents: any[] = [];
   let s: any;
   s = makeLoopSession({
     currentMilestoneId: "M002",
@@ -1821,6 +1853,15 @@ test("autoLoop dev path dispatches orchestration.advance results without legacy
       deps.callLog.push("resolveDispatch");
       throw new Error("legacy resolveDispatch must not run when orchestration is wired");
     },
+    runPreDispatchHooks: () => ({
+      firedHooks: ["complete-slice-policies"],
+      action: "proceed",
+      prompt: "hooked prompt",
+      model: "hook-model",
+    }),
+    emitJournalEvent: (entry: any) => {
+      journalEvents.push(entry);
+    },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
       s.active = false;
@@ -1841,11 +1882,115 @@ test("autoLoop dev path dispatches orchestration.advance results without legacy
   );
   assert.equal(
     (pi.calls[0] as any[])[0].content,
-    "advance prompt",
-    "runUnit should receive the dispatch prompt captured by advance()",
+    "hooked prompt",
+    "runUnit should receive the dispatch prompt after pre-dispatch hooks",
+  );
+  assert.deepEqual(
+    pi.setModelCalls.map((call: any[]) => call[0]),
+    [
+      { provider: "test", id: "hook-model" },
+      { provider: "test", id: "hook-model" },
+    ],
+    "proceed hooks should apply model overrides before dispatch",
   );
   assert.deepEqual(finalizedUnits, ["execute-task:M002/S03/T05"]);
   assert.equal(s.pendingOrchestrationDispatch, null, "pending dispatch should be one-shot");
+  assert.equal(
+    journalEvents.filter((entry) => entry.eventType === "pre-dispatch-hook").length,
+    1,
+    "hook dispatch should emit one pre-dispatch-hook journal event",
+  );
+});
+
+test("autoLoop pauses once when orchestration reports reconciliation drift error", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({
+    currentMilestoneId: "M002",
+    orchestration: {
+      start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      advance: async () => {
+        advanceCalls++;
+        return {
+          kind: "error" as const,
+          reason: "Reconciliation drift: Reconciliation repair failed in pass 0",
+        };
+      },
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      stop: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      getStatus: () => ({ phase: "error" as const, transitionCount: 1 }),
+    },
+  });
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      throw new Error("legacy resolveDispatch must not run after orchestration error");
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.equal(advanceCalls, 1, "orchestration error must not be retried in the same loop");
+  assert.ok(deps.callLog.includes("pauseAuto"), "orchestration error should pause auto-mode");
+  assert.equal(
+    deps.callLog.includes("resolveDispatch"),
+    false,
+    "orchestration error must not fall back to legacy dispatch",
+  );
+  assert.equal(s.pendingOrchestrationDispatch, null, "no orchestration dispatch should remain pending");
+});
+
+test("autoLoop retries next iteration when orchestration reports paused", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({
+    currentMilestoneId: "M002",
+    orchestration: {
+      start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      advance: async () => {
+        advanceCalls++;
+        return advanceCalls === 1
+          ? { kind: "paused" as const, reason: "provider transient; retry" }
+          : { kind: "stopped" as const, reason: "done retrying" };
+      },
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      stop: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      getStatus: () => ({ phase: "running" as const, transitionCount: advanceCalls }),
+    },
+  });
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      throw new Error("legacy resolveDispatch must not run after orchestration paused");
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.equal(advanceCalls, 2, "orchestration paused should retry on the next loop iteration");
+  assert.equal(deps.callLog.includes("pauseAuto"), false, "orchestration paused should not pause auto-mode");
+  assert.equal(
+    deps.callLog.includes("resolveDispatch"),
+    false,
+    "orchestration paused must not fall back to legacy dispatch",
+  );
+  assert.equal(s.pendingOrchestrationDispatch, null, "no orchestration dispatch should remain pending");
 });
 
 test("autoLoop consumes pending orchestration dispatch without advancing twice", async () => {
@@ -4453,6 +4598,101 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
   );
 });
 
+test("runUnitPhase retries 0-tool units with ordinary network-related assistant text", async (t) => {
+  _resetPendingResolve();
+
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-network-text-"));
+  t.after(() => {
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const pi = {
+    ...makeMockPi(),
+    sendMessage: () => {
+      queueMicrotask(() => resolveAgentEnd(makeEvent([
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "Error: I'll investigate the network error handling next." },
+          ],
+        },
+      ])));
+    },
+  } as any;
+  const s = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+  });
+  const mockLedger = {
+    version: 1,
+    projectStartedAt: Date.now(),
+    units: [] as any[],
+  };
+  const deps = makeMockDeps({
+    closeoutUnit: async () => {
+      mockLedger.units.push({
+        type: "execute-task",
+        id: "M001/S01/T01",
+        startedAt: s.currentUnit?.startedAt ?? Date.now(),
+        toolCalls: 0,
+        assistantMessages: 1,
+        tokens: { input: 100, output: 20, total: 120, cacheRead: 0, cacheWrite: 0 },
+        cost: 0.01,
+      });
+    },
+    getLedger: () => mockLedger,
+  });
+  let seq = 0;
+
+  const result = await runUnitPhase(
+    { ctx, pi, s, deps, prefs: undefined, iteration: 1, flowId: "flow-zero-tool-network-text", nextSeq: () => ++seq },
+    {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "do work",
+      finalPrompt: "do work",
+      pauseAfterUatDispatch: false,
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Milestone" },
+        activeSlice: { id: "S01", title: "Slice" },
+        activeTask: { id: "T01", title: "Task" },
+        registry: [{ id: "M001", title: "Milestone", status: "active" }],
+        recentDecisions: [],
+        blockers: [],
+        nextAction: "",
+        progress: { milestones: { done: 0, total: 1 } },
+        requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+      } as any,
+      mid: "M001",
+      midTitle: "Milestone",
+      isRetry: false,
+      previousTier: undefined,
+    },
+    { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 },
+  );
+
+  assert.equal(result.action, "retry");
+  assert.equal((result as any).reason, "zero-tool-calls");
+  assert.equal(deps.callLog.includes("pauseAuto"), false);
+});
+
 test("autoLoop pauses user-driven deep question instead of flagging 0 tool calls", async () => {
   _resetPendingResolve();
 
@@ -4640,6 +4880,92 @@ test("autoLoop rejects complete-slice with 0 tool calls as context-exhausted (#2
   );
 });
 
+test("autoLoop pauses on zero-tool-call rate-limit assistant messages instead of immediate retry", async (t) => {
+  _resetPendingResolve();
+
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-rate-limit-"));
+  t.after(() => {
+    _resetPendingResolve();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const originalSetTimeout = globalThis.setTimeout;
+  const timers: Array<{ fn: () => void; delay: number }> = [];
+  globalThis.setTimeout = ((fn: () => void, delay?: number) => {
+    timers.push({ fn, delay: delay ?? 0 });
+    return 0 as unknown as ReturnType<typeof setTimeout>;
+  }) as typeof setTimeout;
+
+  try {
+    const ctx = makeMockCtx();
+    ctx.ui.setStatus = () => {};
+    const notifications: string[] = [];
+    ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+    ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+    ctx.modelRegistry = {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    };
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      basePath,
+      canonicalProjectRoot: basePath,
+      originalBasePath: basePath,
+    });
+
+    const mockLedger = {
+      version: 1,
+      projectStartedAt: Date.now(),
+      units: [] as any[],
+    };
+
+    const deps = makeMockDeps({
+      closeoutUnit: async () => {
+        mockLedger.units.push({
+          type: "execute-task",
+          id: "M001/S01/T01",
+          startedAt: s.currentUnit?.startedAt ?? Date.now(),
+          toolCalls: 0,
+          assistantMessages: 1,
+          tokens: { input: 100, output: 100, total: 200, cacheRead: 0, cacheWrite: 0 },
+          cost: 0.05,
+        });
+      },
+      getLedger: () => mockLedger,
+    });
+
+    const loopPromise = autoLoop(ctx as any, pi as any, s, deps);
+
+    await new Promise((r) => originalSetTimeout(r, 50));
+    resolveAgentEnd(makeEvent([
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "You've hit your limit · resets Jun 1 at 8am" }],
+      },
+    ]));
+
+    await loopPromise;
+
+    assert.equal(deps.callLog.includes("pauseAuto"), true);
+    assert.ok(
+      timers.some((timer) => timer.delay === 60_000),
+      "rate-limit message should schedule delayed auto-resume instead of immediate retry",
+    );
+    assert.ok(
+      notifications.some((msg) => msg.includes("Auto-resuming in 60s")),
+      "rate-limit pause should announce delayed resume",
+    );
+    assert.ok(
+      !notifications.some((msg) => msg.includes("context exhaustion")),
+      "rate-limit message should not be classified as context exhaustion",
+    );
+    const deriveCount = deps.callLog.filter((entry) => entry === "deriveState").length;
+    assert.equal(deriveCount, 1, "loop should pause after first iteration instead of redispatching");
+  } finally {
+    globalThis.setTimeout = originalSetTimeout;
+  }
+});
+
 // ─── Worktree health check (#1833) ────────────────────────────────────────
 
 test("autoLoop stops when Worktree Safety finds no .git marker for execute-task (#1833)", async (t) => {

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

@@ -15,6 +15,7 @@ import { resolveDispatch, type DispatchContext } from "../auto-dispatch.js";
 import { RuleRegistry, setRegistry, resetRegistry } from "../rule-registry.js";
 import type { UnifiedRule } from "../rule-types.js";
 import { supportsStructuredQuestions } from "../workflow-mcp.js";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.js";
 
 function assertBlockedResult(
   result: Awaited<ReturnType<ReturnType<typeof createAutoOrchestrator>["advance"]>>,
@@ -592,6 +593,27 @@ test("retryActiveUnit clears in-flight idempotency without marking the unit fina
   assert.equal(prepareCalls, 2, "retry should intentionally redispatch the same unit");
 });
 
+test("retryActiveUnit clears finalized same-unit guard for post-hook retries", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  assert.equal(first.kind, "advanced");
+  if (first.kind !== "advanced") throw new Error("expected first advance");
+
+  await orchestrator.completeActiveUnit(first.unit);
+  await orchestrator.retryActiveUnit(first.unit);
+  const second = await orchestrator.advance();
+
+  assert.equal(second.kind, "advanced");
+  if (second.kind !== "advanced") throw new Error("expected retry advance");
+  assert.deepEqual(second.unit, first.unit);
+  assert.ok(calls.includes("journal:unit-finalized"));
+  assert.ok(calls.includes("journal:unit-retry"));
+  const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
+  assert.equal(prepareCalls, 2, "post-hook retry should redispatch the finalized unit");
+});
+
 test("resume() re-enters running phase", async () => {
   const { deps } = makeDeps();
   const orchestrator = createAutoOrchestrator(deps);
@@ -1255,6 +1277,59 @@ test("wired DispatchAdapter replays pending verification retry dispatch", async
   assert.equal(session.pendingOrchestrationDispatch?.state, stateSnapshot);
 });
 
+test("wired DispatchAdapter clears verification retry state when skipping an already closed retry dispatch", async () => {
+  const stateSnapshot = makeState();
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-closed-retry-"));
+
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Slice", status: "active" });
+    insertTask({ milestoneId: "M001", sliceId: "S01", id: "T01", title: "Task", status: "complete" });
+
+    const retryRule: UnifiedRule = {
+      name: "test-closed-verification-retry",
+      when: "dispatch",
+      evaluation: "first-match",
+      where: async () => ({
+        action: "dispatch" as const,
+        unitType: "execute-task",
+        unitId: "M001/S01/T01",
+        prompt: "retry closed task",
+      }),
+      then: (r: unknown) => r,
+    };
+    setRegistry(new RuleRegistry([retryRule]));
+
+    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as any;
+    const pi = { getActiveTools: () => [] } as any;
+    const session = {
+      basePath: base,
+      pendingOrchestrationDispatch: { stale: true },
+      pendingVerificationRetry: {
+        unitId: "M001/S01/T01",
+        failureContext: "artifact missing",
+        attempt: 1,
+      },
+    } as any;
+    const adapter = createWiredDispatchAdapter(ctx, pi, base, session);
+
+    const result = await adapter.decideNextUnit({ stateSnapshot });
+
+    assert.deepEqual(result, {
+      kind: "skipped",
+      reason: "execute-task M001/S01/T01 is already complete",
+    });
+    assert.equal(session.pendingVerificationRetry, null);
+    assert.equal(session.pendingOrchestrationDispatch, null);
+  } finally {
+    resetRegistry();
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("wired DispatchAdapter preserves stop reason as a blocked decision", async () => {
   const stateSnapshot = makeState();
   const stopRule: UnifiedRule = {

package/src/resources/extensions/gsd/tests/auto-post-unit-artifact-diagnostic.test.ts

@@ -1,9 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { _describeArtifactVerificationFailureForTest } from "../auto-post-unit.ts";
+import {
+  _describeArtifactVerificationFailureForTest,
+  maybeWriteParallelResearchCostSpikeBlocker,
+} from "../auto-post-unit.ts";
+import { resolveExpectedArtifactPath } from "../auto-recovery.ts";
 
 test("missing execute-task artifact includes completion contract and completion-tool hint", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-artifact-diag-"));
@@ -30,3 +34,25 @@ test("missing execute-task artifact skips completion-tool hint when completion t
   assert.match(msg, /was not found on disk after unit execution/);
   assert.doesNotMatch(msg, /No completion tool call detected \(`gsd_task_complete`\/alias\)/);
 });
+
+test("parallel research cost spike writes durable PARALLEL-BLOCKER", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-cost-blocker-"));
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    const blocker = maybeWriteParallelResearchCostSpikeBlocker(
+      "research-slice",
+      "M001/parallel-research",
+      base,
+      3.73,
+      1.02,
+    );
+
+    const expected = resolveExpectedArtifactPath("research-slice", "M001/parallel-research", base);
+    assert.match(blocker ?? "", /M001-PARALLEL-BLOCKER\.md/);
+    assert.ok(expected);
+    assert.equal(existsSync(expected!), true);
+    assert.match(readFileSync(expected!, "utf-8"), /cost spike detected \(3\.73 vs avg 1\.02\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-post-unit-evidence-crossref-4909.test.ts

@@ -58,3 +58,33 @@ test("detects top-level bash tool call via toolName field", () => {
 
   assert.equal(_hasExecutionToolCallsInSessionForTest(entries), true);
 });
+
+test("detects session execution tools supported by the evidence collector", () => {
+  const entries = [
+    {
+      type: "message",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "toolCall",
+            toolName: "async_bash",
+            arguments: { command: "npm test" },
+          },
+          {
+            type: "toolCall",
+            toolName: "PowerShell",
+            arguments: { command: "Get-ChildItem" },
+          },
+          {
+            type: "toolCall",
+            toolName: "functions.exec_command",
+            arguments: { cmd: "pnpm test" },
+          },
+        ],
+      },
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), true);
+});

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

@@ -1837,3 +1837,44 @@ test("#4414: verifyExpectedArtifact parallel-research succeeds when all research
     cleanup(base);
   }
 });
+
+test("parallel-research verification accepts canonical project artifacts from a worktree base", () => {
+  const base = makeTmpBase();
+  try {
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(join(milestoneDir, "slices", "S02", "tasks"), { recursive: true });
+    mkdirSync(join(milestoneDir, "slices", "S03", "tasks"), { recursive: true });
+
+    writeFileSync(
+      join(milestoneDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Regression",
+        "",
+        "## Slices",
+        "",
+        "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+        "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+        "- [ ] **S03: Gamma** `risk:low` `depends:[]`",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(milestoneDir, "M001-RESEARCH.md"), "# milestone research\n", "utf-8");
+    writeFileSync(join(milestoneDir, "slices", "S02", "S02-RESEARCH.md"), "# research\n", "utf-8");
+    writeFileSync(join(milestoneDir, "slices", "S03", "S03-RESEARCH.md"), "# research\n", "utf-8");
+
+    const worktree = join(base, ".gsd", "worktrees", "M001");
+    mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(worktree, ".git"), "gitdir: ../../../../.git/worktrees/M001\n", "utf-8");
+
+    clearParseCache();
+    invalidateAllCaches();
+    assert.equal(
+      verifyExpectedArtifact("research-slice", "M001/parallel-research", worktree),
+      true,
+      "worktree verification should use the same canonical artifacts as dispatch",
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -95,4 +95,28 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     assert.equal(entries[1].kind, "bash");
     assert.equal(entries[1].command, "npm run build");
   });
+
+  it("treats Codex exec_command tool names as execution evidence", () => {
+    recordToolCall("tc-exec", "exec_command", { cmd: "pnpm test" });
+    recordToolCall("tc-namespaced-exec", "functions.exec_command", { cmd: "pnpm lint" });
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].kind, "bash");
+    assert.equal(entries[0].command, "pnpm test");
+    assert.equal(entries[1].kind, "bash");
+    assert.equal(entries[1].command, "pnpm lint");
+  });
+
+  it("treats any workflow MCP gsd_exec server namespace as execution evidence", () => {
+    recordToolCall("tc-default", "mcp__gsd-workflow__gsd_exec", { command: "pnpm test" });
+    recordToolCall("tc-custom", "mcp__custom-workflow__gsd_exec_search", { query: "rg TODO" });
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].kind, "bash");
+    assert.equal(entries[0].command, "pnpm test");
+    assert.equal(entries[1].kind, "bash");
+    assert.equal(entries[1].command, "rg TODO");
+  });
 });