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

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -1,72 +1,61 @@
 /**
- * Regression test for #3628 — restore tool set after discuss flow scoping
- *
- * The discuss flow narrows the active tool set to avoid "grammar too complex"
- * errors. Without restoring after sendMessage, the narrowed tools leaked into
- * subsequent dispatches, breaking plan/execute flows.
- *
- * The fix saves the full tool set before scoping and restores it after
- * sendMessage returns.
+ * Regression test for #3628 — restore tool set after discuss flow scoping.
  */
 
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'guided-flow.ts'),
-  'utf-8',
-)
-
-describe('restore tools after discuss flow scoping (#3628)', () => {
-  it('savedTools is declared before the discuss scoping block', () => {
-    // savedTools must be declared before the discuss-* check
-    const savedToolsDecl = src.indexOf('let savedTools')
-    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
-    assert.ok(savedToolsDecl !== -1, 'savedTools variable must be declared')
-    assert.ok(discussCheck !== -1, 'discuss-* type check must exist')
-    assert.ok(
-      savedToolsDecl < discussCheck,
-      'savedTools must be declared before the discuss scoping block',
-    )
-  })
-
-  it('savedTools captures current tools inside the discuss block', () => {
-    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
-    assert.ok(discussCheck !== -1)
-
-    // Look for savedTools assignment within the discuss block
-    const blockAfter = extractSourceRegion(src, 'if (unitType?.startsWith("discuss-"))')
-    assert.ok(
-      blockAfter.includes('savedTools = currentTools'),
-      'savedTools must be assigned from currentTools inside the discuss block',
-    )
-  })
-
-  it('savedTools is restored after sendMessage', () => {
-    // #4573: guided-flow.ts now contains multiple `triggerTurn: true` calls
-    // (ready-phrase and empty-turn recovery paths). The discuss-flow scoping
-    // sendMessage is the one that follows `savedTools = currentTools`, so
-    // anchor the search there rather than at the first `triggerTurn: true`.
-    const savedToolsAssign = src.indexOf('savedTools = currentTools')
-    assert.ok(savedToolsAssign !== -1, 'savedTools = currentTools must exist')
-
-    const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
-    assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
-
-    // After sendMessage, savedTools should be restored via setActiveTools.
-    // Use fromIdx to anchor at the discuss-flow sendMessage, not the first
-    // triggerTurn: true occurrence in the file.
-    const afterSend = extractSourceRegion(src, 'triggerTurn: true', { fromIdx: savedToolsAssign })
-    assert.ok(
-      afterSend.includes('if (savedTools)'),
-      'savedTools restoration guard must exist after sendMessage',
-    )
-    assert.ok(
-      afterSend.includes('setActiveTools(savedTools)'),
-      'setActiveTools(savedTools) must be called to restore the full tool set',
-    )
-  })
-})
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { _dispatchWorkflowForTest } from "../guided-flow.ts";
+
+test("discuss workflow scopes tools for the queued turn and restores the full tool set", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-discuss-tools-"));
+  const workflowPath = join(dir, "GSD-WORKFLOW.md");
+  const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+  const originalTools = [
+    "gsd_task_complete",
+    "gsd_summary_save",
+    "shell_exec",
+    "gsd_plan_milestone",
+  ];
+  let activeTools = [...originalTools];
+  let sentTools: string[] | null = null;
+  let triggerTurn = false;
+
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+    sendMessage: (_message: unknown, options?: { triggerTurn?: boolean }) => {
+      sentTools = [...activeTools];
+      triggerTurn = options?.triggerTurn === true;
+    },
+  };
+
+  try {
+    writeFileSync(workflowPath, "# Workflow\n", "utf-8");
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+
+    await _dispatchWorkflowForTest(
+      pi as any,
+      "Interview the user.",
+      "gsd-discuss",
+      undefined,
+      "discuss-milestone",
+    );
+
+    assert.deepEqual(sentTools, ["gsd_summary_save"]);
+    assert.deepEqual(activeTools, originalTools);
+    assert.equal(triggerTurn, true);
+  } finally {
+    if (originalWorkflowPath === undefined) {
+      delete process.env.GSD_WORKFLOW_PATH;
+    } else {
+      process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+    }
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/resume-dispatch-worktree.test.ts

@@ -1,15 +1,6 @@
 /**
- * Tests for fix of #3723: auto-mode resume/crash-recovery dispatches
- * from project root instead of milestone worktree.
- *
- * During resume, the paused-session metadata may record `worktreePath` that
- * was active when the session paused. The resume path must use that path (or
- * derive the worktree path via filesystem lookup) to set the dispatch context
- * (`s.basePath`), rather than defaulting to the project root.
- *
- * The fix adds an early worktree-path resolution step in the paused-session
- * resume block of auto.ts — immediately after `s.basePath = base` — so that
- * the correct dispatch directory is used before the dispatch loop runs.
+ * Tests for fix of #3723: auto-mode resume/crash-recovery dispatches from
+ * the paused milestone worktree when that worktree still exists.
  */
 
 import test from "node:test";
@@ -18,95 +9,8 @@ import { readFileSync, mkdirSync, rmSync, writeFileSync } 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 __dirname = dirname(fileURLToPath(import.meta.url));
-const autoSrc = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
-
-// ── Source-structure tests ────────────────────────────────────────────────────
-
-/**
- * Extract the paused-session resume block from auto.ts.
- *
- * The block we care about is the `if (s.paused) { ... }` section inside
- * startAuto, which contains `s.basePath = base` (line ~1473) followed by the
- * `enterMilestone` call.
- *
- * We find it by locating the `s.basePath = base` assignment that appears
- * WITHIN the s.paused branch (there's only one: all other basePath assignments
- * use originalBasePath or a different value). We extract from that assignment
- * up to just before `enterMilestone(`.
- */
-function getBasepathToEnterMilestoneSegment(): string {
-  // Find `s.basePath = base;` in the s.paused branch
-  // This assignment appears uniquely inside the resume block
-  const assignPattern = "s.basePath = base;";
-  const assignIdx = autoSrc.indexOf(assignPattern);
-  assert.ok(
-    assignIdx > -1,
-    `auto.ts must contain '${assignPattern}' in the resume block`,
-  );
-
-  // Find the next enterMilestone call after this assignment
-  const enterMilestoneIdx = autoSrc.indexOf("enterMilestone(", assignIdx);
-  assert.ok(
-    enterMilestoneIdx > assignIdx,
-    "auto.ts must call enterMilestone after the s.basePath = base assignment",
-  );
-
-  // Return the code between the assignment and enterMilestone
-  return autoSrc.slice(assignIdx, enterMilestoneIdx);
-}
-
-test("auto.ts resume block resolves paused-session worktreePath and applies it to s.basePath before entering worktree (fixes #3723)", () => {
-  // The segment between `s.basePath = base` and `enterMilestone(` must
-  // contain logic that resolves the paused-session worktreePath and applies
-  // it to s.basePath when the worktree exists on disk.
-  //
-  // The fix reads the worktree path from freshStartAssessment.pausedSession
-  // (since `meta` is out of scope at this point in startAuto) and assigns
-  // it to s.basePath, guarded by existsSync.
-  //
-  // Without this fix, the dispatch loop runs from `base` (project root)
-  // instead of the worktree, causing split-brain execution (#3723).
-  const segment = getBasepathToEnterMilestoneSegment();
-
-  // The fix uses freshStartAssessment.pausedSession?.worktreePath via a
-  // local variable (resumeWorktreePath) and assigns to s.basePath.
-  const hasWorktreePathResolution =
-    segment.includes("worktreePath") &&
-    segment.includes("existsSync") &&
-    segment.includes("s.basePath =");
-
-  assert.ok(
-    hasWorktreePathResolution,
-    "auto.ts must resolve the paused-session worktreePath, check existsSync, and assign " +
-    "s.basePath before enterMilestone — crash-recovery currently dispatches from project root " +
-    "instead of milestone worktree (issue #3723). The fix belongs between `s.basePath = base` " +
-    "and the enterMilestone call.",
-  );
-});
-
-test("auto.ts worktreePath assignment in resume block guards against non-existent path (fixes #3723)", () => {
-  // The assignment to s.basePath from the paused-session worktreePath must
-  // be guarded by existsSync to avoid setting an invalid basePath if the
-  // worktree was cleaned up between pause and resume.
-  const segment = getBasepathToEnterMilestoneSegment();
-
-  // Must have existsSync guard AND a worktreePath reference AND s.basePath assignment
-  const hasGuardedAssignment =
-    segment.includes("existsSync") &&
-    segment.includes("worktreePath") &&
-    segment.includes("s.basePath =");
-
-  assert.ok(
-    hasGuardedAssignment,
-    "auto.ts must guard the s.basePath = worktreePath assignment with existsSync (fixes #3723)",
-  );
-});
-
-// ── Functional tests ──────────────────────────────────────────────────────────
+import { _resolvePausedResumeBasePathForTest } from "../auto.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-resume-wt-${randomUUID()}`);
@@ -115,7 +19,7 @@ function makeTmpBase(): string {
 }
 
 function cleanup(base: string): void {
-  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
 }
 
 function writePausedSession(
@@ -142,7 +46,6 @@ function makeWorktreePath(base: string, milestoneId: string): string {
 
 function setupWorktreeOnDisk(wt: string): void {
   mkdirSync(wt, { recursive: true });
-  // Simulate a git worktree: .git file with gitdir pointer
   writeFileSync(
     join(wt, ".git"),
     "gitdir: /project/.git/worktrees/M001-test\n",
@@ -150,81 +53,46 @@ function setupWorktreeOnDisk(wt: string): void {
   );
 }
 
-function writeRoadmap(base: string, milestoneId = "M001-test"): void {
-  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
-  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
-  writeFileSync(
-    join(milestoneDir, `${milestoneId}-ROADMAP.md`),
-    [
-      `# ${milestoneId}: Test Milestone`,
-      "",
-      "## Slices",
-      "",
-      "- [ ] **S01: Test slice** `risk:low`",
-      "  After this: Demo",
-    ].join("\n"),
-    "utf-8",
-  );
-}
+test("resume base path uses paused-session worktreePath when the worktree exists", () => {
+  const base = makeTmpBase();
+  const wt = makeWorktreePath(base, "M001-test");
+  try {
+    setupWorktreeOnDisk(wt);
+    assert.equal(
+      _resolvePausedResumeBasePathForTest(base, wt),
+      wt,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
 
-test("readPausedSessionMetadata round-trips worktreePath from paused-session.json", () => {
-  // Verify that the paused-session metadata correctly stores and reads back
-  // the worktreePath field — this is what the resume path in auto.ts uses
-  // to determine the dispatch basePath (#3723).
-  //
-  // Implemented inline to avoid slow import chain from interrupted-session.ts.
+test("resume base path falls back to project root when paused worktree is missing", () => {
+  const base = makeTmpBase();
+  const wt = makeWorktreePath(base, "M001-test");
+  try {
+    assert.equal(
+      _resolvePausedResumeBasePathForTest(base, wt),
+      base,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("read paused-session metadata round-trips worktreePath from paused-session.json", () => {
   const base = makeTmpBase();
   const wt = makeWorktreePath(base, "M001-test");
   try {
     setupWorktreeOnDisk(wt);
     writePausedSession(base, "M001-test", wt);
 
-    // Simulate readPausedSessionMetadata without importing the full module
     const pausedPath = join(base, ".gsd", "runtime", "paused-session.json");
     const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
 
-    assert.ok(meta, "paused-session metadata must be readable");
     assert.equal(meta.milestoneId, "M001-test");
-    assert.equal(meta.worktreePath, wt, "worktreePath must round-trip through paused-session.json");
+    assert.equal(meta.worktreePath, wt);
   } finally {
     cleanup(base);
   }
 });
-
-test("auto.ts resume block uses worktreePath from freshStartAssessment.pausedSession as dispatch basePath when worktree exists (#3723)", () => {
-  // End-to-end structural verification: the auto.ts source must contain code
-  // that reads the worktreePath from freshStartAssessment.pausedSession AND
-  // applies it to s.basePath (guarded by existsSync) between the
-  // `s.basePath = base` assignment and `enterMilestone`.
-  //
-  // This is the core of the #3723 fix. Without this check, a session that
-  // paused while operating inside a worktree will resume dispatching from the
-  // project root, not the worktree — causing split-brain execution where some
-  // operations target the worktree and others target the project root.
-  const segment = getBasepathToEnterMilestoneSegment();
-
-  // Must reference freshStartAssessment.pausedSession?.worktreePath or
-  // equivalent local variable, AND contain an existsSync guard
-  const hasAssessmentWorktreePath =
-    segment.includes("freshStartAssessment.pausedSession") &&
-    segment.includes("worktreePath");
-
-  assert.ok(
-    hasAssessmentWorktreePath,
-    "auto.ts must read worktreePath from freshStartAssessment.pausedSession between " +
-    "s.basePath=base and enterMilestone",
-  );
-  assert.ok(
-    segment.includes("existsSync"),
-    "auto.ts must guard worktreePath usage with existsSync",
-  );
-  // The actual basePath re-assignment must be present in the segment
-  // (note: there are multiple `s.basePath =` assignments — we need one after
-  // the initial `s.basePath = base` assignment within this segment)
-  const worktreeAssignIdx = segment.lastIndexOf("s.basePath =");
-  const baseAssignIdx = segment.indexOf("s.basePath = base");
-  assert.ok(
-    worktreeAssignIdx > baseAssignIdx,
-    "auto.ts must assign s.basePath to the worktree path after `s.basePath = base` in the resume block",
-  );
-});

package/src/resources/extensions/gsd/tests/right-sized-workflow-prompts.test.ts

@@ -0,0 +1,192 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildCompleteMilestonePrompt, buildPlanMilestonePrompt } from "../auto-prompts.ts";
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: { ...process.env, GIT_AUTHOR_NAME: "Test User", GIT_AUTHOR_EMAIL: "test@example.com", GIT_COMMITTER_NAME: "Test User", GIT_COMMITTER_EMAIL: "test@example.com" },
+  }).trim();
+}
+
+function makeRepo(files: Record<string, string>): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-right-size-"));
+  git(base, ["init", "-b", "main"]);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# Context\n\nTest milestone.");
+  for (const [path, content] of Object.entries(files)) {
+    const abs = join(base, path);
+    mkdirSync(join(abs, ".."), { recursive: true });
+    writeFileSync(abs, content);
+  }
+  git(base, ["add", "."]);
+  git(base, ["commit", "-m", "init"]);
+  return base;
+}
+
+function writeCompleteMilestoneFiles(base: string, validation: string): void {
+  const dir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(dir, "slices", "S01"), { recursive: true });
+  writeFileSync(join(dir, "M001-ROADMAP.md"), "# M001\n\n## Slices\n- [x] **S01: One** `risk:low` `depends:[]`\n  > Done\n");
+  writeFileSync(join(dir, "M001-VALIDATION.md"), validation);
+  writeFileSync(join(dir, "slices", "S01", "S01-SUMMARY.md"), "# S01 Summary\n\n**Verification:** passed\n");
+}
+
+function validationMetadata(): string {
+  return [
+    "validation_metadata:",
+    "  covered_artifacts:",
+    "    - `.gsd/milestones/M001/M001-VALIDATION.md`",
+    "    - `.gsd/milestones/M001/M001-ROADMAP.md`",
+    "    - `.gsd/milestones/M001/slices/S01/S01-SUMMARY.md`",
+  ].join("\n");
+}
+
+test("plan-milestone prompt includes tiny untyped project classification and one-slice guidance", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* untyped-existing/);
+    assert.match(prompt, /\*\*Content files:\*\* 1/);
+    assert.match(prompt, /`index\.html`/);
+    assert.match(prompt, /Prefer exactly one slice/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("plan-milestone prompt includes small untyped project 1-2 slice guidance", async () => {
+  const base = makeRepo({
+    "index.html": "html",
+    "README.md": "readme",
+    "styles.css": "body {}",
+  });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Polish static files", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* untyped-existing/);
+    assert.match(prompt, /\*\*Content files:\*\* 3/);
+    assert.match(prompt, /Prefer 1-2 slices/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("plan-milestone prompt keeps normal guidance for typed projects", async () => {
+  const base = makeRepo({
+    "package.json": "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    "src/index.js": "console.log('ok');\n",
+  });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Update app", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* typed-existing/);
+    assert.match(prompt, /Use normal ecosystem-aware planning guidance/);
+    assert.doesNotMatch(prompt, /Prefer exactly one slice/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("workflow docs no longer contain blanket 4-10 slice guidance", () => {
+  const docs = readFileSync(join(process.cwd(), "src", "resources", "GSD-WORKFLOW.md"), "utf-8");
+  assert.doesNotMatch(docs, /4-10 slices/);
+  assert.match(docs, /1-10 slices/);
+  assert.match(docs, /single-file/);
+});
+
+test("prompt templates carry right-sized planning and closeout mode guidance", () => {
+  const planTemplate = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "prompts", "plan-milestone.md"), "utf-8");
+  const completeTemplate = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "prompts", "complete-milestone.md"), "utf-8");
+
+  assert.match(planTemplate, /Use 1-10 slices, sized to the work/);
+  assert.match(planTemplate, /tiny\/single-file\/static work should usually be one slice/);
+  assert.match(planTemplate, /untyped-existing/);
+  assert.match(completeTemplate, /Closeout Review Mode/);
+  assert.match(completeTemplate, /passing validation artifact is present/);
+  assert.doesNotMatch(completeTemplate, /^### Delegate Review Work/m);
+});
+
+test("complete-milestone prompt trusts passing validation artifact", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\n${validationMetadata()}\n\nAll checks passed.`);
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Passing Validation Artifact/);
+    assert.match(prompt, /Treat it as authoritative/);
+    assert.match(prompt, /Do not delegate fresh reviewer\/security\/tester audits/);
+    assert.match(prompt, /All checks passed/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt trusts centralized markdown body pass verdict", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, `# Validation\n\n**Verdict:** PASS\n\n${validationMetadata()}\n\nAll checks passed.`);
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Passing Validation Artifact/);
+    assert.match(prompt, /Treat it as authoritative/);
+    assert.match(prompt, /Do not delegate fresh reviewer\/security\/tester audits/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt does not trust stale pass validation without metadata", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nAll checks passed.");
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /missing freshness metadata/);
+    assert.doesNotMatch(prompt, /Passing Validation Artifact/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt does not trust pass validation missing current summary coverage", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, [
+      "---",
+      "verdict: pass",
+      "remediation_round: 0",
+      "---",
+      "",
+      "# Validation",
+      "validation_metadata:",
+      "  covered_artifacts:",
+      "    - `.gsd/milestones/M001/M001-VALIDATION.md`",
+      "    - `.gsd/milestones/M001/M001-ROADMAP.md`",
+      "",
+      "All checks passed.",
+    ].join("\n"));
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /does not cover current milestone artifacts/);
+    assert.doesNotMatch(prompt, /Passing Validation Artifact/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt keeps deeper review path without passing validation", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nFix gaps.");
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /verdict `needs-attention`/);
+    assert.match(prompt, /Use `subagent` for review work needing fresh context/i);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});