gsd-pi 2.73.0-dev.1cfd50c → 2.73.0-dev.27730dc

package/src/resources/extensions/gsd/tests/crash-handler-secondary.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Regression tests for #3348 secondary issues — crash handler gaps surfaced after #3696
+ *
+ * 1. register-extension.ts: writeCrashLog writes to ~/.gsd/crash/ directory
+ * 2. register-extension.ts: _gsdRejectionGuard registered for unhandledRejection
+ * 3. register-extension.ts: _gsdEpipeGuard exits with code 1 for unrecoverable errors (no log-and-continue)
+ * 4. crash-recovery.ts: emitCrashRecoveredUnitEnd closes open unit-start journal entries
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, '.gsd'), { recursive: true });
+  return base;
+}
+
+// ─── register-extension source assertions ────────────────────────────────────
+
+const registerExtSrc = readFileSync(
+  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
+  'utf-8',
+);
+
+describe('register-extension crash handler secondary fixes (#3348)', () => {
+  test('writeCrashLog is exported and writes a file to the crash directory', async () => {
+    // Dynamic import so GSD_HOME can be pointed at a temp dir without polluting ~/.gsd
+    const tmpHome = join(tmpdir(), `gsd-crash-test-${randomUUID()}`);
+    const origHome = process.env.GSD_HOME;
+    process.env.GSD_HOME = tmpHome;
+    try {
+      const { writeCrashLog } = await import('../bootstrap/crash-log.ts');
+      const err = new Error('test crash from secondary regression test');
+      writeCrashLog(err, 'uncaughtException');
+
+      const crashDir = join(tmpHome, 'crash');
+      assert.ok(existsSync(crashDir), 'crash directory should be created');
+
+      const logs = readdirSync(crashDir).filter((f) => f.endsWith('.log'));
+      assert.equal(logs.length, 1, 'exactly one crash log should be written');
+
+      const content = readFileSync(join(crashDir, logs[0]), 'utf-8');
+      assert.ok(content.includes('test crash from secondary regression test'), 'log should contain error message');
+      assert.ok(content.includes('uncaughtException'), 'log should identify the source');
+      assert.ok(content.includes('pid:'), 'log should include process pid');
+    } finally {
+      process.env.GSD_HOME = origHome;
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  test('_gsdRejectionGuard is registered for unhandledRejection', () => {
+    assert.match(
+      registerExtSrc,
+      /_gsdRejectionGuard/,
+      '_gsdRejectionGuard handler should be defined',
+    );
+    assert.match(
+      registerExtSrc,
+      /unhandledRejection/,
+      'installEpipeGuard should register an unhandledRejection handler',
+    );
+  });
+
+  test('_gsdEpipeGuard calls process.exit(1) for unrecoverable errors, not log-and-continue', () => {
+    // The original #3696 fix replaced "throw err" with a log-and-continue.
+    // The secondary fix replaces that with writeCrashLog + process.exit(1).
+    assert.ok(
+      !registerExtSrc.includes('process.stderr.write(`[gsd] uncaught extension error (non-fatal)'),
+      '_gsdEpipeGuard should NOT log errors as non-fatal and continue',
+    );
+    assert.match(
+      registerExtSrc,
+      /process\.exit\(1\)/,
+      '_gsdEpipeGuard should call process.exit(1) for unrecoverable errors',
+    );
+  });
+
+  test('writeCrashLog never throws even when directory is unwritable', async () => {
+    const { writeCrashLog } = await import('../bootstrap/crash-log.ts');
+    const origHome = process.env.GSD_HOME;
+    // Point at a path that will fail to mkdir (e.g. a file that exists as non-dir)
+    const tmpFile = join(tmpdir(), `gsd-not-a-dir-${randomUUID()}`);
+    // Don't create it — mkdirSync with bad path should be caught internally
+    process.env.GSD_HOME = join(tmpFile, 'nested', 'deeply');
+    try {
+      // Should not throw
+      assert.doesNotThrow(() => {
+        writeCrashLog(new Error('should not throw'), 'test');
+      });
+    } finally {
+      process.env.GSD_HOME = origHome;
+    }
+  });
+});
+
+// ─── emitCrashRecoveredUnitEnd ────────────────────────────────────────────────
+
+describe('emitCrashRecoveredUnitEnd (#3348)', () => {
+  test('emits synthetic unit-end when unit-start has no matching unit-end', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const flowId = randomUUID();
+      const unitStartSeq = 5;
+
+      // Emit a unit-start with no corresponding unit-end (simulating a crash)
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId,
+        seq: unitStartSeq,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M001/S01/T01' },
+      });
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+      };
+
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const events = queryJournal(base);
+      const ends = events.filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 1, 'should emit exactly one unit-end');
+      assert.equal(ends[0].data?.unitId, 'M001/S01/T01');
+      assert.equal(ends[0].data?.status, 'crash-recovered');
+      assert.equal(ends[0].causedBy?.flowId, flowId);
+      assert.equal(ends[0].causedBy?.seq, unitStartSeq);
+      assert.ok(ends[0].seq > unitStartSeq, 'unit-end seq must be higher than unit-start seq');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('is a no-op when unit-end was already emitted (e.g. hard timeout fired)', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const flowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'plan-slice', unitId: 'M001/S02' },
+      });
+      // Hard timeout already emitted a unit-end
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId,
+        seq: 4,
+        eventType: 'unit-end',
+        data: { unitType: 'plan-slice', unitId: 'M001/S02', status: 'cancelled' },
+        causedBy: { flowId, seq: 3 },
+      });
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'plan-slice',
+        unitId: 'M001/S02',
+        unitStartedAt: new Date().toISOString(),
+      };
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 1, 'should not emit a duplicate unit-end');
+      assert.equal(ends[0].data?.status, 'cancelled', 'original unit-end should be preserved');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('is a no-op for "starting" pseudo-units (bootstrap crash)', async () => {
+    const base = makeTmpBase();
+    try {
+      const { queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'starting',
+        unitId: 'bootstrap',
+        unitStartedAt: new Date().toISOString(),
+      };
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const events = queryJournal(base);
+      assert.equal(events.length, 0, 'should emit nothing for starting/bootstrap pseudo-units');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('is a no-op when no unit-start exists in the journal', async () => {
+    const base = makeTmpBase();
+    try {
+      const { queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M002/S01/T03',
+        unitStartedAt: new Date().toISOString(),
+      };
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const events = queryJournal(base);
+      assert.equal(events.length, 0, 'should emit nothing when there is no journal entry to close');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -15,10 +15,14 @@ import {
   getRequirementById,
   getActiveDecisions,
   getActiveRequirements,
-  getTask,
   transaction,
   _getAdapter,
   _resetProvider,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+  getSliceTasks,
 } from '../gsd-db.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -460,6 +464,60 @@ describe('gsd-db', () => {
     assert.ok(!wasDbOpenAttempted(), 'wasDbOpenAttempted should reset after closeDatabase');
   });
 
+  test('gsd-db: rowToTask tolerates corrupt comma-separated task arrays', () => {
+    openDatabase(':memory:');
+    insertMilestone({ id: 'M001', status: 'active' });
+    insertSlice({ milestoneId: 'M001', id: 'S01', status: 'active' });
+    insertTask({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      id: 'T01',
+      title: 'Recover corrupt arrays',
+      planning: {
+        description: 'desc',
+        estimate: 'small',
+        files: ['src/original.ts'],
+        verify: 'npm test',
+        inputs: ['docs/original.md'],
+        expectedOutput: ['dist/original.md'],
+        observabilityImpact: '',
+      },
+    });
+
+    const adapter = _getAdapter()!;
+    adapter.prepare(
+      `UPDATE tasks
+         SET files = ?, inputs = ?, expected_output = ?, key_files = ?, key_decisions = ?
+       WHERE milestone_id = ? AND slice_id = ? AND id = ?`,
+    ).run(
+      'src-erf/Models/foo.cs, src-erf/Models/bar.cs',
+      'docs/input-a.md, docs/input-b.md',
+      'dist/out-a.md, dist/out-b.md',
+      'src/resources/extensions/gsd/gsd-db.ts, src/resources/extensions/gsd/state.ts',
+      '"decision-1"',
+      'M001',
+      'S01',
+      'T01',
+    );
+
+    const task = getTask('M001', 'S01', 'T01');
+    assert.ok(task, 'getTask should still return the corrupt row');
+    assert.deepStrictEqual(task!.files, ['src-erf/Models/foo.cs', 'src-erf/Models/bar.cs']);
+    assert.deepStrictEqual(task!.inputs, ['docs/input-a.md', 'docs/input-b.md']);
+    assert.deepStrictEqual(task!.expected_output, ['dist/out-a.md', 'dist/out-b.md']);
+    assert.deepStrictEqual(
+      task!.key_files,
+      ['src/resources/extensions/gsd/gsd-db.ts', 'src/resources/extensions/gsd/state.ts'],
+    );
+    assert.deepStrictEqual(task!.key_decisions, ['decision-1']);
+
+    const sliceTasks = getSliceTasks('M001', 'S01');
+    assert.equal(sliceTasks.length, 1, 'getSliceTasks should also survive corrupt rows');
+    assert.deepStrictEqual(sliceTasks[0]!.files, task!.files);
+
+    closeDatabase();
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

package/src/resources/extensions/gsd/tests/park-milestone.test.ts

@@ -3,10 +3,22 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
 
 import { deriveState, invalidateStateCache, getActiveMilestoneId } from '../state.ts';
 import { clearPathCache } from '../paths.ts';
 import { parkMilestone, unparkMilestone, discardMilestone, isParked, getParkedReason } from '../milestone-actions.ts';
+import {
+  closeDatabase,
+  getMilestone,
+  getMilestoneSlices,
+  getSliceTasks,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import { createWorktree } from "../worktree-manager.ts";
 
 
 
@@ -60,9 +72,29 @@ function createMilestone(base: string, mid: string, opts?: { withRoadmap?: boole
 }
 
 function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    // ignore
+  }
   rmSync(base, { recursive: true, force: true });
 }
 
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function initGitRepo(base: string): void {
+  writeFileSync(join(base, "README.md"), "# test\n", "utf-8");
+  writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+  run("git init", base);
+  run("git config user.email test@test.com", base);
+  run("git config user.name Test", base);
+  run("git add .", base);
+  run('git commit -m "init"', base);
+  run("git branch -M main", base);
+}
+
 function clearCaches(): void {
   clearPathCache();
   invalidateStateCache();
@@ -294,6 +326,38 @@ test('discardMilestone updates queue order', () => {
     }
 });
 
+test('discardMilestone removes DB rows, worktree, and milestone branch', () => {
+    const base = createFixtureBase();
+    try {
+      createMilestone(base, 'M001', { withRoadmap: true });
+      initGitRepo(base);
+      clearCaches();
+
+      assert.ok(openDatabase(join(base, '.gsd', 'gsd.db')), 'database opens');
+      insertMilestone({ id: 'M001', title: 'Discard me', status: 'active' });
+      insertSlice({ milestoneId: 'M001', id: 'S01', title: 'Only slice', status: 'pending' });
+      insertTask({ milestoneId: 'M001', sliceId: 'S01', id: 'T01', title: 'Only task', status: 'pending' });
+
+      const wt = createWorktree(base, 'M001', { branch: 'milestone/M001' });
+      assert.ok(existsSync(wt.path), 'worktree exists before discard');
+      assert.ok(run('git branch', base).includes('milestone/M001'), 'milestone branch exists before discard');
+      assert.ok(getMilestone('M001'), 'milestone exists in DB before discard');
+      assert.equal(getMilestoneSlices('M001').length, 1, 'slice exists in DB before discard');
+      assert.equal(getSliceTasks('M001', 'S01').length, 1, 'task exists in DB before discard');
+
+      const success = discardMilestone(base, 'M001');
+      assert.ok(success, 'discardMilestone returns true');
+
+      assert.equal(getMilestone('M001'), null, 'milestone row removed from DB');
+      assert.equal(getMilestoneSlices('M001').length, 0, 'slice rows removed from DB');
+      assert.equal(getSliceTasks('M001', 'S01').length, 0, 'task rows removed from DB');
+      assert.ok(!existsSync(wt.path), 'worktree removed after discard');
+      assert.ok(!run('git branch', base).includes('milestone/M001'), 'milestone branch removed after discard');
+    } finally {
+      cleanup(base);
+    }
+});
+
   // ─── Test 12: All milestones parked → no active milestone ─────────────
 test('All milestones parked → no active', async () => {
     const base = createFixtureBase();

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

@@ -0,0 +1,267 @@
+/**
+ * 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
+ */
+
+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 { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { validatePreferences } from "../preferences-validation.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 = promptsSrc.slice(fnStart, fnStart + 300);
+  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 = promptsSrc.slice(fnStart, fnStart + 300);
+  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 = promptsSrc.slice(fnStart, fnStart + 300);
+  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 = dispatchSrc.slice(ruleStart, ruleStart + 1000);
+  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 = dispatchSrc.slice(callIdx, callIdx + 300);
+  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 = dispatchSrc.slice(callIdx, callIdx + 300);
+  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 }));
+
+  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 model injection",
+      "**Demo:** Model appears in subagent prompt",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Task One** `est:15m`",
+      "  Do something.",
+      "",
+    ].join("\n"),
+  );
+
+  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"),
+  );
+
+  const prompt = await buildReactiveExecutePrompt(
+    "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)}`,
+  );
+});
+
+test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
+  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-none-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+  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"),
+  );
+
+  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"),
+  );
+
+  const prompt = await buildReactiveExecutePrompt(
+    "M001", "Test Milestone", "S01", "Test Slice",
+    ["T01"], repo,
+    // no subagentModel
+  );
+
+  assert.ok(
+    !prompt.includes('with model:'),
+    "Prompt should not contain model instruction when subagentModel is omitted",
+  );
+});