gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

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

@@ -297,7 +297,6 @@ describe("parallel-orchestrator: lifecycle", () => {
             worktreePath: "/tmp/wt-M001",
             startedAt: Date.now(),
             state: "running",
-            completedUnits: 2,
             cost: 0.25,
           },
         ],
@@ -309,7 +308,6 @@ describe("parallel-orchestrator: lifecycle", () => {
       const workers = getWorkerStatuses(base);
       assert.equal(workers.length, 1);
       assert.equal(workers[0].milestoneId, "M001");
-      assert.equal(workers[0].completedUnits, 2);
       assert.equal(isParallelActive(), true);
     } finally {
       resetOrchestrator();
@@ -416,7 +414,6 @@ describe("parallel-orchestrator: lifecycle", () => {
       const workers = getWorkerStatuses();
       assert.equal(workers.length, 1);
       assert.equal(workers[0].state, "running");
-      assert.equal(workers[0].completedUnits, 4);
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });
@@ -552,7 +549,6 @@ function makeWorker(overrides: Partial<WorkerInfo> = {}): WorkerInfo {
     worktreePath: "/tmp/test-worktree",
     startedAt: Date.now() - 60_000,
     state: "stopped",
-    completedUnits: 5,
     cost: 2.50,
     ...overrides,
   };
@@ -563,9 +559,9 @@ function makeWorker(overrides: Partial<WorkerInfo> = {}): WorkerInfo {
 describe("parallel-merge: determineMergeOrder sequential", () => {
   it("returns milestone IDs sorted alphabetically by default", () => {
     const workers = [
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 1 }),
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 2 }),
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 3 }),
+      makeWorker({ milestoneId: "M003", state: "stopped" }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
+      makeWorker({ milestoneId: "M002", state: "stopped" }),
     ];
     const order = determineMergeOrder(workers, "sequential");
     assert.deepEqual(order, ["M001", "M002", "M003"]);
@@ -573,27 +569,27 @@ describe("parallel-merge: determineMergeOrder sequential", () => {
 
   it("excludes workers that are still running", () => {
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 5 }),
-      makeWorker({ milestoneId: "M002", state: "running", completedUnits: 0 }),
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 2 }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
+      makeWorker({ milestoneId: "M002", state: "running" }),
+      makeWorker({ milestoneId: "M003", state: "stopped" }),
     ];
     const order = determineMergeOrder(workers, "sequential");
     assert.deepEqual(order, ["M001", "M003"]);
   });
 
-  it("excludes workers with zero completedUnits even if stopped", () => {
+  it("includes all stopped workers", () => {
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 0 }),
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 3 }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
+      makeWorker({ milestoneId: "M002", state: "stopped" }),
     ];
     const order = determineMergeOrder(workers, "sequential");
-    assert.deepEqual(order, ["M002"]);
+    assert.deepEqual(order, ["M001", "M002"]);
   });
 
   it("returns empty array when no workers are completed", () => {
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "running", completedUnits: 0 }),
-      makeWorker({ milestoneId: "M002", state: "paused", completedUnits: 0 }),
+      makeWorker({ milestoneId: "M001", state: "running" }),
+      makeWorker({ milestoneId: "M002", state: "paused" }),
     ];
     const order = determineMergeOrder(workers);
     assert.deepEqual(order, []);
@@ -601,8 +597,8 @@ describe("parallel-merge: determineMergeOrder sequential", () => {
 
   it("uses sequential order as the default when no order arg provided", () => {
     const workers = [
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 1 }),
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 1 }),
+      makeWorker({ milestoneId: "M002", state: "stopped" }),
+      makeWorker({ milestoneId: "M001", state: "stopped" }),
     ];
     // Call with no second argument — should default to "sequential"
     const order = determineMergeOrder(workers);
@@ -614,9 +610,9 @@ describe("parallel-merge: determineMergeOrder by-completion", () => {
   it("returns milestones sorted by startedAt (earliest first)", () => {
     const now = Date.now();
     const workers = [
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 1, startedAt: now - 30_000 }),
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 1, startedAt: now - 90_000 }),
-      makeWorker({ milestoneId: "M002", state: "stopped", completedUnits: 1, startedAt: now - 60_000 }),
+      makeWorker({ milestoneId: "M003", state: "stopped", startedAt: now - 30_000 }),
+      makeWorker({ milestoneId: "M001", state: "stopped", startedAt: now - 90_000 }),
+      makeWorker({ milestoneId: "M002", state: "stopped", startedAt: now - 60_000 }),
     ];
     const order = determineMergeOrder(workers, "by-completion");
     assert.deepEqual(order, ["M001", "M002", "M003"]);
