@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

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

@@ -0,0 +1,173 @@
+// GSD Extension — Guidance module tests
+// The catalog is the test surface: every typed finding must resolve to
+// non-empty remediation, and load-bearing phrases must survive edits.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatGuidance,
+  recoveryRemediation,
+  needsAttentionBlockerGuidance,
+  needsRemediationBlockerGuidance,
+  uatSignoffBlockerGuidance,
+  worktreeCreationFailedGuidance,
+  crashResumeHint,
+  doctorFixHint,
+  type RecoveryGuidanceKey,
+} from "../guidance.js";
+import { classifyFailure, type RecoveryFailureKind } from "../recovery-classification.js";
+import { isValidationBlockedState } from "../validation-block-guard.js";
+import type { GSDState } from "../types.js";
+
+const RECOVERY_KEYS: RecoveryGuidanceKey[] = [
+  "tool-schema",
+  "tool-contract",
+  "tool-unavailable",
+  "deterministic-policy",
+  "lifecycle-progression",
+  "stale-worker",
+  "worktree-invalid",
+  "verification-drift",
+  "reconciliation-drift",
+  "illegal-transition",
+  "runtime-unknown",
+  "provider-transient",
+  "provider-permanent",
+];
+
+describe("guidance catalog", () => {
+  test("every recovery guidance key resolves to non-empty remediation", () => {
+    for (const key of RECOVERY_KEYS) {
+      const remediation = recoveryRemediation(key);
+      assert.ok(remediation.length > 0, `empty remediation for ${key}`);
+    }
+  });
+
+  test("classifyFailure carries catalog remediation for every failure kind", () => {
+    const kinds: RecoveryFailureKind[] = [
+      "tool-schema",
+      "tool-contract",
+      "deterministic-policy",
+      "lifecycle-progression",
+      "stale-worker",
+      "worktree-invalid",
+      "verification-drift",
+      "reconciliation-drift",
+      "runtime-unknown",
+    ];
+    for (const kind of kinds) {
+      const result = classifyFailure({ error: new Error("boom"), failureKind: kind });
+      assert.equal(result.failureKind, kind);
+      assert.equal(result.exitReason, kind);
+      assert.ok(result.remediation.length > 0, `empty remediation for ${kind}`);
+    }
+  });
+
+  test("escalation kinds with weak guidance now name a concrete command", () => {
+    for (const key of ["stale-worker", "worktree-invalid", "verification-drift", "reconciliation-drift"] as const) {
+      assert.match(recoveryRemediation(key), /\/gsd /, `no command in remediation for ${key}`);
+    }
+  });
+
+  test("formatGuidance numbers steps under the summary", () => {
+    const text = formatGuidance({ summary: "It broke.", steps: ["Fix it.", "Retry."] });
+    assert.equal(text, "It broke.\n\n1. Fix it.\n2. Retry.");
+  });
+
+  test("formatGuidance with no steps is just the summary", () => {
+    assert.equal(formatGuidance({ summary: "All good.", steps: [] }), "All good.");
+  });
+});
+
+describe("milestone blocker guidance", () => {
+  test("needs-attention blocker keeps the phrase the validation-block guard matches", () => {
+    const state = { phase: "blocked", blockers: [needsAttentionBlockerGuidance("M005")] } as unknown as GSDState;
+    assert.ok(isValidationBlockedState(state));
+  });
+
+  test("needs-remediation blocker keeps the phrase the validation-block guard matches", () => {
+    const state = { phase: "blocked", blockers: [needsRemediationBlockerGuidance("M005")] } as unknown as GSDState;
+    assert.ok(isValidationBlockedState(state));
+  });
+
+  test("blockers carry the milestone id and concrete fix commands", () => {
+    const text = needsAttentionBlockerGuidance("M007");
+    assert.match(text, /M007/);
+    assert.match(text, /\/gsd status/);
+    assert.match(text, /\/gsd validate-milestone/);
+  });
+
+  test("UAT sign-off guidance explains direct dispatch target", () => {
+    const missing = uatSignoffBlockerGuidance("M007", "S02");
+    const failing = uatSignoffBlockerGuidance("M007", "S02", "FAIL");
+
+    for (const text of [missing, failing]) {
+      assert.match(text, /Manual UAT sign-off \(PASS\) is required before milestone closure/);
+      assert.match(text, /\/gsd dispatch uat/);
+      assert.match(text, /most recently completed slice/);
+      assert.match(text, /re-run UAT for S02/);
+      assert.match(text, /gsd_uat_result_save/);
+    }
+  });
+
+  test("worktree creation failure guidance does not claim bootstrap continues", () => {
+    const text = worktreeCreationFailedGuidance("M007", "boom");
+
+    assert.match(text, /Auto-worktree creation for M007 failed: boom\. Continuing in project root\./);
+    assert.match(text, /Worktree isolation is degraded for this session\./);
+    assert.doesNotMatch(text, /work continues in the project root/i);
+  });
+});
+
+describe("crash resume hints", () => {
+  test("bootstrap crash reports no work lost", () => {
+    assert.match(crashResumeHint("starting", "bootstrap") ?? "", /No work was lost/);
+  });
+
+  test("unit classes map to their resume hints", () => {
+    assert.match(crashResumeHint("research-milestone", "M001") ?? "", /may be incomplete/);
+    assert.match(crashResumeHint("execute-task", "T001") ?? "", /completed work is preserved/);
+    assert.match(crashResumeHint("complete-slice", "S001") ?? "", /interrupted/);
+  });
+
+  test("unknown unit types yield no hint", () => {
+    assert.equal(crashResumeHint("triage-captures", "X"), undefined);
+  });
+});
+
+describe("doctor fix hints", () => {
+  test("known codes resolve to a hint", () => {
+    assert.ok(doctorFixHint("stale_crash_lock"));
+    assert.ok(doctorFixHint("db_unavailable"));
+  });
+
+  test("codes without authored guidance resolve to undefined", () => {
+    assert.equal(doctorFixHint("delimiter_in_title"), undefined);
+  });
+
+  test("fixable issue codes instruct /gsd doctor fix, not bare /gsd doctor", () => {
+    const fixableCodes = [
+      "stale_crash_lock",
+      "stale_parallel_session",
+      "orphaned_auto_worktree",
+      "gitignore_missing_patterns",
+      "state_file_stale",
+      "state_file_missing",
+      "projection_drift",
+    ] as const;
+
+    for (const code of fixableCodes) {
+      const hint = doctorFixHint(code);
+      assert.ok(hint, `expected a hint for ${code}`);
+      assert.match(hint, /\/gsd doctor fix/, `hint for ${code} must use /gsd doctor fix`);
+    }
+  });
+
+  test("db_unavailable uses bare /gsd doctor (diagnostic only, no auto-fix)", () => {
+    const hint = doctorFixHint("db_unavailable");
+    assert.ok(hint);
+    assert.match(hint, /\/gsd doctor/);
+    assert.doesNotMatch(hint, /\/gsd doctor fix/);
+  });
+});

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -86,3 +86,45 @@ test("guided milestone prompt builder preloads milestone planning context", asyn
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("guided milestone prompt builder caps prior draft seed before interpolation", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-draft-cap-"));
+  const previousGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = join(base, ".gsd-home");
+
+  try {
+    const currentDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(currentDir, { recursive: true });
+
+    const draftPath = join(currentDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nSMALL-DRAFT-SIGNAL", "utf-8");
+    const smallPrompt = await buildDiscussMilestonePrompt("M001", "Draft Resume", base, "true", {
+      includeContextMode: false,
+    });
+
+    writeFileSync(
+      draftPath,
+      ["# Draft", "", "SMALL-DRAFT-SIGNAL", "", "A".repeat(200_000), "", "OVERSIZED-DRAFT-TAIL-SIGNAL"].join("\n"),
+      "utf-8",
+    );
+    const largePrompt = await buildDiscussMilestonePrompt("M001", "Draft Resume", base, "true", {
+      includeContextMode: false,
+    });
+
+    const addedChars = largePrompt.length - smallPrompt.length;
+
+    assert.match(largePrompt, /## Prior Discussion \(Draft Seed\)/);
+    assert.match(largePrompt, /### Prior Discussion Draft/);
+    assert.match(largePrompt, /SMALL-DRAFT-SIGNAL/);
+    assert.doesNotMatch(largePrompt, /OVERSIZED-DRAFT-TAIL-SIGNAL/);
+    assert.match(
+      largePrompt,
+      /Draft seed truncated; read the full draft at `\.gsd\/milestones\/M001\/M001-CONTEXT-DRAFT\.md` if needed\./,
+    );
+    assert.ok(addedChars < 25_000, `large draft should add bounded seed chars, added ${addedChars}`);
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -11,6 +11,7 @@ import {
   _dispatchWorkflowForTest,
   resolveGuidedDispatchProjectRoot,
 } from "../guided-flow.ts";
+import { getRequiredWorkflowToolsForUnit } from "../unit-tool-contracts.ts";
 
 test("guided dispatch falls back to cwd only when no project root is supplied", () => {
   const cwd = process.cwd();
@@ -77,12 +78,8 @@ test("guided dispatch passes the explicit project root through model and compati
             seen.modelRoot = projectRoot;
             return { routing: null, appliedModel: null };
           },
-          getTransportSupportError: (
-            _provider: string | undefined,
-            _requiredTools: string[],
-            options?: { projectRoot?: string },
-          ) => {
-            seen.compatibilityRoot = options?.projectRoot ?? "";
+          getDispatchReadinessError: (input: { projectRoot?: string }) => {
+            seen.compatibilityRoot = input.projectRoot ?? "";
             return null;
           },
         },
@@ -119,6 +116,7 @@ test("guided dispatch accepts workflow MCP tools absent from parent active tool
       getProviderAuthMode: () => "externalCli",
     },
     ui: {
+      setStatus: () => {},
       notify: (message: string) => {
         notifications.push(message);
       },
@@ -134,8 +132,22 @@ test("guided dispatch accepts workflow MCP tools absent from parent active tool
     "write",
   ];
 
+  // The workflow MCP server registers its tools out of band, so the unit's
+  // required workflow tools show up in the registered tool snapshot
+  // (getAllTools) under the MCP server prefix without ever entering the parent
+  // session's active tool surface (getActiveTools). This is exactly the shape
+  // the readiness gate must accept. Derive the surface from the unit contract
+  // so this test stays correct if discuss-milestone's required tools change.
+  const registeredTools = [
+    ...activeTools,
+    ...getRequiredWorkflowToolsForUnit("discuss-milestone").map(
+      (tool) => `mcp__gsd-workflow__${tool}`,
+    ),
+  ];
+
   const pi = {
     getActiveTools: () => [...activeTools],
+    getAllTools: () => registeredTools.map((name) => ({ name })),
     setActiveTools: (tools: string[]) => {
       activeTools = [...tools];
     },

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -3,8 +3,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   buildHealthLines,
@@ -12,8 +14,9 @@ import {
   formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
-import { HEALTH_WIDGET_ACTIVE_HINTS } from "../health-widget.ts";
+import { HEALTH_WIDGET_ACTIVE_HINTS, getCachedProjectState, initHealthWidget } from "../health-widget.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -32,6 +35,58 @@ function cleanup(dir: string): void {
   }
 }
 
+function runGit(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim();
+}
+
+function makeTempRepo(prefix: string): string {
+  const dir = makeTempDir(prefix);
+  runGit(dir, "init");
+  runGit(dir, "config", "user.email", "test@test.com");
+  runGit(dir, "config", "user.name", "Test");
+  writeFileSync(join(dir, "README.md"), "# test\n", "utf-8");
+  runGit(dir, "add", "README.md");
+  runGit(dir, "commit", "-m", "initial commit");
+  return dir;
+}
+
+function installSlowGitLogShim(binDir: string): void {
+  writeFileSync(
+    join(binDir, "git"),
+    [
+      "#!/bin/sh",
+      'if [ "$1" = "log" ]; then sleep 1; fi',
+      'PATH="$GSD_REAL_PATH"',
+      "export PATH",
+      'exec git "$@"',
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  chmodSync(join(binDir, "git"), 0o755);
+
+  writeFileSync(
+    join(binDir, "git.cmd"),
+    [
+      "@echo off",
+      'if "%1"=="log" powershell -NoProfile -Command "Start-Sleep -Seconds 1"',
+      'set "PATH=%GSD_REAL_PATH%"',
+      "git %*",
+      "",
+    ].join("\r\n"),
+    "utf-8",
+  );
+}
+
+type HealthWidgetFactory = (
+  tui: { requestRender(): void },
+  theme: { fg(style: string, text: string): string },
+) => { dispose(): void };
+
 function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData {
   return {
     projectState: "active",
@@ -70,6 +125,86 @@ test("detectHealthWidgetProjectState: milestone without metrics returns active",
   assert.equal(detectHealthWidgetProjectState(dir), "active");
 });
 
+test("getCachedProjectState: reuses project state until the refresh TTL expires", (t) => {
+  const dir = makeTempDir("cached-state");
+  t.after(() => { cleanup(dir); });
+
+  let now = 1_000_000;
+  const dateNow = t.mock.method(Date, "now", () => now);
+  t.after(() => { dateNow.mock.restore(); });
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  now += 60_000;
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  now += 1;
+  assert.equal(getCachedProjectState(dir), "active");
+});
+
+test("getCachedProjectState: force=true bypasses TTL and returns fresh state within TTL window", (t) => {
+  const dir = makeTempDir("forced-state");
+  t.after(() => { cleanup(dir); });
+
+  let now = 2_000_000;
+  const dateNow = t.mock.method(Date, "now", () => now);
+  t.after(() => { dateNow.mock.restore(); });
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  // Prime the cache with "initialized".
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  // Disk changes within the TTL window.
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  now += 1_000; // well within 60s TTL
+
+  // Normal call still returns stale cached value.
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  // force=true bypasses TTL and returns the fresh disk state.
+  assert.equal(getCachedProjectState(dir, true), "active");
+
+  // Subsequent non-forced call also reflects the freshened cache.
+  assert.equal(getCachedProjectState(dir), "active");
+});
+
+test("initHealthWidget: re-init paints fresh project state within cache TTL", (t) => {
+  const dir = makeTempDir("reinit-state");
+  t.after(() => { cleanup(dir); });
+
+  let now = 3_000_000;
+  const dateNow = t.mock.method(Date, "now", () => now);
+  t.after(() => { dateNow.mock.restore(); });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  t.after(() => { process.chdir(originalCwd); });
+
+  const initialLineSets: string[][] = [];
+  const ctx = {
+    hasUI: true,
+    ui: {
+      setWidget: (_key: string, value: unknown) => {
+        if (Array.isArray(value)) initialLineSets.push(value as string[]);
+      },
+    },
+  } as any;
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  initHealthWidget(ctx);
+  assert.equal(initialLineSets.at(-1)?.[0], "  GSD  Project Initialized");
+
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  now += 1_000;
+
+  initHealthWidget(ctx);
+  assert.match(initialLineSets.at(-1)?.[0] ?? "", /System OK/);
+});
+
 test("buildHealthLines: none state shows single onboarding line pointing at /gsd", (t) => {
   const lines = buildHealthLines(activeData({ projectState: "none" }));
   assert.equal(lines.length, 1, "renders exactly one line");
@@ -101,6 +236,136 @@ test("health widget active hints include visualization and notifications", () =>
   assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd help/);
 });
 
+test("health widget async refresh does not block timers while git log is slow", async (t) => {
+  const dir = makeTempRepo("slow-git-log");
+  const binDir = makeTempDir("slow-git-log-bin");
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  installSlowGitLogShim(binDir);
+
+  const originalCwd = process.cwd();
+  const originalProcessPath = process.env.PATH;
+  const originalEnvPath = GIT_NO_PROMPT_ENV.PATH;
+  const originalEnvRealPath = GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+  const shimmedPath = `${binDir}${delimiter}${originalProcessPath ?? ""}`;
+
+  process.chdir(dir);
+  process.env.PATH = shimmedPath;
+  GIT_NO_PROMPT_ENV.PATH = shimmedPath;
+  GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalProcessPath ?? "";
+
+  let factory: HealthWidgetFactory | null = null;
+  let resolveRefresh: (() => void) | undefined;
+  const refreshed = new Promise<void>((resolve) => { resolveRefresh = resolve; });
+  const gaps: number[] = [];
+  let lastTick = performance.now();
+  let heartbeat: NodeJS.Timeout | undefined;
+  let refreshTimeout: NodeJS.Timeout | undefined;
+  let widget: { dispose(): void } | undefined;
+
+  t.after(() => {
+    if (widget) widget.dispose();
+    if (heartbeat) clearInterval(heartbeat);
+    if (refreshTimeout) clearTimeout(refreshTimeout);
+    process.chdir(originalCwd);
+    if (originalProcessPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalProcessPath;
+    if (originalEnvPath === undefined) delete GIT_NO_PROMPT_ENV.PATH;
+    else GIT_NO_PROMPT_ENV.PATH = originalEnvPath;
+    if (originalEnvRealPath === undefined) delete GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+    else GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalEnvRealPath;
+    cleanup(binDir);
+    cleanup(dir);
+  });
+
+  initHealthWidget({
+    hasUI: true,
+    ui: {
+      setWidget: (_key: string, value: unknown) => {
+        if (typeof value === "function") factory = value as HealthWidgetFactory;
+      },
+    },
+  } as any);
+
+  assert.ok(factory, "health widget factory is registered");
+
+  heartbeat = setInterval(() => {
+    const now = performance.now();
+    gaps.push(now - lastTick);
+    lastTick = now;
+  }, 25);
+
+  // assert.ok above guards at runtime; double-cast is needed because TypeScript
+  // cannot track the factory assignment through the `as any` closure call.
+  widget = (factory as unknown as HealthWidgetFactory)(
+    { requestRender: () => { resolveRefresh?.(); } },
+    { fg: (_style: string, text: string) => text },
+  );
+
+  await Promise.race([
+    refreshed,
+    new Promise<never>((_, reject) => {
+      refreshTimeout = setTimeout(() => reject(new Error("health widget refresh did not complete")), 4_000);
+    }),
+  ]);
+  if (refreshTimeout) clearTimeout(refreshTimeout);
+
+  assert.ok(gaps.length > 0, "heartbeat ran while refresh was in flight");
+  const maxGap = Math.max(...gaps);
+  assert.ok(maxGap < 750, `slow git log must not starve timers; max gap was ${Math.round(maxGap)}ms`);
+});
+
+test("initHealthWidget: synchronous first-paint render never contains last-commit info (regression #964)", (t) => {
+  // Before the fix, loadHealthWidgetData with includeChecks:true called
+  // loadLastCommitInfo — synchronous native-git-bridge ops (nativeIsRepo,
+  // nativeGetCurrentBranch, nativeLastCommitEpoch, nativeCommitSubject) — which
+  // froze the TUI on slow repos. The fix removes that synchronous git path
+  // entirely: lastCommitEpoch/lastCommitMessage are now always null from the
+  // synchronous loader; only the async refresh (loadLastCommitInfoAsync) fills
+  // them in. This test guards that contract by verifying that the initial
+  // string-array setWidget call never contains "Last commit:" even on a real
+  // git repo where native git queries would succeed.
+  const dir = makeTempRepo("sync-last-commit-regression");
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+
+  let widget: { dispose(): void } | undefined;
+  t.after(() => {
+    if (widget) widget.dispose();
+    process.chdir(originalCwd);
+    cleanup(dir);
+  });
+
+  const initialRenders: string[][] = [];
+
+  initHealthWidget({
+    hasUI: true,
+    ui: {
+      setWidget: (_key: string, value: unknown) => {
+        if (Array.isArray(value)) {
+          initialRenders.push(value as string[]);
+        } else if (typeof value === "function") {
+          // Instantiate the factory to satisfy dispose(), but do not await the
+          // async refresh — we are only inspecting the synchronous first-paint.
+          widget = (value as unknown as HealthWidgetFactory)(
+            { requestRender: () => {} },
+            { fg: (_style: string, text: string) => text },
+          );
+        }
+      },
+    },
+  } as any);
+
+  assert.ok(initialRenders.length > 0, "at least one synchronous setWidget call");
+
+  const combined = initialRenders.flat().join("\n");
+  assert.ok(
+    !combined.includes("Last commit:"),
+    "synchronous first-paint render must not contain 'Last commit:' — sync git path removed (regression #964)",
+  );
+});
+
 test("buildHealthLines: active state with budget ceiling shows percent summary", (t) => {
   const lines = buildHealthLines(activeData({ budgetSpent: 2.5, budgetCeiling: 10 }));
   assert.equal(lines.length, 1);

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -560,7 +560,12 @@ test("verifyExpectedArtifact execute-task rejects heading-style plan without che
 });
 
 test("verifyExpectedArtifact plan-slice passes for rendered slice/task plan artifacts from DB", async () => {
-  const base = makeTmpBase();
+  // Do NOT use makeTmpBase() here — it creates a legacy milestones/ dir which forces
+  // renderPlanFromDb into the legacy path layout and creates a spurious tasks/ dir that
+  // triggers the per-task file check even when dbPrimary=true. Create only .gsd/ so
+  // resolveMilestonePath returns null and the flat-phase path is used instead.
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
   const dbPath = join(base, ".gsd", "gsd.db");
   openDatabase(dbPath);
   try {
@@ -614,26 +619,28 @@ test("verifyExpectedArtifact plan-slice passes for rendered slice/task plan arti
 
     const rendered = await renderPlanFromDb(base, "M001", "S01");
     assert.ok(existsSync(rendered.planPath), "renderPlanFromDb should write the slice plan");
-    assert.equal(rendered.taskPlanPaths.length, 2, "renderPlanFromDb should render one task plan per task");
+    // Flat-phase: tasks are checkboxes inside the slice plan — no per-task plan files.
+    assert.equal(rendered.taskPlanPaths.length, 0, "flat-phase: renderPlanFromDb returns no per-task plan paths");
 
     const planContent = readFileSync(rendered.planPath, "utf-8");
     const parsedPlan = parsePlan(planContent);
     assert.equal(parsedPlan.tasks.length, 2, "rendered slice plan should parse into task entries");
 
-    const taskPlanContent = readFileSync(rendered.taskPlanPaths[0], "utf-8");
-    const taskPlan = parseTaskPlanFile(taskPlanContent);
-    assert.deepEqual(taskPlan.frontmatter.skills_used, [], "rendered task plans should use conservative empty skills_used");
-
+    // DB-primary: task rows prove the slice was planned; no per-task file check.
     const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-    assert.equal(result, true, "plan-slice verification should pass when rendered task plan files exist");
+    assert.equal(result, true, "plan-slice verification should pass when DB has task rows");
   } finally {
     closeDatabase();
     cleanup(base);
   }
 });
 
-test("verifyExpectedArtifact plan-slice fails after deleting a rendered task plan file", async () => {
-  const base = makeTmpBase();
+test("verifyExpectedArtifact plan-slice fails after deleting the slice plan file", async () => {
+  // Do NOT use makeTmpBase() here — same reason as the passing test above: the legacy
+  // milestones/ dir forces a legacy path and creates a tasks/ dir that incorrectly
+  // triggers the per-task file check. Create only .gsd/ to stay on the flat-phase path.
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
   const dbPath = join(base, ".gsd", "gsd.db");
   openDatabase(dbPath);
   try {
@@ -686,10 +693,11 @@ test("verifyExpectedArtifact plan-slice fails after deleting a rendered task pla
     });
 
     const rendered = await renderPlanFromDb(base, "M001", "S01");
-    rmSync(rendered.taskPlanPaths[1]);
+    // Flat-phase: per-task plan files do not exist; delete the slice plan itself to fail verification.
+    rmSync(rendered.planPath);
 
     const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-    assert.equal(result, false, "plan-slice verification should fail when a rendered task plan file is removed");
+    assert.equal(result, false, "plan-slice verification should fail when the slice plan file is removed");
   } finally {
     closeDatabase();
     cleanup(base);