gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.b0acf17e9

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

@@ -1,47 +1,42 @@
 /**
- * Regression test for #3691 — /gsd status opens DB before deriveState
- *
- * In cold sessions the DB was not opened before deriveState, causing
- * status to fall back to filesystem-only state.  The fix adds an
- * ensureDbOpen() call before deriveState in handleStatus.
- *
- * Also verifies that quick.ts checks getIsolationMode before branching.
+ * Regression tests for status/quick behavior.
  */
 
-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 coreSrc = readFileSync(
-  join(__dirname, '..', 'commands', 'handlers', 'core.ts'),
-  'utf-8',
-);
-const quickSrc = readFileSync(
-  join(__dirname, '..', 'quick.ts'),
-  'utf-8',
-);
-
-describe('status opens DB before deriveState (#3691)', () => {
-  test('handleStatus calls ensureDbOpen before deriveState', () => {
-    const ensureIdx = coreSrc.indexOf('ensureDbOpen');
-    const deriveIdx = coreSrc.indexOf('deriveState(basePath)');
-    assert.ok(ensureIdx > -1, 'ensureDbOpen call should exist in core.ts');
-    assert.ok(deriveIdx > -1, 'deriveState(basePath) call should exist in core.ts');
-    assert.ok(
-      ensureIdx < deriveIdx,
-      'ensureDbOpen must appear before deriveState so DB is ready',
-    );
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { buildQuickCommitInstruction } from "../quick.ts";
+
+describe("status opens DB before deriveState (#3691)", () => {
+  test("core handler routes status command", async () => {
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: {
+        custom: async () => undefined,
+        notify: (message: string, level: string) => {
+          notifications.push({ message, level });
+        },
+      },
+    };
+
+    const handled = await handleCoreCommand("status", ctx as any);
+
+    assert.equal(handled, true);
+    assert.ok(notifications.length >= 0);
   });
 
-  test('quick.ts checks getIsolationMode before branching', () => {
-    assert.match(quickSrc, /getIsolationMode\(\)/,
-      'quick.ts should call getIsolationMode()');
-    assert.match(quickSrc, /getIsolationMode\(\)\s*!==\s*"none"/,
-      'quick.ts should compare isolation mode against "none"');
+  test("quick task commit instructions handle external .gsd roots without staging quick files", () => {
+    const instruction = buildQuickCommitInstruction("/project", "/external/.gsd");
+
+    assert.match(instruction, /do not stage or commit `\.gsd\/quick\/\.\.\.`/);
+    assert.match(instruction, /nothing in the project repo to commit/);
+  });
+
+  test("quick task commit instructions include normal commit guidance for in-project .gsd roots", () => {
+    const instruction = buildQuickCommitInstruction("/project", "/project/.gsd");
+
+    assert.doesNotMatch(instruction, /nothing in the project repo to commit/);
+    assert.match(instruction, /Commit your changes atomically/);
   });
 });

package/src/resources/extensions/gsd/tests/stop-auto-merge-back.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Stop-auto worktree exit strategy regression tests.
 /**
  * stop-auto-merge-back.test.ts — Regression test for #2317.
  *
@@ -9,59 +11,48 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ─── Source analysis: stopAuto calls mergeAndExit for complete milestones ────
-
-const autoSrcPath = join(import.meta.dirname, "..", "auto.ts");
-const autoSrc = readFileSync(autoSrcPath, "utf-8");
+import { _selectStopAutoWorktreeExit } from "../auto.ts";
 
 test("#2317: stopAuto should check milestone completion status before choosing exit strategy", () => {
-  // stopAuto Step 4 should NOT unconditionally call exitMilestone(preserveBranch: true).
-  // It should check if the milestone is complete and call mergeAndExit instead.
-
-  // Find the Step 4 section
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
-
-  // Extract a reasonable window around Step 4 (up to Step 5)
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
-
-  // The fix: Step 4 should call mergeAndExit when milestone is complete
-  assert.ok(
-    step4Block.includes("mergeAndExit"),
-    "Step 4 should call mergeAndExit for completed milestones",
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: true,
+      milestoneMergedInPhases: false,
+    }),
+    "merge",
   );
 });
 
-test("#2317: stopAuto should detect milestone completion via SUMMARY file or DB", () => {
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
-
-  // Should check completion status — either via SUMMARY file, DB getMilestone, or phase
-  const checksCompletion =
-    step4Block.includes("SUMMARY") ||
-    step4Block.includes("getMilestone") ||
-    step4Block.includes("complete") ||
-    step4Block.includes("isMilestoneComplete");
-
-  assert.ok(
-    checksCompletion,
-    "Step 4 should check if milestone is complete before deciding exit strategy",
+test("#2317: stopAuto still preserves branch for incomplete milestones", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: false,
+      milestoneMergedInPhases: false,
+    }),
+    "preserve",
   );
 });
 
-test("#2317: stopAuto still preserves branch for incomplete milestones", () => {
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+test("#2317: stopAuto does not merge a milestone already merged in phases", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: true,
+      milestoneMergedInPhases: true,
+    }),
+    "none",
+  );
+});
 
-  // preserveBranch should still be used as fallback for non-complete milestones
-  assert.ok(
-    step4Block.includes("preserveBranch"),
-    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+test("#2317: stopAuto skips worktree teardown when no milestone is active", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: null,
+      milestoneComplete: true,
+      milestoneMergedInPhases: false,
+    }),
+    "none",
   );
 });

package/src/resources/extensions/gsd/tests/stop-auto-race-null-unit.test.ts

@@ -1,106 +1,18 @@
-/**
- * stop-auto-race-null-unit.test.ts — Regression test for #2939.
- *
- * When the user stops auto-mode while a unit is executing, stopAuto()
- * calls s.reset() which sets s.currentUnit = null. The resumed
- * runUnitPhase() then hits s.currentUnit.startedAt on the closeout
- * line and throws a TypeError.
- *
- * The fix adds null guards (matching the existing pattern at lines 136
- * and 344) so that closeout and subsequent accesses are skipped when
- * s.currentUnit has been nulled by a concurrent stopAuto().
- */
+// GSD-2 — stopAuto race current-unit guard regression tests.
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createTestContext, extractSourceRegion } from "./test-helpers.ts";
+import test from "node:test";
+import assert from "node:assert/strict";
 
-const { assertTrue, report } = createTestContext();
+import { _resolveCurrentUnitStartedAtForTest } from "../auto/phases.ts";
 
-const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesPath, "utf-8");
+test("unit started-at resolver tolerates stopAuto clearing currentUnit", () => {
+  assert.equal(_resolveCurrentUnitStartedAtForTest(null), undefined);
+  assert.equal(_resolveCurrentUnitStartedAtForTest(undefined), undefined);
+});
 
-console.log("\n=== #2939: stopAuto race — null guard on s.currentUnit in closeout ===");
-
-// ── Test 1: closeoutUnit call is guarded by if (s.currentUnit) ──────────
-// The closeout block starting around the "Immediate unit closeout" comment
-// must be wrapped in an `if (s.currentUnit)` guard, matching the pattern
-// already used at lines 136 and 344.
-
-const closeoutComment = "Immediate unit closeout";
-const closeoutIdx = phasesSrc.indexOf(closeoutComment);
-assertTrue(
-  closeoutIdx > 0,
-  "phases.ts contains the 'Immediate unit closeout' comment block",
-);
-
-// Extract the region from the closeout comment to the next section comment
-const closeoutRegion = extractSourceRegion(phasesSrc, closeoutComment);
-assertTrue(
-  closeoutRegion.includes("if (s.currentUnit)"),
-  "closeoutUnit call is guarded by `if (s.currentUnit)` check (#2939)",
-);
-
-// ── Test 2: zero-tool-call guard uses s.currentUnit?.startedAt ──────────
-// The zero-tool-call section accesses s.currentUnit!.startedAt (non-null
-// assertion) which will throw if currentUnit is null.
-
-const zeroToolComment = "Zero tool-call guard";
-const zeroToolIdx = phasesSrc.indexOf(zeroToolComment);
-assertTrue(
-  zeroToolIdx > 0,
-  "phases.ts contains the 'Zero tool-call guard' comment block",
-);
-
-const zeroToolRegion = extractSourceRegion(phasesSrc, zeroToolComment);
-
-// The non-null assertion `s.currentUnit!.startedAt` must be replaced with
-// optional chaining `s.currentUnit?.startedAt`
-assertTrue(
-  !zeroToolRegion.includes("s.currentUnit!.startedAt"),
-  "zero-tool-call guard no longer uses non-null assertion on s.currentUnit (#2939)",
-);
-
-// ── Test 3: return value uses optional chaining for startedAt ───────────
-// The final return at the end of runUnitPhase uses s.currentUnit.startedAt
-// which will throw if currentUnit was nulled. It must use optional chaining.
-
-// Find the last return statement in runUnitPhase that references startedAt.
-// There are two: one inside the zero-tool-call block and one at the end.
-// Both must use s.currentUnit?.startedAt
-
-// Count unguarded s.currentUnit.startedAt (without optional chaining)
-// after the "Immediate unit closeout" comment. All of them should use
-// optional chaining or be inside a guard.
-const afterCloseout = phasesSrc.slice(closeoutIdx);
-
-// Count s.currentUnit!.startedAt (non-null assertion — always unsafe)
-const nonNullPattern = /s\.currentUnit!\.startedAt/g;
-const nonNullAfterCloseout = [...afterCloseout.matchAll(nonNullPattern)];
-assertTrue(
-  nonNullAfterCloseout.length === 0,
-  `no non-null assertions s.currentUnit!.startedAt after closeout comment (found ${nonNullAfterCloseout.length}, expected 0) (#2939)`,
-);
-
-// Count bare s.currentUnit.startedAt that are NOT inside an if (s.currentUnit) guard.
-// The closeout block itself uses s.currentUnit.startedAt inside a guard — that's fine.
-// But any usage outside a guard block (e.g. in a return statement) must use optional chaining.
-// We check that all return statements use optional chaining.
-const returnWithBareAccess = /return\s*\{[^}]*s\.currentUnit\.startedAt/g;
-const bareReturnCount = [...afterCloseout.matchAll(returnWithBareAccess)].length;
-assertTrue(
-  bareReturnCount === 0,
-  `no return statements use bare s.currentUnit.startedAt (found ${bareReturnCount}, expected 0) (#2939)`,
-);
-
-// ── Test 4: the return at end of runUnitPhase uses optional chaining ────
-// The final `return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } }`
-// must use optional chaining.
-
-const finalReturnPattern = /unitStartedAt:\s*s\.currentUnit\?\.startedAt/;
-assertTrue(
-  finalReturnPattern.test(afterCloseout),
-  "final return uses s.currentUnit?.startedAt with optional chaining (#2939)",
-);
-
-report();
+test("unit started-at resolver preserves the active unit timestamp", () => {
+  assert.equal(
+    _resolveCurrentUnitStartedAtForTest({ startedAt: 12345 }),
+    12345,
+  );
+});

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -1,173 +1,21 @@
-/**
- * Regression tests for subagent model preference wiring.
- *
- * Fixes: subagent_model config in reactive_execution was validated and stored
- * but never passed through to subagent dispatch instruction strings, so the
- * executing agent autonomously chose "sonnet" instead of the configured model.
- *
- * Issue: gsd-build/gsd-2#4078
- */
+// GSD-2 — Subagent model dispatch behavior tests.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { validatePreferences } from "../preferences-validation.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
-const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-
-// ─── Preference Validation ────────────────────────────────────────────────
-
-test("reactive_execution: subagent_model is preserved in validated preferences", () => {
-  const result = validatePreferences({
-    reactive_execution: {
-      enabled: true,
-      max_parallel: 2,
-      isolation_mode: "same-tree",
-      subagent_model: "claude-opus-4-6",
-    },
-  });
-  assert.equal(result.errors.length, 0);
-  assert.equal(
-    result.preferences.reactive_execution?.subagent_model,
-    "claude-opus-4-6",
-    "subagent_model should be preserved through validation",
-  );
-});
-
-test("reactive_execution: subagent_model rejects empty string", () => {
-  const result = validatePreferences({
-    reactive_execution: {
-      enabled: true,
-      max_parallel: 2,
-      isolation_mode: "same-tree",
-      subagent_model: "",
-    } as any,
-  });
-  assert.ok(
-    result.errors.some((e) => e.includes("subagent_model")),
-    "empty subagent_model should produce a validation error",
-  );
-});
-
-// ─── Structural: Prompt Builders Accept subagentModel ────────────────────
-
-test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
-  assert.ok(fnStart !== -1, "buildReactiveExecutePrompt should be exported");
-  const signature = extractSourceRegion(promptsSrc, "export async function buildReactiveExecutePrompt", { fromIdx: fnStart });
-  assert.ok(
-    signature.includes("subagentModel"),
-    "buildReactiveExecutePrompt should accept a subagentModel parameter",
-  );
-});
-
-test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
-  assert.ok(fnStart !== -1, "buildParallelResearchSlicesPrompt should be exported");
-  const signature = extractSourceRegion(promptsSrc, "export async function buildParallelResearchSlicesPrompt", { fromIdx: fnStart });
-  assert.ok(
-    signature.includes("subagentModel"),
-    "buildParallelResearchSlicesPrompt should accept a subagentModel parameter",
-  );
-});
-
-test("buildGateEvaluatePrompt: accepts subagentModel parameter", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
-  assert.ok(fnStart !== -1, "buildGateEvaluatePrompt should be exported");
-  const signature = extractSourceRegion(promptsSrc, "export async function buildGateEvaluatePrompt", { fromIdx: fnStart });
-  assert.ok(
-    signature.includes("subagentModel"),
-    "buildGateEvaluatePrompt should accept a subagentModel parameter",
-  );
-});
 
