gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -1,63 +1,79 @@
 /**
- * Regression test: S##-CONTEXT.md from slice discussion must be
- * injected into all 5 downstream prompt builders (#3452).
- *
- * Scans auto-prompts.ts for the 5 builder functions and verifies
- * each one resolves and inlines the slice-level CONTEXT file.
+ * Regression test: S##-CONTEXT.md from slice discussion is injected into
+ * downstream prompt builders (#3452).
  */
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
-const source = readFileSync(autoPromptsPath, "utf-8");
+import {
+  buildCompleteSlicePrompt,
+  buildPlanSlicePrompt,
+  buildReassessRoadmapPrompt,
+  buildReplanSlicePrompt,
+  buildResearchSlicePrompt,
+} from "../auto-prompts.ts";
 
-const BUILDERS = [
-  "buildResearchSlicePrompt",
-  "buildPlanSlicePrompt",
-  "buildCompleteSlicePrompt",
-  "buildReplanSlicePrompt",
-  "buildReassessRoadmapPrompt",
-];
+function makeSliceContextFixture(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-context-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceDir, "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Context Injection",
+      "",
+      "## Slices",
+      "- [ ] **S01: Context-heavy slice** `risk:low`",
+      "  Demo: context appears in prompts.",
+    ].join("\n"),
+    "utf-8",
+  );
+  writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# M001 Context\n", "utf-8");
+  writeFileSync(
+    join(sliceDir, "S01-CONTEXT.md"),
+    "# Slice Context\n\nUnique slice context marker: SLICE-CONTEXT-3452\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Context-heavy slice",
+      "",
+      "**Goal:** Test context injection.",
+      "**Demo:** Prompt contains the marker.",
+      "",
+      "## Tasks",
+      "- [ ] **T01: Task** `est:10m`",
+    ].join("\n"),
+    "utf-8",
+  );
+  return base;
+}
 
 describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