@@ -625,9 +621,9 @@ describe("parallel-merge: determineMergeOrder by-completion", () => {
   it("excludes paused workers from by-completion order", () => {
     const now = Date.now();
     const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 2, startedAt: now - 90_000 }),
-      makeWorker({ milestoneId: "M002", state: "paused",  completedUnits: 1, startedAt: now - 60_000 }),
-      makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 3, startedAt: now - 30_000 }),
+      makeWorker({ milestoneId: "M001", state: "stopped", startedAt: now - 90_000 }),
+      makeWorker({ milestoneId: "M002", state: "paused",  startedAt: now - 60_000 }),
+      makeWorker({ milestoneId: "M003", state: "stopped", startedAt: now - 30_000 }),
     ];
     const order = determineMergeOrder(workers, "by-completion");
     assert.deepEqual(order, ["M001", "M003"]);

package/src/resources/extensions/gsd/tests/parallel-worker-monitoring.test.ts

@@ -155,7 +155,6 @@ describe("parallel-worker-monitoring", () => {
             worktreePath: "/tmp/wt-M001",
             startedAt: Date.now(),
             state: "running",
-            completedUnits: 1,
             cost: 0.1,
           },
         ],
@@ -191,7 +190,6 @@ describe("parallel-worker-monitoring", () => {
       refreshWorkerStatuses(base, { restoreIfNeeded: true });
       const workers = getWorkerStatuses();
       assert.deepStrictEqual(workers[0].state, "running", "live session status restored");
-      assert.deepStrictEqual(workers[0].completedUnits, 3, "completed units restored from status file");
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });

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