-// ─── Structural: Instruction Strings Inject Model ────────────────────────
-
-test("buildReactiveExecutePrompt: instruction string uses subagentModel when set", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
-  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
-  const fnBody = promptsSrc.slice(fnStart, fnEnd);
-  assert.ok(
-    fnBody.includes("subagentModel"),
-    "buildReactiveExecutePrompt body should reference subagentModel",
-  );
-  // The instruction line must be dynamic (not a plain string literal)
-  assert.ok(
-    !fnBody.includes('"Use this as the prompt for a `subagent` call:"'),
-    "instruction should not be a plain static string — model must be injectable",
-  );
-});
-
-test("buildParallelResearchSlicesPrompt: instruction string uses subagentModel when set", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
-  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
-  const fnBody = promptsSrc.slice(fnStart, fnEnd);
-  assert.ok(
-    fnBody.includes("subagentModel"),
-    "buildParallelResearchSlicesPrompt body should reference subagentModel",
-  );
-});
-
-test("buildGateEvaluatePrompt: instruction string uses subagentModel when set", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
-  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
-  const fnBody = promptsSrc.slice(fnStart, fnEnd);
-  assert.ok(
-    fnBody.includes("subagentModel"),
-    "buildGateEvaluatePrompt body should reference subagentModel",
-  );
-});
-
-// ─── Structural: Dispatch Wires Model to Prompt Builders ─────────────────
-
-test("auto-dispatch: passes model to buildReactiveExecutePrompt", () => {
-  // Find the reactive-execute dispatch rule
-  const ruleStart = dispatchSrc.indexOf("reactive-execute (parallel dispatch)");
-  assert.ok(ruleStart !== -1, "reactive-execute dispatch rule should exist");
-  const ruleBlock = extractSourceRegion(dispatchSrc, "reactive-execute (parallel dispatch)", { fromIdx: ruleStart });
-  assert.ok(
-    ruleBlock.includes("subagent_model") || ruleBlock.includes("subagentModel"),
-    "reactive-execute rule should resolve and pass the subagent model",
-  );
-});
-
-test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
-  const callIdx = dispatchSrc.indexOf("buildParallelResearchSlicesPrompt(");
-  assert.ok(callIdx !== -1, "buildParallelResearchSlicesPrompt call should exist");
-  // The call site should pass a model argument (not just 4 args)
-  const callSite = extractSourceRegion(dispatchSrc, "buildParallelResearchSlicesPrompt(", { fromIdx: callIdx });
-  assert.ok(
-    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
-    "buildParallelResearchSlicesPrompt call should include model argument",
-  );
-});
-
-test("auto-dispatch: passes model to buildGateEvaluatePrompt", () => {
-  const callIdx = dispatchSrc.indexOf("buildGateEvaluatePrompt(");
-  assert.ok(callIdx !== -1, "buildGateEvaluatePrompt call should exist");
-  const callSite = extractSourceRegion(dispatchSrc, "buildGateEvaluatePrompt(", { fromIdx: callIdx });
-  assert.ok(
-    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
-    "buildGateEvaluatePrompt call should include model argument",
-  );
-});
-
-// ─── Integration: Prompt Output Contains Model String ────────────────────
-
-test("buildReactiveExecutePrompt: output contains model string when subagentModel provided", async (t) => {
-  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
-  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-reactive-"));
-  t.after(() => rmSync(repo, { recursive: true, force: true }));
+import { validatePreferences } from "../preferences-validation.ts";
+import {
+  buildGateEvaluatePrompt,
+  buildParallelResearchSlicesPrompt,
+  buildReactiveExecutePrompt,
+} from "../auto-prompts.ts";
 
+function writeReactiveFixture(repo: string): void {
   const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
   mkdirSync(join(gsd, "tasks"), { recursive: true });
-
   writeFileSync(
     join(gsd, "S01-PLAN.md"),
     [
@@ -183,7 +31,6 @@ test("buildReactiveExecutePrompt: output contains model string when subagentMode
       "",
     ].join("\n"),
   );
-
   writeFileSync(
     join(gsd, "tasks", "T01-PLAN.md"),
     [
@@ -201,82 +48,87 @@ test("buildReactiveExecutePrompt: output contains model string when subagentMode
       "- `src/out.ts` — Result",
     ].join("\n"),
   );
+}
+
+test("reactive_execution subagent_model is preserved in validated preferences", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "claude-opus-4-6",
+    },
+  });
+  assert.equal(result.errors.length, 0);
+  assert.equal(result.preferences.reactive_execution?.subagent_model, "claude-opus-4-6");
+});
+
+test("reactive_execution subagent_model rejects empty string", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "",
+    } as any,
+  });
+  assert.ok(result.errors.some((e) => e.includes("subagent_model")));
+});
+
+test("buildReactiveExecutePrompt injects subagent model when provided", async (t) => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-reactive-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+  writeReactiveFixture(repo);
 
   const prompt = await buildReactiveExecutePrompt(
-    "M001", "Test Milestone", "S01", "Test Slice",
-    ["T01"], repo, "claude-opus-4-6",
+    "M001",
+    "Test Milestone",
+    "S01",
+    "Test Slice",
+    ["T01"],
+    repo,
+    "claude-opus-4-6",
   );
 
-  assert.ok(
-    prompt.includes('model: "claude-opus-4-6"'),
-    `Prompt should contain model instruction. Got:\n${prompt.slice(0, 500)}`,
-  );
-  assert.ok(
-    prompt.includes("Context Mode (execution lane):"),
-    "embedded reactive-execute task prompt should use nested Context Mode guidance",
-  );
-  assert.ok(
-    prompt.includes("## Context Mode"),
-    "reactive-execute parent prompt should include standalone Context Mode guidance",
-  );
+  assert.match(prompt, /model: "claude-opus-4-6"/);
+  assert.match(prompt, /Context Mode \(execution lane\):/);
+  assert.match(prompt, /## Context Mode/);
 });
 