-  for (const builder of BUILDERS) {
-    test(`${builder} resolves slice CONTEXT file`, () => {
-      // Find the function body
-      const fnStart = source.indexOf(`export async function ${builder}`);
-      assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
+  const builders: Array<[string, (base: string) => Promise<string>]> = [
+    ["buildResearchSlicePrompt", (base) => buildResearchSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildPlanSlicePrompt", (base) => buildPlanSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildCompleteSlicePrompt", (base) => buildCompleteSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildReplanSlicePrompt", (base) => buildReplanSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildReassessRoadmapPrompt", (base) => buildReassessRoadmapPrompt("M001", "Context Injection", "S01", base)],
+  ];
 
-      // Get a reasonable chunk after the function start
-      const chunk = extractSourceRegion(source, `export async function ${builder}`);
-
-      // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
-      // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
-      // resolve. When a builder delegates, scan the helper's body instead.
-      const delegatesToHelper = chunk.includes("renderSlicePrompt(");
-      const bodyToCheck = delegatesToHelper
-        ? (() => {
-            const helperStart = source.indexOf("async function renderSlicePrompt");
-            assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
-            return extractSourceRegion(source, "async function renderSlicePrompt");
-          })()
-        : chunk;
-
-      // Must resolve the slice CONTEXT path
-      assert.ok(
-        bodyToCheck.includes('resolveSliceFile(base, mid,') && bodyToCheck.includes('"CONTEXT"'),
-        `${builder} should call resolveSliceFile with "CONTEXT" (directly or via renderSlicePrompt)`,
-      );
-
-      // Must inline it with inlineFileOptional
-      assert.ok(
-        bodyToCheck.includes("Slice Context"),
-        `${builder} should inline slice CONTEXT with a "Slice Context" label`,
-      );
+  for (const [name, build] of builders) {
+    test(`${name} includes slice discussion context`, async () => {
+      const base = makeSliceContextFixture();
+      try {
+        const prompt = await build(base);
+        assert.match(prompt, /Slice Context/);
+        assert.match(prompt, /SLICE-CONTEXT-3452/);
+      } finally {
+        rmSync(base, { recursive: true, force: true });
+      }
     });
   }
 });

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

@@ -1,20 +1,20 @@
-/**
- * Structural tests for slice-level parallel orchestrator.
- * Verifies the orchestrator module exists and has the correct shape,
- * env var usage, and preference gating.
- */
+// GSD-2 — Slice parallel orchestrator behavior tests.
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync, spawn } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { restoreSliceState, SLICE_WORKER_AUTO_ARGS } from "../slice-parallel-orchestrator.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
+import { deriveState } from "../state.js";
+import { validatePreferences } from "../preferences-validation.ts";
+import {
+  _buildSliceWorkerEnvForTest,
+  _resolveSliceParallelMaxWorkersForTest,
+  restoreSliceState,
+  SLICE_WORKER_AUTO_ARGS,
+} from "../slice-parallel-orchestrator.ts";
 
 function readLinuxProcessStartFingerprint(pid: number): string | null {
   try {
@@ -83,81 +83,31 @@ function writeSliceOrchestratorState(
   );
 }
 
-describe("slice-parallel-orchestrator structural tests", () => {
-  it("orchestrator uses GSD_SLICE_LOCK env var", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_SLICE_LOCK"),
-      "Orchestrator must use GSD_SLICE_LOCK env var to isolate slice workers",
-    );
-  });
-
-  it("orchestrator sets GSD_PARALLEL_WORKER=1 to prevent nesting", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_PARALLEL_WORKER"),
-      "Orchestrator must set GSD_PARALLEL_WORKER to prevent nested parallel",
-    );
-  });
-
-  it("slice workers use headless auto instead of print-mode slash commands", () => {
-    const args: readonly string[] = SLICE_WORKER_AUTO_ARGS;
-    assert.deepEqual([...args], ["headless", "--json", "auto"]);
-    assert.equal(args.includes("--print"), false);
-  });
-
-  it("maxWorkers default is 2", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    // Check that default max workers is 2 (in opts.maxWorkers ?? 2 or similar)
-    assert.ok(
-      source.includes("maxWorkers") && source.includes("2"),
-      "Default maxWorkers should be 2",
-    );
-  });
-
-  it("orchestrator imports GSD_MILESTONE_LOCK for milestone isolation", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_MILESTONE_LOCK"),
-      "Orchestrator must also pass GSD_MILESTONE_LOCK for milestone context",
-    );
+describe("slice worker launch contract", () => {
+  it("uses headless auto instead of print-mode slash commands", () => {
+    assert.deepEqual([...SLICE_WORKER_AUTO_ARGS], ["headless", "--json", "auto"]);
+    assert.equal(SLICE_WORKER_AUTO_ARGS.includes("--print" as never), false);
   });
 
-  it("recovery preserves terminal workers for coordinator-side collection", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes('} else if (w.state === "running")') &&
-        source.includes("survivors.push(w);"),
-      "Recovery must only prune dead running workers, not stopped/error workers",
+  it("builds isolated worker environment", () => {
+    const env = _buildSliceWorkerEnvForTest(
+      "/repo",
+      "M001",
+      "S02",
+      "worker-token",
+      { PATH: "/bin" } as NodeJS.ProcessEnv,
     );
-  });
 
-  it("recovered PID-only workers are validated before signaling", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("isRecoveredSliceWorkerAlive(worker)") &&
-        source.includes('process.kill(worker.pid, "SIGTERM")'),
-      "stopSliceParallel must validate recovered worker identity before signaling a PID",
-    );
+    assert.equal(env.GSD_SLICE_LOCK, "S02");
+    assert.equal(env.GSD_MILESTONE_LOCK, "M001");
+    assert.equal(env.GSD_PROJECT_ROOT, "/repo");
+    assert.equal(env.GSD_PARALLEL_WORKER, "1");
+    assert.equal(env.GSD_SLICE_WORKER_TOKEN, "worker-token");
   });
 
-  it("persists worker identity for crash recovery", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("workerToken") &&
-        source.includes("processStartFingerprint") &&
-        source.includes("GSD_SLICE_WORKER_TOKEN"),
-      "Orchestrator must persist stable worker identity metadata for recovered workers",
-    );
-  });
-
-  it("spawn failures remove stale worker state and worktree", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("sliceState.workers.delete(slice.id)") &&
-        source.includes("removeWorktree(basePath, wtName, { deleteBranch: true, force: true })"),
-      "Failed slice worker spawns must remove stale worker state and clean up the worktree",
-    );
+  it("defaults to two workers unless explicitly configured", () => {
+    assert.equal(_resolveSliceParallelMaxWorkersForTest(), 2);
+    assert.equal(_resolveSliceParallelMaxWorkersForTest(4), 4);
   });
 });
 