@@ -92,9 +92,11 @@ test('handlePlanMilestone writes milestone and slice planning state and renders
     assert.ok(existsSync(roadmapPath), 'roadmap should be rendered to disk');
     const roadmap = readFileSync(roadmapPath, 'utf-8');
     assert.match(roadmap, /# M001: DB-backed planning/);
-    assert.match(roadmap, /\*\*Vision:\*\* Make planning write through the database\./);
-    assert.match(roadmap, /- \[ \] \*\*S01: Tool wiring\*\* `risk:medium` `depends:\[\]`/);
-    assert.match(roadmap, /- \[ \] \*\*S02: Prompt migration\*\* `risk:low` `depends:\[S01\]`/);
+    assert.match(roadmap, /## Vision/);
+    assert.match(roadmap, /Make planning write through the database\./);
+    assert.match(roadmap, /## Slice Overview/);
+    assert.match(roadmap, /\| S01 \| Tool wiring \| medium \|/);
+    assert.match(roadmap, /\| S02 \| Prompt migration \| low \| S01 \|/);
   } finally {
     cleanup(base);
   }
@@ -152,9 +154,10 @@ test('handlePlanMilestone clears parse-visible roadmap state after successful re
     const result = await handlePlanMilestone(validParams(), base);
     assert.ok(!('error' in result));
 
-    const parsedAfter = parseRoadmap(readFileSync(roadmapPath, 'utf-8'));
-    assert.equal(parsedAfter.vision, 'Make planning write through the database.');
-    assert.equal(parsedAfter.slices.length, 2);
+    const contentAfter = readFileSync(roadmapPath, 'utf-8');
+    assert.match(contentAfter, /Make planning write through the database\./);
+    assert.match(contentAfter, /S01/);
+    assert.match(contentAfter, /S02/);
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/post-mutation-hook.test.ts

@@ -0,0 +1,171 @@
+// GSD Extension — post-mutation hook regression tests
+// Verifies that after a successful handleCompleteTask call, the post-mutation
+// hook fires: event-log.jsonl and state-manifest.json are both written.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { openDatabase, closeDatabase } from '../gsd-db.ts';
+import { handleCompleteTask } from '../tools/complete-task.ts';
+import { readEvents } from '../workflow-events.ts';
+import { readManifest } from '../workflow-manifest.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-post-hook-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+/** Create a minimal project directory with a PLAN.md for complete-task to find. */
+function createProject(basePath: string): void {
+  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const tasksDir = path.join(sliceDir, 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+  fs.writeFileSync(path.join(sliceDir, 'S01-PLAN.md'), `# S01: Test Slice
+
+## Tasks
+
+- [ ] **T01: Test task** \`est:30m\`
+  - Do: Implement the thing
+  - Verify: Run tests
+
+- [ ] **T02: Second task** \`est:1h\`
+  - Do: Implement more
+  - Verify: Run more tests
+`);
+}
+
+function makeCompleteTaskParams() {
+  return {
+    taskId: 'T01',
+    sliceId: 'S01',
+    milestoneId: 'M001',
+    oneLiner: 'Implemented auth middleware',
+    narrative: 'Added JWT validation middleware with proper error handling.',
+    verification: 'Ran npm test — all tests pass.',
+    deviations: 'None.',
+    knownIssues: 'None.',
+    keyFiles: ['src/middleware/auth.ts'],
+    keyDecisions: [],
+    blockerDiscovered: false,
+    verificationEvidence: [
+      { command: 'npm test', exitCode: 0, verdict: '✅ pass', durationMs: 2500 },
+    ],
+  };
+}
+
+// ─── Post-mutation hook: event log ───────────────────────────────────────
+
+test('post-mutation-hook: event-log.jsonl exists after handleCompleteTask', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    const result = await handleCompleteTask(makeCompleteTaskParams(), base);
+    assert.ok(!('error' in result), `handler should succeed, got: ${JSON.stringify(result)}`);
+
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    assert.ok(fs.existsSync(logPath), 'event-log.jsonl should exist after handler completes');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('post-mutation-hook: event log contains complete-task event with correct params', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    await handleCompleteTask(makeCompleteTaskParams(), base);
+
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    const events = readEvents(logPath);
+    assert.ok(events.length > 0, 'event log should have at least one event');
+
+    const ev = events.find((e) => e.cmd === 'complete-task');
+    assert.ok(ev !== undefined, 'should have a complete-task event');
+    assert.strictEqual((ev!.params as { milestoneId?: string }).milestoneId, 'M001');
+    assert.strictEqual((ev!.params as { sliceId?: string }).sliceId, 'S01');
+    assert.strictEqual((ev!.params as { taskId?: string }).taskId, 'T01');
+    assert.strictEqual(ev!.actor, 'agent');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── Post-mutation hook: manifest ────────────────────────────────────────
+
+test('post-mutation-hook: state-manifest.json exists after handleCompleteTask', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    const result = await handleCompleteTask(makeCompleteTaskParams(), base);
+    assert.ok(!('error' in result), `handler should succeed, got: ${JSON.stringify(result)}`);
+
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist after handler completes');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('post-mutation-hook: manifest has version 1 and includes completed task', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    await handleCompleteTask(makeCompleteTaskParams(), base);
+
+    const manifest = readManifest(base);
+    assert.ok(manifest !== null, 'manifest should be readable');
+    assert.strictEqual(manifest!.version, 1);
+
+    const task = manifest!.tasks.find((t) => t.id === 'T01');
+    assert.ok(task !== undefined, 'T01 should appear in manifest');
+    assert.strictEqual(task!.status, 'complete');
+    assert.strictEqual(task!.milestone_id, 'M001');
+    assert.strictEqual(task!.slice_id, 'S01');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── Post-mutation hook: non-fatal on hook failure ───────────────────────
+
+test('post-mutation-hook: handler still returns success even if projections dir is missing', async () => {
+  // basePath with NO .gsd directory — projections will fail to find milestones
+  // but handler should still return a result (not throw)
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+
+  // Create tasks dir but NO plan file (projections will soft-fail)
+  const tasksDir = path.join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+
+  try {
+    const result = await handleCompleteTask(makeCompleteTaskParams(), base);
+    // Handler should succeed (post-hook failures are non-fatal)
+    assert.ok(!('error' in result), `handler should not propagate hook errors, got: ${JSON.stringify(result)}`);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -41,18 +41,16 @@ test("git.merge_to_main produces deprecation warning", () => {
 });
 
 
-test("getIsolationMode defaults to worktree when preferences have no isolation setting", () => {
+test("getIsolationMode defaults to none when preferences have no isolation setting", () => {
   // Validate the default via validatePreferences: when no isolation is set,
-  // preferences.git.isolation is undefined, and getIsolationMode returns "worktree".
-  // We test the function's logic by verifying its documented default.
+  // preferences.git.isolation is undefined, and getIsolationMode returns "none".
+  // Default changed from "worktree" to "none" so GSD works out of the box
+  // without preferences.md (#2480).
   const { preferences } = validatePreferences({});
   assert.equal(preferences.git?.isolation, undefined, "no isolation in empty prefs");
-  // The function returns "worktree" when prefs?.git?.isolation is not "none" or "branch"
-  // This is a compile-time-verifiable truth from the function body — test it directly
-  // by constructing the same conditions getIsolationMode checks.
   const isolation = preferences.git?.isolation;
-  const expected = isolation === "none" ? "none" : isolation === "branch" ? "branch" : "worktree";
-  assert.equal(expected, "worktree", "default isolation mode is worktree");
+  const expected = isolation === "worktree" ? "worktree" : isolation === "branch" ? "branch" : "none";
+  assert.equal(expected, "none", "default isolation mode is none");
 });
 
 // ── Mode defaults ────────────────────────────────────────────────────────────
@@ -63,7 +61,7 @@ test("solo mode applies correct defaults", () => {
   assert.equal(result.git?.push_branches, false);
   assert.equal(result.git?.pre_merge_check, false);
   assert.equal(result.git?.merge_strategy, "squash");
-  assert.equal(result.git?.isolation, "worktree");
+  assert.equal(result.git?.isolation, "none");
   assert.equal(result.unique_milestone_ids, false);
 });
 

package/src/resources/extensions/gsd/tests/projection-regression.test.ts

@@ -0,0 +1,174 @@
+// GSD — projection renderer regression tests
+// Verifies that "done" vs "complete" status mismatch doesn't recur.
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { renderPlanContent, renderRoadmapContent } from '../workflow-projections.ts';
+import type { SliceRow, TaskRow } from '../gsd-db.ts';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+function makeSliceRow(overrides?: Partial<SliceRow>): SliceRow {
+  return {
+    milestone_id: 'M001',
+    id: 'S01',
+    title: 'Test Slice',
+    status: 'pending',
+    risk: 'medium',
+    depends: [],
+    demo: 'Demo.',
+    created_at: '2026-01-01T00:00:00Z',
+    completed_at: null,
+    full_summary_md: '',
+    full_uat_md: '',
+    goal: 'Test goal',
+    success_criteria: '',
+    proof_level: '',
+    integration_closure: '',
+    observability_impact: '',
+    sequence: 0,
+    replan_triggered_at: null,
+    ...overrides,
+  };
+}
+
+function makeTaskRow(overrides?: Partial<TaskRow>): TaskRow {
+  return {
+    milestone_id: 'M001',
+    slice_id: 'S01',
+    id: 'T01',
+    title: 'Test Task',
+    status: 'pending',
+    one_liner: '',
+    narrative: '',
+    verification_result: '',
+    duration: '',
+    completed_at: null,
+    blocker_discovered: false,
+    deviations: '',
+    known_issues: '',
+    key_files: [],
+    key_decisions: [],
+    full_summary_md: '',
+    full_plan_md: '',
+    description: 'Test description',
+    estimate: '30m',
+    files: ['src/test.ts'],
+    verify: 'npm test',
+    inputs: [],
+    expected_output: [],
+    observability_impact: '',
+    sequence: 0,
+    ...overrides,
+  };
+}
+
+function makeMilestoneRow() {
+  return {
+    id: 'M001',
+    title: 'Test Milestone',
+    status: 'active',
+    depends_on: [],
+    created_at: '2026-01-01T00:00:00Z',
+    completed_at: null,
+    vision: 'Test vision',
+    success_criteria: [],
+    key_risks: [],
+    proof_strategy: [],
+    verification_contract: '',
+    verification_integration: '',
+    verification_operational: '',
+    verification_uat: '',
+    definition_of_done: [],
+    requirement_coverage: '',
+    boundary_map_markdown: '',
+  };
+}
+
+// ─── renderPlanContent: checkbox regression ──────────────────────────────
+
+test('renderPlanContent: task with status "complete" renders [x] checkbox', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'complete', title: 'Completed Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[x\]\s+\*\*T01:/, 'complete task should have [x] checkbox');
+});
+
+test('renderPlanContent: task with status "done" renders [x] checkbox', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'done', title: 'Done Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[x\]\s+\*\*T01:/, 'done task should have [x] checkbox');
+});
+
+test('renderPlanContent: task with status "pending" renders [ ] checkbox', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'pending', title: 'Pending Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[ \]\s+\*\*T01:/, 'pending task should have [ ] checkbox');
+});
+
+test('renderPlanContent: mixed statuses render correct checkboxes', () => {
+  const slice = makeSliceRow();
+  const tasks = [
+    makeTaskRow({ id: 'T01', status: 'complete', title: 'Done One' }),
+    makeTaskRow({ id: 'T02', status: 'pending', title: 'Pending One' }),
+    makeTaskRow({ id: 'T03', status: 'done', title: 'Done Two' }),
+  ];
+
+  const content = renderPlanContent(slice, tasks);
+
+  assert.match(content, /\[x\]\s+\*\*T01:/, 'T01 (complete) should be checked');
+  assert.match(content, /\[ \]\s+\*\*T02:/, 'T02 (pending) should be unchecked');
+  assert.match(content, /\[x\]\s+\*\*T03:/, 'T03 (done) should be checked');
+});
+
+// ─── renderPlanContent: format regression (parsePlan compatibility) ──────
+
+test('renderPlanContent: format matches parsePlan regex **ID: title**', () => {
+  const slice = makeSliceRow();
+  const tasks = [makeTaskRow({ id: 'T01', status: 'pending', title: 'My Task' })];
+
+  const content = renderPlanContent(slice, tasks);
+
+  // parsePlan expects: **T01: My Task** (both ID and title inside bold)
+  // NOT: **T01:** My Task (only ID in bold)
+  assert.match(content, /\*\*T01: My Task\*\*/, 'ID and title should both be inside bold markers');
+});
+
+// ─── renderRoadmapContent: status regression ─────────────────────────────
+
+test('renderRoadmapContent: slice with status "complete" shows ✅', () => {
+  const milestone = makeMilestoneRow();
+  const slices = [makeSliceRow({ id: 'S01', status: 'complete' })];
+
+  const content = renderRoadmapContent(milestone, slices);
+
+  assert.ok(content.includes('✅'), 'complete slice should show ✅');
+});
+
+test('renderRoadmapContent: slice with status "done" shows ✅', () => {
+  const milestone = makeMilestoneRow();
+  const slices = [makeSliceRow({ id: 'S01', status: 'done' })];
+
+  const content = renderRoadmapContent(milestone, slices);
+
+  assert.ok(content.includes('✅'), 'done slice should show ✅');
+});
+
+test('renderRoadmapContent: slice with status "pending" shows ⬜', () => {
+  const milestone = makeMilestoneRow();
+  const slices = [makeSliceRow({ id: 'S01', status: 'pending' })];
+
+  const content = renderRoadmapContent(milestone, slices);
+
+  assert.ok(content.includes('⬜'), 'pending slice should show ⬜');
+});

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

@@ -58,17 +58,18 @@ test("guided-resume-task prompt preserves recovery state until work is supersede
   assert.doesNotMatch(prompt, /Delete the continue file after reading it/i);
 });
 
-// ─── Prompt migration: execute-task → gsd_task_complete ───────────────
+// ─── Prompt migration: execute-task → gsd_complete_task ───────────────
 
-test("execute-task prompt references gsd_task_complete tool", () => {
+test("execute-task prompt references gsd_complete_task tool", () => {
   const prompt = readPrompt("execute-task");
-  assert.match(prompt, /gsd_task_complete/);
+  assert.match(prompt, /gsd_complete_task/);
 });
 
-test("execute-task prompt does not instruct LLM to write summary file manually", () => {
+test("execute-task prompt instructs writing task summary before tool call", () => {
   const prompt = readPrompt("execute-task");
-  // Should not contain "Write {{taskSummaryPath}}" as an action instruction
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{taskSummaryPath\}\}`?/m);
+  // The prompt instructs writing the summary file AND calling the tool
+  assert.match(prompt, /\{\{taskSummaryPath\}\}/);
+  assert.match(prompt, /gsd_complete_task/);
 });
 
 test("execute-task prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -93,12 +94,11 @@ test("guided-execute-task prompt does not instruct manual file write", () => {
   assert.doesNotMatch(prompt, /Write `?\{\{taskId\}\}-SUMMARY\.md`?.*mark it done/i);
 });
 
-// ─── Prompt migration: complete-slice → gsd_slice_complete ────────────
-// These tests are for T02 — expected to fail until that task runs.
+// ─── Prompt migration: complete-slice → gsd_complete_slice ────────────
 
-test("complete-slice prompt references gsd_slice_complete tool", () => {
+test("complete-slice prompt references gsd_complete_slice tool", () => {
   const prompt = readPrompt("complete-slice");
-  assert.match(prompt, /gsd_slice_complete/);
+  assert.match(prompt, /gsd_complete_slice/);
 });
 
 test("complete-slice prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -111,10 +111,12 @@ test("guided-complete-slice prompt references gsd_slice_complete tool", () => {
   assert.match(prompt, /gsd_slice_complete/);
 });
 
-test("complete-slice prompt does not instruct LLM to write summary/UAT files manually", () => {
+test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceSummaryPath\}\}/m);
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceUatPath\}\}/m);
+  // The prompt instructs writing the summary AND UAT files, then calling the tool
+  assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
+  assert.match(prompt, /\{\{sliceUatPath\}\}/);
+  assert.match(prompt, /gsd_complete_slice/);
 });
 
 test("complete-slice prompt preserves decisions and knowledge review steps", () => {
@@ -127,7 +129,6 @@ test("complete-slice prompt still contains template variables for context", () =
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
   assert.match(prompt, /\{\{sliceUatPath\}\}/);
-  assert.match(prompt, /\{\{roadmapPath\}\}/);
 });
 
 test("plan-milestone prompt references DB-backed planning tool and explicitly forbids manual roadmap writes", () => {
@@ -147,12 +148,12 @@ test("plan-slice prompt no longer frames direct PLAN writes as the source of tru
   assert.match(prompt, /Do \*\*not\*\* rely on direct `PLAN\.md` writes as the source of truth/i);
 });
 
-test("plan-slice prompt explicitly names gsd_plan_slice and gsd_plan_task as DB-backed planning tools", () => {
+test("plan-slice prompt explicitly names gsd_plan_slice as DB-backed planning tool", () => {
   const prompt = readPrompt("plan-slice");
   assert.match(prompt, /gsd_plan_slice/);
   assert.match(prompt, /gsd_plan_task/);
-  // The prompt should describe these as the canonical write path
-  assert.match(prompt, /DB-backed tools are the canonical write path/i);
+  // The prompt should describe the DB-backed tool as the canonical write path
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
 });
 
 test("plan-slice prompt does not instruct direct file writes as a primary step", () => {
@@ -161,14 +162,18 @@ test("plan-slice prompt does not instruct direct file writes as a primary step",
   assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{outputPath\}\}`?\s*$/m);
 });
 
-test("plan-slice prompt instructs calling gsd_plan_task for each task", () => {
+test("plan-slice prompt clarifies gsd_plan_slice handles task persistence", () => {
   const prompt = readPrompt("plan-slice");
-  assert.match(prompt, /call `gsd_plan_task` for each task/i);
+  // gsd_plan_slice persists tasks in its transaction — no separate gsd_plan_task calls needed
+  assert.match(prompt, /gsd_plan_task/);
+  assert.match(prompt, /gsd_plan_slice` handles task persistence/i);
 });
 
-test("replan-slice prompt requires DB-backed planning state when available", () => {
+test("replan-slice prompt uses gsd_replan_slice as canonical DB-backed tool", () => {
   const prompt = readPrompt("replan-slice");
-  assert.match(prompt, /DB-backed planning tool exists for this phase, use it as the source of truth/i);
+  assert.match(prompt, /gsd_replan_slice/);
+  // Degraded fallback (direct file writes) was removed — DB tools are always available
+  assert.doesNotMatch(prompt, /Degraded fallback/i);
 });
 
 test("reassess-roadmap prompt references gsd_reassess_roadmap tool", () => {