-test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
-  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+test("buildReactiveExecutePrompt omits model instruction when subagentModel is omitted", async (t) => {
   const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-none-"));
   t.after(() => rmSync(repo, { recursive: true, force: true }));
+  writeReactiveFixture(repo);
 
-  const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
-  mkdirSync(join(gsd, "tasks"), { recursive: true });
-
-  writeFileSync(
-    join(gsd, "S01-PLAN.md"),
-    [
-      "# S01: Test Slice",
-      "",
-      "**Goal:** Verify no model when omitted",
-      "**Demo:** No model string",
-      "",
-      "## Tasks",
-      "",
-      "- [ ] **T01: Task One** `est:15m`",
-      "  Do something.",
-      "",
-    ].join("\n"),
+  const prompt = await buildReactiveExecutePrompt(
+    "M001",
+    "Test Milestone",
+    "S01",
+    "Test Slice",
+    ["T01"],
+    repo,
   );
 
-  writeFileSync(
-    join(gsd, "tasks", "T01-PLAN.md"),
-    [
-      "# T01: Task One",
-      "",
-      "## Description",
-      "Do something.",
-      "",
-      "## Inputs",
-      "",
-      "- `src/config.json` — Config",
-      "",
-      "## Expected Output",
-      "",
-      "- `src/out.ts` — Result",
-    ].join("\n"),
-  );
+  assert.doesNotMatch(prompt, /with model:/);
+});
 
-  const prompt = await buildReactiveExecutePrompt(
-    "M001", "Test Milestone", "S01", "Test Slice",
-    ["T01"], repo,
-    // no subagentModel
-  );
+test("buildParallelResearchSlicesPrompt injects subagent model for each slice", async (t) => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-parallel-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+  mkdirSync(join(repo, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
 
-  assert.ok(
-    !prompt.includes('with model:'),
-    "Prompt should not contain model instruction when subagentModel is omitted",
+  const prompt = await buildParallelResearchSlicesPrompt(
+    "M001",
+    "Test Milestone",
+    [{ id: "S01", title: "Research Slice" }],
+    repo,
+    "claude-opus-4-6",
   );
+
+  assert.match(prompt, /model: "claude-opus-4-6"/);
 });
 
-test("buildGateEvaluatePrompt: embedded gate prompts use nested Context Mode guidance", async (t) => {
-  const { buildGateEvaluatePrompt } = await import("../auto-prompts.ts");
+test("buildGateEvaluatePrompt uses nested context guidance and model instruction", async (t) => {
   const { closeDatabase, insertGateRow, insertMilestone, insertSlice, openDatabase } = await import("../gsd-db.ts");
   const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-gate-"));
   t.after(() => {
@@ -315,13 +167,7 @@ test("buildGateEvaluatePrompt: embedded gate prompts use nested Context Mode gui
     "claude-opus-4-6",
   );
 
-  assert.ok(
-    prompt.includes("Context Mode (verification lane):"),
-    "embedded gate-evaluate prompt should use nested Context Mode guidance",
-  );
-  assert.ok(
-    prompt.includes("## Context Mode"),
-    "gate-evaluate parent prompt should include standalone Context Mode guidance",
-  );
-  assert.ok(prompt.includes('model: "claude-opus-4-6"'), "gate subagent prompt should preserve model instruction");
+  assert.match(prompt, /Context Mode \(verification lane\):/);
+  assert.match(prompt, /## Context Mode/);
+  assert.match(prompt, /model: "claude-opus-4-6"/);
 });