@@ -217,36 +167,47 @@ describe("slice-parallel-orchestrator recovery identity", () => {
   });
 });
 
-describe("slice_parallel preference gating", () => {
-  it("preferences-types.ts includes slice_parallel in interface", () => {
-    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
-    assert.ok(
-      source.includes("slice_parallel"),
-      "GSDPreferences should have slice_parallel field",
-    );
-  });
-
-  it("slice_parallel is in KNOWN_PREFERENCE_KEYS", () => {
-    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
-    assert.ok(
-      source.includes('"slice_parallel"'),
-      'KNOWN_PREFERENCE_KEYS should include "slice_parallel"',
-    );
+describe("slice_parallel preference and state gating", () => {
+  it("validates slice_parallel preferences", () => {
+    const result = validatePreferences({
+      slice_parallel: { enabled: true, max_workers: 3 },
+    });
+
+    assert.equal(result.errors.length, 0);
+    assert.deepEqual(result.preferences.slice_parallel, {
+      enabled: true,
+      max_workers: 3,
+    });
   });
 
-  it("state.ts checks GSD_SLICE_LOCK for slice isolation", () => {
-    const source = readFileSync(join(gsdDir, "state.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_SLICE_LOCK"),
-      "State derivation should check GSD_SLICE_LOCK for slice-level parallel isolation",
-    );
-  });
+  it("derives the locked slice for parallel workers", async () => {
+    const basePath = makeTempProject();
+    const oldWorker = process.env.GSD_PARALLEL_WORKER;
+    const oldSlice = process.env.GSD_SLICE_LOCK;
+    try {
+      const msDir = join(basePath, ".gsd", "milestones", "M001");
+      mkdirSync(msDir, { recursive: true });
+      writeFileSync(
+        join(msDir, "M001-ROADMAP.md"),
+        [
+          "# M001",
+          "",
+          "## Slices",
+          "- [ ] **S01: First** `risk:low` `depends:[]`",
+          "- [ ] **S02: Second** `risk:low` `depends:[]`",
+        ].join("\n"),
+      );
+      process.env.GSD_PARALLEL_WORKER = "1";
+      process.env.GSD_SLICE_LOCK = "S02";
 
-  it("auto.ts imports slice parallel orchestrator when enabled", () => {
-    const source = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
-    assert.ok(
-      source.includes("slice_parallel") || source.includes("slice-parallel"),
-      "auto.ts should reference slice_parallel for dispatch gating",
-    );
+      const state = await deriveState(basePath);
+      assert.equal(state.activeSlice?.id, "S02");
+    } finally {
+      if (oldWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+      else process.env.GSD_PARALLEL_WORKER = oldWorker;
+      if (oldSlice === undefined) delete process.env.GSD_SLICE_LOCK;
+      else process.env.GSD_SLICE_LOCK = oldSlice;
+      rmSync(basePath, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/slice-sequence-insert.test.ts

@@ -1,51 +1,124 @@
 /**
- * Regression test for #3697 — set slice sequence on insert
- *
- * All three insertSlice call sites must pass a sequence value so slices
- * are ordered correctly instead of defaulting to 0.
+ * Regression test for #3697 — set slice sequence on insert.
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const planMilestoneSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'plan-milestone.ts'),
-  'utf-8',
-);
-const reassessRoadmapSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'reassess-roadmap.ts'),
-  'utf-8',
-);
-const mdImporterSrc = readFileSync(
-  join(__dirname, '..', 'md-importer.ts'),
-  'utf-8',
-);
-
-describe('slice sequence on insert (#3697)', () => {
-  test('plan-milestone.ts passes sequence to insertSlice', () => {
-    assert.match(planMilestoneSrc, /insertSlice\(/,
-      'plan-milestone.ts should call insertSlice');
-    assert.match(planMilestoneSrc, /sequence:\s*i\s*\+\s*1/,
-      'plan-milestone.ts should pass sequence: i + 1');
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handlePlanMilestone } from "../tools/plan-milestone.ts";
+import { handleReassessRoadmap } from "../tools/reassess-roadmap.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import {
+  closeDatabase,
+  getMilestoneSlices,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+
+let tempBase: string | null = null;
+
+afterEach(() => {
+  closeDatabase();
+  if (tempBase) rmSync(tempBase, { recursive: true, force: true });
+  tempBase = null;
+});
+
+function makeBase(name: string): string {
+  tempBase = mkdtempSync(join(tmpdir(), name));
+  mkdirSync(join(tempBase, ".gsd", "milestones"), { recursive: true });
+  openDatabase(join(tempBase, ".gsd", "gsd.db"));
+  return tempBase;
+}
+
+function slice(sliceId: string, title: string) {
+  return {
+    sliceId,
+    title,
+    risk: "low",
+    depends: [],
+    demo: `${title} demo`,
+    goal: `${title} goal`,
+    successCriteria: `${title} success`,
+    proofLevel: "unit",
+    integrationClosure: "covered",
+    observabilityImpact: "none",
+  };
+}
+
+describe("slice sequence on insert (#3697)", () => {
+  test("plan milestone persists slices in agent-provided order", async () => {
+    const base = makeBase("gsd-sequence-plan-");
+
+    const result = await handlePlanMilestone({
+      milestoneId: "M001",
+      title: "Sequence",
+      vision: "Preserve slice order",
+      slices: [slice("S01", "First"), slice("S02", "Second"), slice("S03", "Third")],
+    }, base);
+
+    assert.ok(!("error" in result), JSON.stringify(result));
+    assert.deepEqual(
+      getMilestoneSlices("M001").map((row) => [row.id, row.sequence]),
+      [["S01", 1], ["S02", 2], ["S03", 3]],
+    );
   });
 
-  test('reassess-roadmap.ts passes sequence to insertSlice', () => {
-    assert.match(reassessRoadmapSrc, /insertSlice\(/,
-      'reassess-roadmap.ts should call insertSlice');
-    assert.match(reassessRoadmapSrc, /sequence:\s*existingCount\s*\+\s*i\s*\+\s*1/,
-      'reassess-roadmap.ts should pass sequence: existingCount + i + 1');
+  test("reassess roadmap appends new slices after existing slices", async () => {
+    const base = makeBase("gsd-sequence-reassess-");
+    insertMilestone({ id: "M001", title: "Sequence", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Done", status: "complete", risk: "low", depends: [], demo: "", sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Existing", status: "pending", risk: "low", depends: [], demo: "", sequence: 2 });
+
+    const result = await handleReassessRoadmap({
+      milestoneId: "M001",
+      completedSliceId: "S01",
+      verdict: "pass",
+      assessment: "Add follow-up slices.",
+      sliceChanges: {
+        modified: [],
+        added: [
+          { sliceId: "S03", title: "Added 1", risk: "low", depends: [], demo: "" },
+          { sliceId: "S04", title: "Added 2", risk: "low", depends: [], demo: "" },
+        ],
+        removed: [],
+      },
+    }, base);
+
+    assert.ok(!("error" in result), JSON.stringify(result));
+    assert.deepEqual(
+      getMilestoneSlices("M001").map((row) => [row.id, row.sequence]),
+      [["S01", 1], ["S02", 2], ["S03", 3], ["S04", 4]],
+    );
   });
 
-  test('md-importer.ts passes sequence to insertSlice', () => {
-    assert.match(mdImporterSrc, /insertSlice\(/,
-      'md-importer.ts should call insertSlice');
-    assert.match(mdImporterSrc, /sequence:\s*si\s*\+\s*1/,
-      'md-importer.ts should pass sequence: si + 1');
+  test("markdown importer preserves roadmap order in sequence values", () => {
+    const base = makeBase("gsd-sequence-import-");
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(
+      join(milestoneDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Imported",
+        "",
+        "## Slices",
+        "- [ ] **S01: First** `risk:low`",
+        "  Demo: first.",
+        "- [ ] **S02: Second** `risk:low`",
+        "  Demo: second.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const result = migrateHierarchyToDb(base);
+
+    assert.equal(result.slices, 2);
+    assert.deepEqual(
+      getMilestoneSlices("M001").map((row) => [row.id, row.sequence]),
+      [["S01", 1], ["S02", 2]],
+    );
   });
 });

package/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts

@@ -1,34 +1,33 @@
+// GSD-2 — Guided smart entry complete-state behavior tests.
+
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-const { deriveState } = await import("../state.js");
+import { deriveState } from "../state.js";
+
+function writeCompleteMilestone(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Complete Milestone",
+      "",
+      "## Slices",
+      "- [x] **S01: Done slice** `risk:low` `depends:[]`",
+      "  > Done.",
+    ].join("\n"),
+  );
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# M001 Summary\n\nComplete.");
+}
 
 test("deriveState reports the last completed milestone when all milestone slices are done", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-smart-entry-complete-"));
-
   try {
-    const milestoneDir = join(base, ".gsd", "milestones", "M001");
-    mkdirSync(milestoneDir, { recursive: true });
-
-    writeFileSync(
-      join(milestoneDir, "M001-ROADMAP.md"),
-      [
-        "# M001: Complete Milestone",
-        "",
-        "## Slices",
-        "- [x] **S01: Done slice** `risk:low` `depends:[]`",
-        "  > Done.",
-      ].join("\n"),
-    );
-
-    writeFileSync(
-      join(milestoneDir, "M001-SUMMARY.md"),
-      "# M001 Summary\n\nComplete.",
-    );
-
+    writeCompleteMilestone(base);
     const state = await deriveState(base);
     assert.equal(state.phase, "complete");
     assert.equal(state.lastCompletedMilestone?.id, "M001");
@@ -36,40 +35,3 @@ test("deriveState reports the last completed milestone when all milestone slices
     rmSync(base, { recursive: true, force: true });
   }
 });
-
-test("guided-flow complete branch offers a chooser for next milestone or status", () => {
-  const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  const branchIdx = guidedFlowSource.indexOf('state.phase === "complete"');
-
-  assert.ok(branchIdx > -1, "guided-flow.ts should have a complete-phase smart-entry branch");
-
-  const nextBranchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"', branchIdx);
-  const branchChunk = guidedFlowSource.slice(branchIdx, nextBranchIdx === -1 ? branchIdx + 1600 : nextBranchIdx);
-
-  assert.match(branchChunk, /showNextAction\(/, "complete branch should present a chooser");
-  assert.match(branchChunk, /findMilestoneIds\(basePath\)/, "complete branch should compute the next milestone id");
-  assert.match(
-    branchChunk,
-    /nextMilestoneIdReserved\(milestoneIds,\s*uniqueMilestoneIds,\s*basePath\)/,
-    "complete branch should derive the next milestone id",
-  );
-  assert.match(branchChunk, /dispatchWorkflow\(pi, await prepareAndBuildDiscussPrompt\(/, "complete branch should dispatch the prepared discuss prompt");
-});
-
-test("guided-flow needs-discussion skip branch opens the project DB before reserving a new milestone", () => {
-  const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  const laterDbOpenIdx = guidedFlowSource.indexOf("// Ensure DB is open before querying slices (#2560).");
-  assert.ok(laterDbOpenIdx > -1, "guided-flow.ts should contain the post-draft DB-open guard");
-
-  const branchPrefix = guidedFlowSource.slice(0, laterDbOpenIdx);
-  const skipBranchIdx = branchPrefix.lastIndexOf('choice === "skip_milestone"');
-  assert.ok(skipBranchIdx > -1, "needs-discussion skip branch should be present");
-
-  const branchChunk = branchPrefix.slice(skipBranchIdx);
-  const ensureIdx = branchChunk.indexOf("ensureDbOpen(basePath)");
-  const reserveIdx = branchChunk.indexOf("nextMilestoneIdReserved");
-
-  assert.ok(ensureIdx > -1, "skip branch should open the project DB");
-  assert.ok(reserveIdx > -1, "skip branch should reserve the next milestone ID");
-  assert.ok(ensureIdx < reserveIdx, "project DB must be opened before milestone ID reservation");
-});