gsd-pi 2.80.0-dev.2be7caf18 → 2.80.0-dev.3065f7bfa

package/src/resources/extensions/gsd/tests/parallel-orchestrator-fast-forward.test.ts

@@ -0,0 +1,113 @@
+// GSD-2 + src/resources/extensions/gsd/tests/parallel-orchestrator-fast-forward.test.ts
+// Regression: parallel-orchestrator's `_createMilestoneWorktree` must
+// fast-forward a reused milestone branch onto integration before creating
+// the worktree, matching the behavior added to the auto-mode path in
+// commit 8996cb68e (#5549 post-merge audit, R3).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _createMilestoneWorktree } from "../parallel-orchestrator.js";
+
+const NO_PROMPT_ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_AUTHOR_NAME: "test",
+  GIT_AUTHOR_EMAIL: "test@example.com",
+  GIT_COMMITTER_NAME: "test",
+  GIT_COMMITTER_EMAIL: "test@example.com",
+};
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: NO_PROMPT_ENV,
+  });
+}
+
+function rev(cwd: string, ref: string): string {
+  return git(cwd, "rev-parse", ref).trim();
+}
+
+describe("_createMilestoneWorktree fast-forwards reused milestone branches (#5549 R3)", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "parallel-orch-ff-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+    // Minimal .gsd/ structure so syncGsdStateToWorktree doesn't crash on a
+    // bare repo. We don't care if it copies anything — only that the FF ran.
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("reused milestone branch behind main is fast-forwarded before worktree creation", () => {
+    // Worker N drained M001 in a previous run, leaving milestone/M001 forked
+    // from old main. Worker N+1 picks up M002 — but the milestone/M002 branch
+    // was created from old main in a sibling run, so it's now N commits behind.
+    git(repo, "branch", "milestone/M002");
+    const m002Initial = rev(repo, "milestone/M002");
+
+    writeFileSync(join(repo, "seed.txt"), "main moved forward\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main advanced");
+    const mainTip = rev(repo, "main");
+
+    assert.notEqual(m002Initial, mainTip, "main must be ahead before the test");
+
+    // _createMilestoneWorktree may throw inside createWorktree/syncGsdStateToWorktree
+    // (e.g. if the worktree-manager has stricter requirements than this minimal
+    // repo provides). The fast-forward runs BEFORE those calls, so the branch
+    // ref should have moved regardless. Catch and assert on observable state.
+    try {
+      _createMilestoneWorktree(repo, "M002");
+    } catch {
+      // Fine — we only care that FF executed.
+    }
+
+    assert.equal(
+      rev(repo, "milestone/M002"),
+      mainTip,
+      "milestone/M002 must be fast-forwarded to main's tip before worktree is built",
+    );
+  });
+
+  test("diverged milestone branch is NOT touched (would lose work)", () => {
+    git(repo, "checkout", "-q", "-b", "milestone/M002");
+    writeFileSync(join(repo, "wip.txt"), "milestone-only work\n");
+    git(repo, "add", "wip.txt");
+    git(repo, "commit", "-q", "-m", "M002 work");
+    const m002Tip = rev(repo, "milestone/M002");
+
+    git(repo, "checkout", "-q", "main");
+    writeFileSync(join(repo, "seed.txt"), "main moved forward\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main advanced");
+
+    try {
+      _createMilestoneWorktree(repo, "M002");
+    } catch {
+      // ignored
+    }
+
+    assert.equal(
+      rev(repo, "milestone/M002"),
+      m002Tip,
+      "diverged milestone branch must NOT be touched — would lose committed work",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for pre-execution validation checks.
+
 /**
  * pre-execution-checks.test.ts — Unit tests for pre-execution validation checks.
  *
@@ -1542,6 +1545,27 @@ describe("checkFilePathConsistency directory inputs (#4446)", () => {
     assert.equal(results[0].blocking, true);
   });
 
+  test("runtime directory annotation is skipped as a pre-execution file dependency", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-dir-runtime-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        inputs: ["entries/ directory (runtime)"],
+        expected_output: ["src/commands/delete.ts", "src/index.ts"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "Runtime-only directory inputs are created during command execution, not required before the task starts",
+    );
+  });
+
   test("tilde-prefixed input is matched against $HOME, not the project basePath", (t) => {
     const fakeHome = join(tmpdir(), `pre-exec-tilde-home-${Date.now()}`);
     const projectDir = join(tmpdir(), `pre-exec-tilde-proj-${Date.now()}`);
@@ -1597,6 +1621,20 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
       "Directory reference should not be treated as reading a file created later",
     );
   });
+
+  test("runtime directory annotation does not produce an ordering violation", () => {
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["entries/ directory (runtime)"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.deepEqual(results, []);
+  });
 });
 
 // ─── Regression Tests: checkTaskOrdering false positive for pre-execution refs (#4071) ──
@@ -1781,7 +1819,7 @@ describe("checkFilePathConsistency completed-task output exemption (#4071)", ()
     );
   });
 
-  test("pending task at higher index still causes a missing-file error", (t) => {
+  test("pending task at higher index does NOT cause a duplicate consistency error (ordering check handles it)", (t) => {
     const tempDir = join(tmpdir(), `pre-exec-fc-pending-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });
     t.after(() => rmSync(tempDir, { recursive: true, force: true }));
@@ -1803,14 +1841,16 @@ describe("checkFilePathConsistency completed-task output exemption (#4071)", ()
       }),
     ];
 
+    // checkFilePathConsistency suppresses the error here because checkTaskOrdering
+    // will fire a more precise "sequence violation" error for the same file.
+    // The combined output of runPreExecutionChecks still flags the issue — just
+    // once, via the ordering check, instead of twice.
     const results = checkFilePathConsistency(tasks, tempDir);
     assert.equal(
       results.length,
-      1,
-      "pending task at higher index must still be flagged — the file is not available yet",
+      0,
+      "consistency check must not duplicate what the ordering check already reports",
     );
-    assert.equal(results[0].blocking, true);
-    assert.equal(results[0].target, "artifacts/output.json");
   });
 });
 

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

@@ -0,0 +1,230 @@
+// Project/App: GSD-2
+// File Purpose: Verifies low-risk auto-prompt duplication cuts render through prompt builders.
+
+import test from "node:test";
+import type { TestContext } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+  upsertMilestonePlanning,
+} from "../gsd-db.ts";
+
+type AutoPromptBuilders = typeof import("../auto-prompts.ts");
+
+function makeBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+async function loadAutoPromptBuilders(t: TestContext): Promise<AutoPromptBuilders> {
+  const previousGsdHome = process.env.GSD_HOME;
+  const isolatedHome = mkdtempSync(join(tmpdir(), "gsd-prompt-loader-home-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(isolatedHome, { recursive: true, force: true });
+  });
+  return import(`../auto-prompts.ts?promptDupCuts=${Date.now()}-${Math.random()}`) as Promise<AutoPromptBuilders>;
+}
+
+function seedDb(base: string, taskStatus = "complete"): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Prompt Cuts", status: "active", depends_on: [] });
+  upsertMilestonePlanning("M001", {
+    title: "Prompt Cuts",
+    status: "active",
+    vision: "Reduce duplicate prompt reads.",
+    successCriteria: ["Prompt builders render compact context."],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Prompt Slice",
+    status: "active",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task one",
+    status: taskStatus,
+  });
+}
+
+function writeRoadmapAndPlan(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001 Roadmap",
+      "## Slices",
+      "- [ ] **S01: Prompt Slice** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    [
+      "# S01 Plan",
+      "",
+      "**Goal:** Reduce duplicate prompt reads.",
+      "",
+      "## Tasks",
+      "- [x] **T01: Task one** `est:15m`",
+    ].join("\n"),
+  );
+}
+
+function writeTaskSummary(base: string, options?: { blocker?: boolean; repeatedNarrative?: string }): void {
+  const narrative = options?.repeatedNarrative ?? "This full implementation narrative should stay out of closer prompts.";
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    [
+      "---",
+      "id: T01",
+      "parent: S01",
+      "milestone: M001",
+      "provides:",
+      "  - prompt context reduction",
+      "key_files:",
+      "  - src/resources/extensions/gsd/auto-prompts.ts",
+      "key_decisions:",
+      "  - use compact excerpts before full reads",
+      "patterns_established:",
+      "  - excerpt-first complete-slice context",
+      "observability_surfaces: []",
+      "duration: 15m",
+      "verification_result: passed",
+      "completed_at: 2026-05-06T12:00:00Z",
+      `blocker_discovered: ${options?.blocker ? "true" : "false"}`,
+      "---",
+      "",
+      "# T01: Task one",
+      "**One-line result.**",
+      "",
+      "## What Happened",
+      narrative,
+      "",
+      "## Verification",
+      "node:test passed.",
+      "",
+      "## Diagnostics",
+      "Prompt size stayed bounded.",
+    ].join("\n"),
+  );
+}
+
+test("execute-task rendering makes memory_query and template disk reads fallback-only", async (t) => {
+  const base = makeBase("gsd-execute-dup-cuts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base, "pending");
+  writeRoadmapAndPlan(base);
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
+    "# T01 Plan\n\nDo the prompt edit.\n",
+  );
+
+  const { buildExecuteTaskPrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "Prompt Slice", "T01", "Task one", base);
+
+  assert.match(prompt, /Call `memory_query`.*only when no injected memory block exists or the inlined memory\/context is insufficient/s);
+  assert.doesNotMatch(prompt, /Call `memory_query` with 2-4 keywords from the task title and touched files unless this is purely mechanical/);
+  assert.match(prompt, /Use the inlined Task Summary template below/);
+  assert.match(prompt, /Read `.*task-summary\.md` only if the inlined template is absent or visibly truncated/);
+  assert.doesNotMatch(prompt, /Read the template at `.*task-summary\.md`/);
+  assert.match(prompt, /### Output Template: Task Summary/);
+});
+
+test("complete-slice renders task summary excerpts without full summary bodies", async (t) => {
+  const base = makeBase("gsd-complete-slice-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  const repeatedNarrative = "FULL_TASK_BODY_SHOULD_NOT_RENDER ".repeat(40);
+  writeTaskSummary(base, { repeatedNarrative });
+
+  const { buildCompleteSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildCompleteSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.match(prompt, /On-demand.*read `\.gsd\/milestones\/M001\/slices\/S01\/tasks\/T01-SUMMARY\.md` only when this excerpt is absent\/truncated/s);
+  assert.doesNotMatch(prompt, /FULL_TASK_BODY_SHOULD_NOT_RENDER/);
+  assert.match(prompt, /Review the inlined task-summary excerpts/);
+});
+
+test("complete-slice caps malformed task summaries instead of inlining full bodies", async (t) => {
+  const base = makeBase("gsd-complete-slice-malformed-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    [
+      "# Legacy summary without frontmatter id",
+      "LEGACY_FULL_BODY_SHOULD_BE_CAPPED ".repeat(200),
+    ].join("\n"),
+  );
+
+  const { buildCompleteSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildCompleteSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /Truncated malformed summary/);
+  assert.ok(prompt.length < 20_000);
+  assert.ok((prompt.match(/LEGACY_FULL_BODY_SHOULD_BE_CAPPED/g) ?? []).length < 60);
+});
+
+test("replan-slice renders blocker summary excerpt and tells the agent to read full only on demand", async (t) => {
+  const base = makeBase("gsd-replan-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  writeTaskSummary(base, {
+    blocker: true,
+    repeatedNarrative: "FULL_BLOCKER_BODY_SHOULD_NOT_RENDER ".repeat(40),
+  });
+
+  const { buildReplanSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildReplanSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /### Blocker Task Summary: T01 \(excerpt\)/);
+  assert.match(prompt, /Use the inlined blocker summary excerpt first/);
+  assert.match(prompt, /Read the full blocker task summary only if the excerpt is absent, marked truncated, or lacks the specific blocker evidence needed to replan/);
+  assert.doesNotMatch(prompt, /FULL_BLOCKER_BODY_SHOULD_NOT_RENDER/);
+  assert.doesNotMatch(prompt, /Read the blocker task summary carefully/);
+});

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

@@ -65,6 +65,25 @@ describe('prompt step ordering (#3696)', () => {
     assert.ok(learningsIdx < completeMilestoneIdx, 'learnings extraction must happen before gsd_complete_milestone');
   });
 
+  test('complete-milestone duplicate guard checks milestone status before durable writes', () => {
+    const guardMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_milestone_status/m);
+    const reqUpdateMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_requirement_update/m);
+    assert.ok(guardMatch, 'complete-milestone must start with a gsd_milestone_status duplicate guard');
+    assert.ok(reqUpdateMatch, 'gsd_requirement_update should appear in a numbered step');
+
+    const guardIdx = completeMilestoneMd.indexOf(guardMatch![0]);
+    const reqUpdateIdx = completeMilestoneMd.indexOf(reqUpdateMatch![0]);
+    assert.ok(
+      guardIdx < reqUpdateIdx,
+      'duplicate guard must run before requirement/project/learnings writes',
+    );
+    assert.match(
+      completeMilestoneMd,
+      /status(?:`|\*\*)?\s+(?:is\s+)?(?:`complete`|"complete")/i,
+      'duplicate guard must tell the agent to stop when status is complete',
+    );
+  });
+
   test('complete-slice.md uses gsd_requirement_update', () => {
     assert.match(completeSliceMd, /gsd_requirement_update/,
       'complete-slice.md should reference gsd_requirement_update');

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

@@ -28,8 +28,8 @@ describe('query-tools ensureDbOpen usage (#3672)', () => {
   });
 
   test('calls ensureDbOpen() before DB queries', () => {
-    assert.match(source, /await ensureDbOpen\(\)/,
-      'query-tools should call await ensureDbOpen()');
+    assert.match(source, /await ensureDbOpen\([^)]*\)/,
+      'query-tools should call await ensureDbOpen(...)');
   });
 
   test('no longer imports isDbAvailable in the execute path', () => {
@@ -41,7 +41,7 @@ describe('query-tools ensureDbOpen usage (#3672)', () => {
   });
 
   test('uses dbAvailable result from ensureDbOpen', () => {
-    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\(\)/,
+    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\([^)]*\)/,
       'should store ensureDbOpen result in dbAvailable');
   });
 });

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -24,7 +24,7 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
   it('savedTools is declared before the discuss scoping block', () => {
     // savedTools must be declared before the discuss-* check
     const savedToolsDecl = src.indexOf('let savedTools')
-    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
+    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-")')
     assert.ok(savedToolsDecl !== -1, 'savedTools variable must be declared')
     assert.ok(discussCheck !== -1, 'discuss-* type check must exist')
     assert.ok(
@@ -33,40 +33,61 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
     )
   })
 
-  it('savedTools captures current tools inside the discuss block', () => {
-    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
+  it('savedTools captures current tools before scoping can mutate active state', () => {
+    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-")')
     assert.ok(discussCheck !== -1)
 
-    // Look for savedTools assignment within the discuss block
-    const blockAfter = extractSourceRegion(src, 'if (unitType?.startsWith("discuss-"))')
+    const currentToolsDecl = src.indexOf('const currentTools = pi.getActiveTools()')
+    const savedToolsAssign = src.indexOf('savedTools = {', currentToolsDecl)
+    const firstMutation = src.indexOf('pi.setActiveTools(scopedTools)')
     assert.ok(
-      blockAfter.includes('savedTools = currentTools'),
-      'savedTools must be assigned from currentTools inside the discuss block',
+      currentToolsDecl !== -1 && savedToolsAssign !== -1 && firstMutation !== -1,
+      'guided-flow.ts must capture current tools, save them, and then scope active tools',
+    )
+    assert.ok(
+      currentToolsDecl < savedToolsAssign && savedToolsAssign < firstMutation,
+      'savedTools must capture currentTools before any discuss scoping mutation',
+    )
+    assert.ok(
+      src.slice(savedToolsAssign, firstMutation).includes('tools: currentTools'),
+      'savedTools must include currentTools before the first scoping mutation',
     )
   })
 
+  it('scoping and workflow read happen inside the restore try block', () => {
+    const savedToolsDecl = src.indexOf('let savedTools')
+    const tryIdx = src.indexOf('try {', savedToolsDecl)
+    const firstMutation = src.indexOf('pi.setActiveTools(scopedTools)')
+    const workflowRead = src.indexOf('readFileSync(workflowPath')
+    const finallyIdx = src.indexOf('} finally {', tryIdx)
+
+    assert.ok(savedToolsDecl !== -1, 'savedTools variable must be declared')
+    assert.ok(tryIdx !== -1, 'restore try block must exist')
+    assert.ok(firstMutation !== -1, 'discuss scoping mutation must exist')
+    assert.ok(workflowRead !== -1, 'workflow file read must exist')
+    assert.ok(finallyIdx !== -1, 'restore finally block must exist')
+    assert.ok(tryIdx < firstMutation && firstMutation < finallyIdx, 'scoping mutation must be inside try/finally')
+    assert.ok(tryIdx < workflowRead && workflowRead < finallyIdx, 'workflow file read must be inside try/finally')
+  })
+
   it('savedTools is restored after sendMessage', () => {
     // #4573: guided-flow.ts now contains multiple `triggerTurn: true` calls
     // (ready-phrase and empty-turn recovery paths). The discuss-flow scoping
-    // sendMessage is the one that follows `savedTools = currentTools`, so
+    // sendMessage is the one that follows `tools: currentTools`, so
     // anchor the search there rather than at the first `triggerTurn: true`.
-    const savedToolsAssign = src.indexOf('savedTools = currentTools')
-    assert.ok(savedToolsAssign !== -1, 'savedTools = currentTools must exist')
+    const savedToolsAssign = src.indexOf('tools: currentTools')
+    assert.ok(savedToolsAssign !== -1, 'savedTools must capture currentTools')
 
     const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
     assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
 
-    // After sendMessage, savedTools should be restored via setActiveTools.
+    // After sendMessage, savedTools should be restored via the shared helper.
     // Use fromIdx to anchor at the discuss-flow sendMessage, not the first
     // triggerTurn: true occurrence in the file.
     const afterSend = extractSourceRegion(src, 'triggerTurn: true', { fromIdx: savedToolsAssign })
     assert.ok(
-      afterSend.includes('if (savedTools)'),
-      'savedTools restoration guard must exist after sendMessage',
-    )
-    assert.ok(
-      afterSend.includes('setActiveTools(savedTools)'),
-      'setActiveTools(savedTools) must be called to restore the full tool set',
+      afterSend.includes('restoreGsdWorkflowTools(pi, savedTools)'),
+      'restoreGsdWorkflowTools(pi, savedTools) must restore the full scoped state',
     )
   })
 })