gsd-pi 2.44.0 → 2.45.0-dev.6b9da3e

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

@@ -1,13 +1,11 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 
 import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
 /** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
 function tmp(): string {
   const p = mkdtempSync(join(tmpdir(), "gsd-paths-test-"));
@@ -23,91 +21,78 @@ function initGit(dir: string): void {
   spawnSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
 }
 
-// ── tests ──────────────────────────────────────────────────────────────────
-
-{
-  // Case 1: .gsd exists at basePath — fast path
-  const root = tmp();
-  try {
-    mkdirSync(join(root, ".gsd"));
-    _clearGsdRootCache();
-    const result = gsdRoot(root);
-    assertEq(result, join(root, ".gsd"), "fast path: returns basePath/.gsd");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 2: .gsd exists at git root, cwd is a subdirectory
-  const root = tmp();
-  try {
-    initGit(root);
-    mkdirSync(join(root, ".gsd"));
-    const sub = join(root, "src", "deep");
-    mkdirSync(sub, { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(sub);
-    assertEq(result, join(root, ".gsd"), "git-root probe: finds .gsd at git root from subdirectory");
-  } finally { cleanup(root); }
-}
+describe('paths', () => {
+  test('Case 1: .gsd exists at basePath — fast path', () => {
+    const root = tmp();
+    try {
+      mkdirSync(join(root, ".gsd"));
+      _clearGsdRootCache();
+      const result = gsdRoot(root);
+      assert.deepStrictEqual(result, join(root, ".gsd"), "fast path: returns basePath/.gsd");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 3: .gsd in an ancestor — walk-up finds it (git repo with no .gsd at root)
-  const root = tmp();
-  try {
-    // Init a git repo so git probe returns root — but put .gsd one level deeper
-    // to force the walk-up path: root/project/.gsd, cwd = root/project/src/deep
-    initGit(root);
-    const project = join(root, "project");
-    mkdirSync(join(project, ".gsd"), { recursive: true });
-    const deep = join(project, "src", "deep");
-    mkdirSync(deep, { recursive: true });
-    _clearGsdRootCache();
-    // git probe returns root (no .gsd there), so walk-up takes over and finds project/.gsd
-    const result = gsdRoot(deep);
-    assertEq(result, join(project, ".gsd"), "walk-up: finds .gsd in ancestor when git root has none");
-  } finally { cleanup(root); }
-}
+  test('Case 2: .gsd exists at git root, cwd is a subdirectory', () => {
+    const root = tmp();
+    try {
+      initGit(root);
+      mkdirSync(join(root, ".gsd"));
+      const sub = join(root, "src", "deep");
+      mkdirSync(sub, { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(sub);
+      assert.deepStrictEqual(result, join(root, ".gsd"), "git-root probe: finds .gsd at git root from subdirectory");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 4: .gsd nowhere — fallback returns original basePath/.gsd
-  // Use an isolated git repo so we fully control the environment above basePath
-  const root = tmp();
-  try {
-    initGit(root);                          // git root = root, no .gsd anywhere
-    const sub = join(root, "src");
-    mkdirSync(sub, { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(sub);
-    // git probe finds root (no .gsd), walk-up finds nothing → fallback = sub/.gsd
-    assertEq(result, join(sub, ".gsd"), "fallback: returns basePath/.gsd when .gsd not found anywhere");
-  } finally { cleanup(root); }
-}
+  test('Case 3: .gsd in an ancestor — walk-up finds it', () => {
+    const root = tmp();
+    try {
+      initGit(root);
+      const project = join(root, "project");
+      mkdirSync(join(project, ".gsd"), { recursive: true });
+      const deep = join(project, "src", "deep");
+      mkdirSync(deep, { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(deep);
+      assert.deepStrictEqual(result, join(project, ".gsd"), "walk-up: finds .gsd in ancestor when git root has none");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 5: cache — second call returns same value without re-probing
-  const root = tmp();
-  try {
-    mkdirSync(join(root, ".gsd"));
-    _clearGsdRootCache();
-    const first = gsdRoot(root);
-    const second = gsdRoot(root);
-    assertEq(first, second, "cache: same result returned on second call");
-    assertTrue(first === second, "cache: identity check (same string)");
-  } finally { cleanup(root); }
-}
+  test('Case 4: .gsd nowhere — fallback returns original basePath/.gsd', () => {
+    const root = tmp();
+    try {
+      initGit(root);
+      const sub = join(root, "src");
+      mkdirSync(sub, { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(sub);
+      assert.deepStrictEqual(result, join(sub, ".gsd"), "fallback: returns basePath/.gsd when .gsd not found anywhere");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 6: .gsd at basePath takes precedence over ancestor .gsd
-  const outer = tmp();
-  try {
-    initGit(outer);
-    mkdirSync(join(outer, ".gsd"));
-    const inner = join(outer, "nested");
-    mkdirSync(join(inner, ".gsd"), { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(inner);
-    assertEq(result, join(inner, ".gsd"), "precedence: nearest .gsd wins over ancestor");
-  } finally { cleanup(outer); }
-}
+  test('Case 5: cache — second call returns same value without re-probing', () => {
+    const root = tmp();
+    try {
+      mkdirSync(join(root, ".gsd"));
+      _clearGsdRootCache();
+      const first = gsdRoot(root);
+      const second = gsdRoot(root);
+      assert.deepStrictEqual(first, second, "cache: same result returned on second call");
+      assert.ok(first === second, "cache: identity check (same string)");
+    } finally { cleanup(root); }
+  });
 
-report();
+  test('Case 6: .gsd at basePath takes precedence over ancestor .gsd', () => {
+    const outer = tmp();
+    try {
+      initGit(outer);
+      mkdirSync(join(outer, ".gsd"));
+      const inner = join(outer, "nested");
+      mkdirSync(join(inner, ".gsd"), { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(inner);
+      assert.deepStrictEqual(result, join(inner, ".gsd"), "precedence: nearest .gsd wins over ancestor");
+    } finally { cleanup(outer); }
+  });
+});

package/src/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -1,9 +1,10 @@
 // GSD Extension — Hook Engine Tests (Post-Unit, Pre-Dispatch, State Persistence)
 
+import { describe, test } from 'node:test';
+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 { createTestContext } from "./test-helpers.ts";
 import {
   checkPostUnitHooks,
   getActiveHook,
@@ -20,8 +21,6 @@ import {
   triggerHookManually,
 } from "../post-unit-hooks.ts";
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
-
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -36,14 +35,14 @@ function createFixtureBase(): string {
 
 // ─── resolveHookArtifactPath ───────────────────────────────────────────────
 
-console.log("\n=== resolveHookArtifactPath ===");
 
-{
+describe('post-unit-hooks', () => {
+test('resolveHookArtifactPath', () => {
   const base = "/project";
 
   // Task-level
   const taskPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-PASS.md");
-  assertEq(
+  assert.deepStrictEqual(
     taskPath,
     join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-REVIEW-PASS.md"),
     "task-level artifact path",
@@ -51,7 +50,7 @@ console.log("\n=== resolveHookArtifactPath ===");
 
   // Slice-level
   const slicePath = resolveHookArtifactPath(base, "M001/S01", "REVIEW-PASS.md");
-  assertEq(
+  assert.deepStrictEqual(
     slicePath,
     join(base, ".gsd", "milestones", "M001", "slices", "S01", "REVIEW-PASS.md"),
     "slice-level artifact path",
@@ -59,129 +58,106 @@ console.log("\n=== resolveHookArtifactPath ===");
 
   // Milestone-level
   const milestonePath = resolveHookArtifactPath(base, "M001", "REVIEW-PASS.md");
-  assertEq(
+  assert.deepStrictEqual(
     milestonePath,
     join(base, ".gsd", "milestones", "M001", "REVIEW-PASS.md"),
     "milestone-level artifact path",
   );
-}
+});
 
 // ─── resetHookState ────────────────────────────────────────────────────────
-
-console.log("\n=== resetHookState ===");
-
-{
+test('resetHookState', () => {
   resetHookState();
-  assertEq(getActiveHook(), null, "no active hook after reset");
-  assertTrue(!isRetryPending(), "no retry pending after reset");
-  assertEq(consumeRetryTrigger(), null, "no retry trigger after reset");
-}
+  assert.deepStrictEqual(getActiveHook(), null, "no active hook after reset");
+  assert.ok(!isRetryPending(), "no retry pending after reset");
+  assert.deepStrictEqual(consumeRetryTrigger(), null, "no retry trigger after reset");
+});
 
 // ─── checkPostUnitHooks with no hooks configured ───────────────────────────
-
-console.log("\n=== No hooks configured ===");
-
-{
+test('No hooks configured', () => {
   resetHookState();
   const base = createFixtureBase();
   try {
     const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
-    assertEq(result, null, "returns null when no hooks configured");
+    assert.deepStrictEqual(result, null, "returns null when no hooks configured");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
 // ─── Hook units don't trigger hooks (no hook-on-hook) ──────────────────────
-
-console.log("\n=== Hook-on-hook prevention ===");
-
-{
+test('Hook-on-hook prevention', () => {
   resetHookState();
   const base = createFixtureBase();
   try {
     const result = checkPostUnitHooks("hook/code-review", "M001/S01/T01", base);
-    assertEq(result, null, "hook units don't trigger other hooks");
+    assert.deepStrictEqual(result, null, "hook units don't trigger other hooks");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
 // ─── consumeRetryTrigger clears state ──────────────────────────────────────
-
-console.log("\n=== consumeRetryTrigger clears state ===");
-
-{
+test('consumeRetryTrigger clears state', () => {
   resetHookState();
-  assertEq(consumeRetryTrigger(), null, "no trigger initially");
-  assertTrue(!isRetryPending(), "no retry initially");
-}
+  assert.deepStrictEqual(consumeRetryTrigger(), null, "no trigger initially");
+  assert.ok(!isRetryPending(), "no retry initially");
+});
 
 // ─── Variable substitution in prompts ──────────────────────────────────────
-
-console.log("\n=== Variable substitution ===");
-
-{
+test('Variable substitution', () => {
   const base = "/project";
 
   // 3-part ID
   const path3 = resolveHookArtifactPath(base, "M002/S03/T05", "result.md");
-  assertTrue(path3.includes("M002"), "3-part ID extracts milestoneId");
-  assertTrue(path3.includes("S03"), "3-part ID extracts sliceId");
-  assertTrue(path3.includes("T05"), "3-part ID extracts taskId");
-  assertTrue(path3.includes("milestones"), "3-part ID includes milestones/ segment");
+  assert.ok(path3.includes("M002"), "3-part ID extracts milestoneId");
+  assert.ok(path3.includes("S03"), "3-part ID extracts sliceId");
+  assert.ok(path3.includes("T05"), "3-part ID extracts taskId");
+  assert.ok(path3.includes("milestones"), "3-part ID includes milestones/ segment");
 
   // 2-part ID
   const path2 = resolveHookArtifactPath(base, "M002/S03", "result.md");
-  assertTrue(path2.includes("M002"), "2-part ID extracts milestoneId");
-  assertTrue(path2.includes("S03"), "2-part ID extracts sliceId");
-  assertTrue(path2.includes("milestones"), "2-part ID includes milestones/ segment");
+  assert.ok(path2.includes("M002"), "2-part ID extracts milestoneId");
+  assert.ok(path2.includes("S03"), "2-part ID extracts sliceId");
+  assert.ok(path2.includes("milestones"), "2-part ID includes milestones/ segment");
 
   // 1-part ID
   const path1 = resolveHookArtifactPath(base, "M002", "result.md");
-  assertTrue(path1.includes("M002"), "1-part ID extracts milestoneId");
-  assertTrue(path1.includes("milestones"), "1-part ID includes milestones/ segment");
-}
+  assert.ok(path1.includes("M002"), "1-part ID extracts milestoneId");
+  assert.ok(path1.includes("milestones"), "1-part ID includes milestones/ segment");
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 2: Pre-Dispatch Hook Tests
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Pre-dispatch: no hooks configured ===");
-
-{
+test('Pre-dispatch: no hooks configured', () => {
   const base = createFixtureBase();
   try {
     const result = runPreDispatchHooks("execute-task", "M001/S01/T01", "original prompt", base);
-    assertEq(result.action, "proceed", "proceeds when no hooks");
-    assertEq(result.prompt, "original prompt", "prompt unchanged");
-    assertEq(result.firedHooks.length, 0, "no hooks fired");
+    assert.deepStrictEqual(result.action, "proceed", "proceeds when no hooks");
+    assert.deepStrictEqual(result.prompt, "original prompt", "prompt unchanged");
+    assert.deepStrictEqual(result.firedHooks.length, 0, "no hooks fired");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
-
-console.log("\n=== Pre-dispatch: hook units bypass ===");
+});
 
-{
+test('Pre-dispatch: hook units bypass', () => {
   const base = createFixtureBase();
   try {
     const result = runPreDispatchHooks("hook/review", "M001/S01/T01", "hook prompt", base);
-    assertEq(result.action, "proceed", "hook units always proceed");
-    assertEq(result.prompt, "hook prompt", "hook prompt unchanged");
-    assertEq(result.firedHooks.length, 0, "no hooks fired for hook units");
+    assert.deepStrictEqual(result.action, "proceed", "hook units always proceed");
+    assert.deepStrictEqual(result.prompt, "hook prompt", "hook prompt unchanged");
+    assert.deepStrictEqual(result.firedHooks.length, 0, "no hooks fired for hook units");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 3: State Persistence Tests
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== State persistence: persist and restore ===");
-
-{
+test('State persistence: persist and restore', () => {
   const base = createFixtureBase();
   try {
     resetHookState();
@@ -189,19 +165,17 @@ console.log("\n=== State persistence: persist and restore ===");
     // Persist empty state
     persistHookState(base);
     const filePath = join(base, ".gsd", "hook-state.json");
-    assertTrue(existsSync(filePath), "hook-state.json created");
+    assert.ok(existsSync(filePath), "hook-state.json created");
 
     const content = JSON.parse(readFileSync(filePath, "utf-8"));
-    assertEq(typeof content.savedAt, "string", "savedAt is a string");
-    assertEq(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
+    assert.deepStrictEqual(typeof content.savedAt, "string", "savedAt is a string");
+    assert.deepStrictEqual(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
-
-console.log("\n=== State persistence: restore from disk ===");
+});
 
-{
+test('State persistence: restore from disk', () => {
   const base = createFixtureBase();
   try {
     resetHookState();
@@ -222,16 +196,14 @@ console.log("\n=== State persistence: restore from disk ===");
     // Verify by persisting and reading back
     persistHookState(base);
     const restored = JSON.parse(readFileSync(stateFile, "utf-8"));
-    assertEq(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
-    assertEq(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
+    assert.deepStrictEqual(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
+    assert.deepStrictEqual(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
-
-console.log("\n=== State persistence: clear ===");
+});
 
-{
+test('State persistence: clear', () => {
   const base = createFixtureBase();
   try {
     resetHookState();
@@ -246,77 +218,65 @@ console.log("\n=== State persistence: clear ===");
     clearPersistedHookState(base);
 
     const cleared = JSON.parse(readFileSync(stateFile, "utf-8"));
-    assertEq(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
+    assert.deepStrictEqual(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
-console.log("\n=== State persistence: restore handles missing file ===");
-
-{
+test('State persistence: restore handles missing file', () => {
   const base = createFixtureBase();
   try {
     resetHookState();
     // Should not throw
     restoreHookState(base);
-    assertEq(getActiveHook(), null, "no active hook after restore from missing file");
+    assert.deepStrictEqual(getActiveHook(), null, "no active hook after restore from missing file");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
-console.log("\n=== State persistence: restore handles corrupt file ===");
-
-{
+test('State persistence: restore handles corrupt file', () => {
   const base = createFixtureBase();
   try {
     resetHookState();
     writeFileSync(join(base, ".gsd", "hook-state.json"), "not json", "utf-8");
     // Should not throw
     restoreHookState(base);
-    assertEq(getActiveHook(), null, "no active hook after corrupt restore");
+    assert.deepStrictEqual(getActiveHook(), null, "no active hook after corrupt restore");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 3: Hook Status Reporting Tests
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Hook status: no hooks ===");
-
-{
+test('Hook status: no hooks', () => {
   resetHookState();
   const entries = getHookStatus();
   // No preferences file = no hooks
-  assertEq(entries.length, 0, "no entries when no hooks configured");
+  assert.deepStrictEqual(entries.length, 0, "no entries when no hooks configured");
 
   const formatted = formatHookStatus();
-  assertMatch(formatted, /No hooks configured/, "status message says no hooks");
-}
+  assert.match(formatted, /No hooks configured/, "status message says no hooks");
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 4: Manual Hook Trigger Tests
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== triggerHookManually: hook not found ===");
-
-{
+test('triggerHookManually: hook not found', () => {
   resetHookState();
   const base = createFixtureBase();
   try {
     const result = triggerHookManually("nonexistent-hook", "execute-task", "M001/S01/T01", base);
-    assertEq(result, null, "returns null when hook not found");
+    assert.deepStrictEqual(result, null, "returns null when hook not found");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
-console.log("\n=== triggerHookManually: with configured hook ===");
-
-{
+test('triggerHookManually: with configured hook', () => {
   resetHookState();
   const base = createFixtureBase();
   try {
@@ -325,16 +285,16 @@ console.log("\n=== triggerHookManually: with configured hook ===");
     const result = triggerHookManually("code-review", "execute-task", "M001/S01/T01", base);
     // Result depends on whether code-review hook is configured in preferences
     // The function should either return null or a valid HookDispatchResult
-    assertTrue(result === null || typeof result === "object", "returns null or object");
+    assert.ok(result === null || typeof result === "object", "returns null or object");
     if (result) {
-      assertEq(result.hookName, "code-review", "hook name in result");
-      assertEq(result.unitType, "hook/code-review", "unit type is hook-prefixed");
-      assertEq(result.unitId, "M001/S01/T01", "unit ID preserved");
-      assertTrue(typeof result.prompt === "string", "prompt is a string");
+      assert.deepStrictEqual(result.hookName, "code-review", "hook name in result");
+      assert.deepStrictEqual(result.unitType, "hook/code-review", "unit type is hook-prefixed");
+      assert.deepStrictEqual(result.unitId, "M001/S01/T01", "unit ID preserved");
+      assert.ok(typeof result.prompt === "string", "prompt is a string");
     }
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-}
+});
 
-report();
+});

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

@@ -15,6 +15,7 @@ import {
   applyModeDefaults,
   getIsolationMode,
   parsePreferencesMarkdown,
+  _resetParseWarningFlag,
 } from "../preferences.ts";
 import type { GSDPreferences, GSDModelConfigV2, GSDPhaseModelConfig } from "../preferences.ts";
 
@@ -352,3 +353,29 @@ test("handles empty models config", () => {
   assert.notEqual(prefs, null);
   assert.equal(prefs!.models, undefined);
 });
+
+// ── Warn-once for unrecognized format (#2373) ────────────────────────────────
+
+test("unrecognized format warning is emitted at most once (#2373)", () => {
+  const warnings: string[] = [];
+  const origWarn = console.warn;
+  console.warn = (...args: unknown[]) => warnings.push(args.join(" "));
+  try {
+    // Reset internal warned flag so the test starts clean
+    _resetParseWarningFlag();
+
+    const unrecognized = "This is just plain text with no frontmatter or headings.";
+
+    // Call multiple times — simulates repeated preference loads
+    parsePreferencesMarkdown(unrecognized);
+    parsePreferencesMarkdown(unrecognized);
+    parsePreferencesMarkdown(unrecognized);
+
+    const relevant = warnings.filter(w => w.includes("unrecognized format"));
+    assert.equal(relevant.length, 1, `expected exactly 1 warning, got ${relevant.length}: ${JSON.stringify(relevant)}`);
+  } finally {
+    console.warn = origWarn;
+    // Reset so other tests aren't affected by the flag state
+    _resetParseWarningFlag();
+  }
+});

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

@@ -147,12 +147,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 +161,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", () => {