gsd-pi 2.81.0 → 2.82.0-dev.725028083

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -33,43 +33,6 @@ import {
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
-import {
-  WorktreeLifecycle,
-  type WorktreeLifecycleDeps,
-  type NotifyCtx,
-} from "../worktree-lifecycle.ts";
-import { WorktreeStateProjection } from "../worktree-state-projection.ts";
-import { resolveWorktreeProjectRoot } from "../worktree-root.ts";
-import { AutoSession } from "../auto/session.ts";
-
-// Test-local: LegacyTestDeps had three fields Lifecycle does not need
-// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
-// Permit them in test fixtures so existing override patterns keep working —
-// Lifecycle ignores the extras via structural typing.
-type LegacyTestDeps = WorktreeLifecycleDeps & {
-  shouldUseWorktreeIsolation?: () => boolean;
-  syncWorktreeStateBack?: (
-    mainBasePath: string,
-    worktreePath: string,
-    milestoneId: string,
-  ) => { synced: string[] };
-  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
-};
-
-/** Shim factory preserving the legacy WorktreeResolver throw shape for tests. */
-function makeResolver(s: AutoSession, deps: LegacyTestDeps) {
-  const lifecycle = new WorktreeLifecycle(s, deps);
-  return {
-    get workPath(): string { return s.basePath; },
-    get projectRoot(): string {
-      return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
-    },
-    mergeAndExit: (mid: string, ctx: NotifyCtx) => {
-      const r = lifecycle.exitMilestone(mid, { merge: true }, ctx);
-      if (!r.ok && r.cause instanceof Error) throw r.cause;
-    },
-  };
-}
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -91,97 +54,6 @@ function createTempRepo(t: { after: (fn: () => void) => void }): string {
   return dir;
 }
 
-function makeSession(overrides?: Partial<{ basePath: string; originalBasePath: string }>): AutoSession {
-  const s = new AutoSession();
-  s.basePath = overrides?.basePath ?? "/project";
-  s.originalBasePath = overrides?.originalBasePath ?? "/project";
-  return s;
-}
-
-interface CallLog { fn: string; args: unknown[] }
-
-function makeDeps(overrides?: Partial<LegacyTestDeps>): LegacyTestDeps & { calls: CallLog[] } {
-  const calls: CallLog[] = [];
-
-  const deps: LegacyTestDeps & { calls: CallLog[] } = {
-    calls,
-    isInAutoWorktree: (basePath: string) => {
-      calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-      return basePath.includes("worktrees");
-    },
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: (basePath: string, milestoneId: string, roadmapContent: string) => {
-      calls.push({ fn: "mergeMilestoneToMain", args: [basePath, milestoneId, roadmapContent] });
-      return { pushed: false, codeFilesChanged: true };
-    },
-    syncWorktreeStateBack: (mainBasePath: string, worktreePath: string, milestoneId: string) => {
-      calls.push({ fn: "syncWorktreeStateBack", args: [mainBasePath, worktreePath, milestoneId] });
-      return { synced: [] };
-    },
-    teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-      calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-    },
-    createAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "createAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    enterAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "enterAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    getAutoWorktreePath: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "getAutoWorktreePath", args: [basePath, milestoneId] });
-      return null;
-    },
-    autoCommitCurrentBranch: (basePath: string, reason: string, milestoneId: string) => {
-      calls.push({ fn: "autoCommitCurrentBranch", args: [basePath, reason, milestoneId] });
-    },
-    getCurrentBranch: (basePath: string) => {
-      calls.push({ fn: "getCurrentBranch", args: [basePath] });
-      return "main";
-    },
-    checkoutBranch: (basePath: string, branch: string) => {
-      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
-    },
-    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
-    resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-      calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-      return null;
-    },
-    readFileSync: (path: string, _enc: string) => {
-      calls.push({ fn: "readFileSync", args: [path] });
-      return "# Roadmap\n";
-    },
-    GitServiceImpl: class {
-      constructor(_basePath: string, _gitConfig: unknown) {}
-    } as unknown as LegacyTestDeps["GitServiceImpl"],
-    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
-    invalidateAllCaches: () => { calls.push({ fn: "invalidateAllCaches", args: [] }); },
-    captureIntegrationBranch: (_basePath: string, _mid: string | undefined) => {},
-    enterBranchModeForMilestone: (_basePath: string, _milestoneId: string) => {},
-    worktreeProjection: new WorktreeStateProjection(),
-    ...overrides,
-  };
-
-  if (overrides) {
-    for (const [key, val] of Object.entries(overrides)) {
-      if (key !== "calls") (deps as unknown as Record<string, unknown>)[key] = val;
-    }
-  }
-  return deps;
-}
-
-function makeNotifyCtx(): NotifyCtx & { messages: Array<{ msg: string; level?: string }> } {
-  const messages: Array<{ msg: string; level?: string }> = [];
-  return {
-    messages,
-    notify: (msg: string, level?: "info" | "warning" | "error" | "success") => {
-      messages.push({ msg, level });
-    },
-  };
-}
-
 // ─── Suite 1: getAutoWorktreeOriginalBase() returns realpath-canonical path ──
 
 describe("getAutoWorktreeOriginalBase() is realpath-normalised", () => {
@@ -273,92 +145,15 @@ describe("normalizeWorktreePathForCompare equalises canonical vs non-canonical f
 // resolveMilestoneFile call against the "worktree" path that is actually the
 // same directory). The new code correctly skips the fallback.
 
-describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physical path as originalBase", () => {
-  test("with trailing-slash basePath equal to originalBase: resolveMilestoneFile called once", () => {
-    // originalBase is canonical (as returned by workspace registry)
-    const canonicalBase = "/tmp/m5-test-project";
-    // s.basePath has a trailing slash — same physical dir, non-canonical string
-    const trailingSlashBase = canonicalBase + "/";
-
-    const s = makeSession({
-      basePath: trailingSlashBase,
-      originalBasePath: canonicalBase,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      // isInAutoWorktree: basePath has trailing slash but is NOT a worktree
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return false;
-      },
-      // resolveMilestoneFile always returns null (no roadmap found)
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null;
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-
-    // Override calls ref so we can inspect it directly
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    // mergeAndExit → _mergeWorktreeMode
-    // originalBase = s.originalBasePath = canonicalBase
-    // s.basePath = trailingSlashBase — physically same as canonicalBase
-    // Post-fix: isSamePath(trailingSlashBase, canonicalBase) is true
-    //   → roadmap fallback branch is skipped (resolveMilestoneFile called once)
-    // Pre-fix (bug): trailingSlashBase !== canonicalBase → fallback entered
-    //   → resolveMilestoneFile called twice
-
-    resolver.mergeAndExit("M001", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 1,
-      "resolveMilestoneFile must be called exactly once — fallback should be skipped when " +
-      "s.basePath is the same physical path as originalBase (isSamePath fix)");
-  });
-
-  test("with genuinely different basePath (inside worktree): resolveMilestoneFile called twice", () => {
-    // originalBase is the project root
-    const projectRoot = "/tmp/m5-test-project";
-    // s.basePath is inside a worktree — a physically different path
-    const worktreePath = projectRoot + "/.gsd/worktrees/M002";
-
-    const s = makeSession({
-      basePath: worktreePath,
-      originalBasePath: projectRoot,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return basePath.includes("worktrees");
-      },
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null; // no roadmap in either location
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    resolver.mergeAndExit("M002", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 2,
-      "resolveMilestoneFile must be called twice when basePath is a genuine worktree path " +
-      "(fallback should run for different physical paths)");
-  });
-});
+// ADR-016 phase 2 / C2 + C3 (#5625, #5626): the prior two tests in this
+// suite asserted call counts on `deps.resolveMilestoneFile` /
+// `deps.isInAutoWorktree` / `deps.teardownAutoWorktree` to verify that the
+// roadmap-fallback branch was skipped when basePath was a non-canonical
+// form of originalBase (trailing slash). After C2/C3 those fields are
+// inlined into worktree-lifecycle.ts as direct imports — the mocks no
+// longer fire and the call-count assertions test nothing meaningful. The
+// underlying invariant (isSamePathPhysical normalises trailing slashes,
+// canonical/non-canonical pairs, and case differences) is preserved
+// inside worktree-lifecycle.ts and covered indirectly by the merge-area
+// integration tests, which exercise real worktree merges where the
+// fallback choice matters.

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -1,11 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for parallel monitor overlay rendering and input handling.
+
 import { describe, it } from "node:test";
-import assert from "node:assert";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
 
-/**
- * Basic tests for the parallel monitor overlay data helpers.
- * The overlay is primarily a rendering component that reads existing
- * status files — these tests verify the helper logic in isolation.
- */
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
 
 describe("parallel-monitor-overlay", () => {
   it("progressBar generates correct width", async () => {
@@ -37,6 +45,7 @@ describe("parallel-monitor-overlay", () => {
     const lines = overlay.render(80);
     assert.ok(Array.isArray(lines), "render should return an array");
     assert.ok(lines.length > 0, "render should return at least one line");
+    assertLinesFit(lines, 80);
 
     // Should contain header text
     const joined = lines.join("\n");
@@ -79,4 +88,27 @@ describe("parallel-monitor-overlay", () => {
     assert.equal((overlay as any).scrollOffset, 0, "empty overlays clamp scroll to zero");
     overlay.dispose();
   });
+
+  it("ParallelMonitorOverlay empty state fits narrow and wide widths", async () => {
+    const mod = await import("../parallel-monitor-overlay.js");
+
+    const mockTui = { requestRender: () => {} };
+    const mockTheme = {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const overlay = new mod.ParallelMonitorOverlay(
+      mockTui,
+      mockTheme as any,
+      () => {},
+      "/nonexistent/path",
+    );
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
+    }
+
+    overlay.dispose();
+  });
 });

package/src/resources/extensions/gsd/tests/plan-milestone-sketch-render.test.ts

@@ -0,0 +1,157 @@
+// ADR-011 #5750: ROADMAP.md renders sketch slices with a `[sketch]` badge.
+//
+// Locks in the visual distinction so an auditor scanning the rendered roadmap
+// can tell which slices are sketches awaiting refine-slice expansion vs which
+// already carry a full plan. Sits alongside `plan-milestone.test.ts` which
+// covers the full-plan render path.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase } from "../gsd-db.ts";
+import { handlePlanMilestone, type PlanMilestoneParams } from "../tools/plan-milestone.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-sketch-render-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function planMilestoneWithSketches(): PlanMilestoneParams {
+  return {
+    milestoneId: "M001",
+    title: "Progressive Planning Demo",
+    vision: "Demonstrate sketch slices in ROADMAP rendering.",
+    successCriteria: ["S01 full, S02 sketch", "ROADMAP distinguishes them"],
+    keyRisks: [{ risk: "Visual collision", whyItMatters: "Auditors need to spot sketches." }],
+    proofStrategy: [{ riskOrUnknown: "Render correctness", retireIn: "S01", whatWillBeProven: "Roadmap shows the badge." }],
+    verificationContract: "Contract verification text",
+    verificationIntegration: "Integration verification text",
+    verificationOperational: "Operational verification text",
+    verificationUat: "UAT verification text",
+    definitionOfDone: ["Renderer emits badge", "Test asserts it"],
+    requirementCoverage: "Covers ADR-011 #5750.",
+    boundaryMapMarkdown: "| From | To | Produces | Consumes |\n|------|----|----------|----------|\n| S01 | S02 | scaffold | nothing |",
+    slices: [
+      {
+        sliceId: "S01",
+        title: "Fully planned scaffold",
+        risk: "medium" as const,
+        depends: [],
+        demo: "Scaffold is in place.",
+        goal: "Lay down the structural foundation.",
+        successCriteria: "Scaffold tests pass.",
+        proofLevel: "integration" as const,
+        integrationClosure: "Downstream slices depend on this scaffold.",
+        observabilityImpact: "No new telemetry.",
+        // No isSketch flag — defaults to full plan.
+      },
+      {
+        sliceId: "S02",
+        title: "Refinement candidate",
+        risk: "low" as const,
+        depends: ["S01"],
+        demo: "Sketched until S01 ships.",
+        goal: "Refine into a full plan after S01 lands.",
+        successCriteria: "",
+        proofLevel: "",
+        integrationClosure: "",
+        observabilityImpact: "",
+        isSketch: true,
+        sketchScope: "Pick up the scaffold from S01 and add the demo behavior. Stay inside the existing module boundaries.",
+      },
+    ],
+  };
+}
+
+test("ROADMAP renders sketch slices with [sketch] badge and full slices without", async () => {
+  const base = makeTmpBase();
+  try {
+    const params = planMilestoneWithSketches();
+    const result = await handlePlanMilestone(params, base);
+    if ("error" in result) {
+      assert.fail(`handlePlanMilestone failed: ${result.error}`);
+    }
+
+    const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const roadmap = readFileSync(roadmapPath, "utf-8");
+
+    // S01 is a full slice — no sketch badge.
+    const s01Line = roadmap.split("\n").find((line) => line.includes("**S01:"));
+    assert.ok(s01Line, "S01 slice line must exist in roadmap");
+    assert.equal(
+      s01Line.includes("`[sketch]`"),
+      false,
+      "fully-planned S01 must NOT carry the sketch badge",
+    );
+    assert.match(s01Line, /`risk:medium`/);
+
+    // S02 is a sketch — badge required, positioned before risk.
+    const s02Line = roadmap.split("\n").find((line) => line.includes("**S02:"));
+    assert.ok(s02Line, "S02 slice line must exist in roadmap");
+    assert.ok(
+      s02Line.includes("`[sketch]`"),
+      `sketch slice S02 must carry the sketch badge, got: ${s02Line}`,
+    );
+    // Badge sits before risk so it stays visible if the line truncates.
+    const sketchIdx = s02Line.indexOf("`[sketch]`");
+    const riskIdx = s02Line.indexOf("`risk:");
+    assert.ok(
+      sketchIdx >= 0 && riskIdx >= 0 && sketchIdx < riskIdx,
+      "sketch badge must appear before the risk tag",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("ROADMAP omits sketch badge when no slices are sketches", async () => {
+  const base = makeTmpBase();
+  try {
+    const params = planMilestoneWithSketches();
+    // Strip the sketch designation from S02 so both slices are fully planned.
+    params.slices[1] = {
+      ...params.slices[1],
+      isSketch: false,
+      successCriteria: "Demo behavior works.",
+      proofLevel: "unit" as const,
+      integrationClosure: "S02 closes the demo behavior.",
+      observabilityImpact: "No new telemetry.",
+    };
+
+    const result = await handlePlanMilestone(params, base);
+    if ("error" in result) {
+      assert.fail(`handlePlanMilestone failed: ${result.error}`);
+    }
+
+    const roadmap = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "utf-8",
+    );
+
+    assert.equal(
+      roadmap.includes("`[sketch]`"),
+      false,
+      "roadmap must not carry the sketch badge when no slice is a sketch",
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -250,14 +250,14 @@ describe("Post-execution blocking failure retry bypass", () => {
     const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
     
     // Pre-set some retry state
-    s.verificationRetryCount.set("M001/S01/T01", 2);
+    s.verificationRetryCount.set("execute-task:M001/S01/T01", 2);
 
     const vctx: VerificationContext = { s, ctx, pi };
     const result = await runPostUnitVerification(vctx, pauseAutoMock);
 
     // On success, retry count should be cleared
     assert.equal(result, "continue");
-    assert.equal(s.verificationRetryCount.has("M001/S01/T01"), false);
+    assert.equal(s.verificationRetryCount.has("execute-task:M001/S01/T01"), false);
   });
 
   test("post-exec failure notification mentions cross-task consistency", async () => {

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -14,9 +14,9 @@ import {
   insertMilestone,
   insertSlice,
   setSliceSketchFlag,
-  autoHealSketchFlags,
   getSlice,
 } from "../gsd-db.ts";
+import { autoHealSketchFlags } from "../state-reconciliation/drift/sketch-flag.ts";
 import { deriveStateFromDb } from "../state.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";

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

@@ -55,6 +55,14 @@ test("system prompt hard rules forbid fabricating user responses", () => {
   assert.match(prompt, /ask_user_questions.*only valid structured user input/i);
 });
 
+test("system prompt requires reading before edit or overwrite", () => {
+  const prompt = readPrompt("system");
+  assert.match(prompt, /Read before edit or overwrite/i);
+  assert.match(prompt, /Before any write that creates or replaces a file/i);
+  assert.match(prompt, /confirm whether the path exists; if it does, `read` it first/i);
+  assert.match(prompt, /For truly new files, confirm the path does not already exist/i);
+});
+
 test("discuss prompt allows implementation questions when they materially matter", () => {
   const prompt = readPrompt("discuss");
   assert.match(prompt, /Lead with experience, but ask implementation when it materially matters/i);
@@ -64,6 +72,16 @@ test("discuss prompt allows implementation questions when they materially matter
   assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
 });
 
+test("discuss prompt ends milestone planning with next-step handoff", () => {
+  const prompt = readPrompt("discuss");
+  assert.match(prompt, /Next steps:/);
+  assert.match(prompt, /\/gsd auto/);
+  assert.match(prompt, /\/gsd status/);
+  assert.match(prompt, /\/gsd visualize/);
+  assert.match(prompt, /\/gsd notifications/);
+  assert.doesNotMatch(prompt, /nothing else\. Auto-mode will start automatically/);
+});
+
 test("guided discussion prompts avoid wrap-up prompts after every round", () => {
   const milestonePrompt = readPrompt("guided-discuss-milestone");
   const slicePrompt = readPrompt("guided-discuss-slice");
@@ -217,6 +235,17 @@ test("complete-slice prompt does not instruct LLM to toggle checkboxes manually"
   assert.doesNotMatch(prompt, /change \[ \] to \[x\]/);
 });
 
+test("complete-slice prompt keeps source fixes in execution units", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(prompt, /Do not use direct `bash` for verification commands/i);
+  assert.match(prompt, /do \*\*not\*\* edit source files in this unit/i);
+  assert.match(prompt, /do \*\*not\*\* call `gsd_slice_complete`/i);
+  assert.match(prompt, /gsd_task_reopen/);
+  assert.match(prompt, /gsd_replan_slice/);
+  assert.match(prompt, /needs execution follow-up/i);
+  assert.doesNotMatch(prompt, /Fix failures before marking done/i);
+});
+
 test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
@@ -363,7 +392,9 @@ test("execute-task prompt uses camelCase parameter names matching TypeBox schema
 test("complete-slice prompt uses camelCase parameter names matching TypeBox schema", () => {
   const prompt = readPrompt("complete-slice");
   // The gsd_complete_slice tool schema uses camelCase: milestoneId, sliceId
-  const toolCallLine = prompt.split("\n").find((l) => /gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l));
+  const toolCallLine = prompt.split("\n").find((l) =>
+    (/gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l)) && /milestoneId/.test(l) && /sliceId/.test(l)
+  );
   assert.ok(toolCallLine, "prompt must contain a gsd_complete_slice or gsd_slice_complete tool call line");
   assert.doesNotMatch(toolCallLine!, /milestone_id/, "must use milestoneId, not milestone_id");
   assert.doesNotMatch(toolCallLine!, /slice_id/, "must use sliceId, not slice_id");