gsd-pi 2.80.0-dev.c5c38454b → 2.80.0-dev.e146beb20

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -131,7 +131,7 @@ test("postflightPopStash — restores stashed changes and emits info notificatio
     run('git commit -m "simulate merge"', repo);
 
     const postNotifications: Array<{ msg: string; level: string }> = [];
-    postflightPopStash(repo, "M004", (msg, level) => {
+    postflightPopStash(repo, "M004", preflight.stashMarker, (msg, level) => {
       postNotifications.push({ msg, level });
     });
 
@@ -171,7 +171,7 @@ test("preflight + merge + postflight round-trip preserves uncommitted changes",
     run('git commit -m "feat: add feature"', repo);
 
     // Postflight: pop stash
-    postflightPopStash(repo, "M005", () => {});
+    postflightPopStash(repo, "M005", preflight.stashMarker, () => {});
 
     // README.md must still have our local content
     const restored = readFileSync(join(repo, "README.md"), "utf-8");
@@ -184,3 +184,89 @@ test("preflight + merge + postflight round-trip preserves uncommitted changes",
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
 });
+
+test("postflightPopStash conflict warning names the exact stash ref", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# local work\n");
+    const preflight = preflightCleanRoot(repo, "M005C", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed");
+
+    writeFileSync(join(repo, "README.md"), "# merged work\n");
+    run("git add README.md", repo);
+    run('git commit -m "simulate conflicting merge"', repo);
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    postflightPopStash(repo, "M005C", preflight.stashMarker, (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
+    assert.match(warning, /git stash pop stash@\{\d+\}/);
+    assert.match(warning, /git stash apply stash@\{\d+\}/);
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash restores the matching GSD stash, not stash@{0}", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# target stash\n");
+    const preflight = preflightCleanRoot(repo, "M006", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed target change");
+
+    writeFileSync(join(repo, "other.txt"), "other stash\n");
+    run('git stash push --include-untracked -m "unrelated newer stash"', repo);
+
+    postflightPopStash(repo, "M006", preflight.stashMarker, () => {});
+
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
+    const stashList = run("git stash list", repo);
+    assert.ok(stashList.includes("unrelated newer stash"), "unrelated newer stash must remain");
+    assert.ok(!stashList.includes("gsd-preflight-stash [gsd-preflight-stash:M006"), "target stash should be consumed");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash restores the exact preflight marker when another same-milestone stash exists", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# target stash\n");
+    const preflight = preflightCleanRoot(repo, "M007", () => {});
+    assert.equal(preflight.stashPushed, true, "must have stashed target change");
+    assert.ok(preflight.stashMarker, "preflight must expose exact stash marker");
+
+    writeFileSync(join(repo, "same-milestone.txt"), "newer same milestone stash\n");
+    run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M007:other]"', repo);
+
+    postflightPopStash(repo, "M007", preflight.stashMarker, () => {});
+
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
+    const stashList = run("git stash list", repo);
+    assert.ok(stashList.includes("gsd-preflight-stash:M007:other"), "newer same-milestone stash must remain");
+    assert.ok(!stashList.includes(preflight.stashMarker), "exact target stash should be consumed");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash falls back to milestone marker prefix when exact marker is unavailable", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# fallback stash\n");
+    run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M008:fallback]"', repo);
+
+    postflightPopStash(repo, "M008", undefined, () => {});
+
+    const content = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(content.replace(/\r\n/g, "\n"), "# fallback stash\n");
+    const stashList = run("git stash list", repo);
+    assert.ok(!stashList.includes("gsd-preflight-stash:M008:fallback"), "fallback stash should be consumed");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

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

@@ -232,4 +232,59 @@ describe('emitCrashRecoveredUnitEnd (#3348)', () => {
       rmSync(base, { recursive: true, force: true });
     }
   });
+
+  test('emitOpenUnitEndForUnit closes the latest open start with error context', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitOpenUnitEndForUnit } = await import('../crash-recovery.ts');
+
+      const firstFlowId = randomUUID();
+      const secondFlowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 1,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 2,
+        eventType: 'unit-end',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02', status: 'completed' },
+        causedBy: { flowId: firstFlowId, seq: 1 },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: secondFlowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+
+      const emitted = emitOpenUnitEndForUnit(
+        base,
+        'execute-task',
+        'M008/S04/T02',
+        'cancelled',
+        { message: 'runUnitPhase exploded', category: 'unit-exception', isTransient: false },
+      );
+
+      assert.equal(emitted, true, 'open unit should be closed');
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 2, 'should preserve existing end and add one new end');
+      const newEnd = ends.find((e) => e.causedBy?.flowId === secondFlowId);
+      assert.ok(newEnd, 'new end should close the latest open start');
+      assert.equal(newEnd!.data?.status, 'cancelled');
+      assert.deepEqual(newEnd!.data?.errorContext, {
+        message: 'runUnitPhase exploded',
+        category: 'unit-exception',
+        isTransient: false,
+      });
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -30,6 +30,7 @@ import {
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
+import { writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
@@ -102,6 +103,27 @@ test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches
   assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
 });
 
+test("readCrashLock falls back to latest in-flight runtime record when dispatch claim is missing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  writeUnitRuntimeRecord(base, "execute-task", "M008/S04/T02", 1778069087937, {
+    phase: "dispatched",
+    lastProgressAt: 1778069087937,
+    lastProgressKind: "dispatch",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.unitType, "execute-task");
+  assert.equal(lock!.unitId, "M008/S04/T02");
+  assert.equal(lock!.unitStartedAt, new Date(1778069087937).toISOString());
+});
+
 test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

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

@@ -11,12 +11,14 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   detectProjectState,
   detectV1Planning,
   detectProjectSignals,
+  classifyProject,
   scanProjectFiles,
 } from "../detection.ts";
 
@@ -37,6 +39,18 @@ function cleanup(dir: string): void {
   }
 }
 
+function git(dir: string, args: string[]): void {
+  execFileSync("git", args, { cwd: dir, stdio: "ignore" });
+}
+
+function makeGitRepo(prefix: string): string {
+  const dir = makeTempDir(prefix);
+  git(dir, ["init"]);
+  git(dir, ["config", "user.email", "test@example.com"]);
+  git(dir, ["config", "user.name", "Test User"]);
+  return dir;
+}
+
 // ─── detectProjectState ─────────────────────────────────────────────────────────
 
 test("detectProjectState: empty directory returns state=none", (t) => {
@@ -49,6 +63,132 @@ test("detectProjectState: empty directory returns state=none", (t) => {
   assert.equal(result.v2, undefined);
 });
 
+test("classifyProject: no git repo is invalid", (t) => {
+  const dir = makeTempDir("classify-invalid");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "invalid-repo");
+});
+
+test("classifyProject: empty git repo is greenfield", (t) => {
+  const dir = makeGitRepo("classify-greenfield");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: nested empty git repo does not inherit ancestor markers", (t) => {
+  const parent = makeGitRepo("classify-parent-marker");
+  t.after(() => cleanup(parent));
+
+  writeFileSync(join(parent, "package.json"), JSON.stringify({ name: "parent" }), "utf-8");
+  git(parent, ["add", "package.json"]);
+  git(parent, ["commit", "-m", "add parent marker"]);
+  const child = join(parent, "nested");
+  mkdirSync(child, { recursive: true });
+  git(child, ["init"]);
+  git(child, ["config", "user.email", "test@example.com"]);
+  git(child, ["config", "user.name", "Test User"]);
+
+  const classification = classifyProject(child);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: tracked static HTML is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-index");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "index.html"), "<main></main>\n", "utf-8");
+  git(dir, ["add", "index.html"]);
+  git(dir, ["commit", "-m", "add static page"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["index.html"]);
+});
+
+test("classifyProject: README-only repo is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-readme");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "README.md"), "# docs\n", "utf-8");
+  git(dir, ["add", "README.md"]);
+  git(dir, ["commit", "-m", "add docs"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+});
+
+test("classifyProject: src-only content is untyped existing, not typed marker", (t) => {
+  const dir = makeGitRepo("classify-src-only");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "src"), { recursive: true });
+  writeFileSync(join(dir, "src", "index.txt"), "content\n", "utf-8");
+  git(dir, ["add", "src/index.txt"]);
+  git(dir, ["commit", "-m", "add source content"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["src/index.txt"]);
+});
+
+test("classifyProject: nested untracked files count as project content", (t) => {
+  const dir = makeGitRepo("classify-untracked-nested");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "docs"), { recursive: true });
+  writeFileSync(join(dir, "docs", "index.html"), "<main></main>\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.untrackedFiles, ["docs/index.html"]);
+});
+
+test("classifyProject: known markers produce typed existing project", (t) => {
+  const dir = makeGitRepo("classify-typed");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "typed" }), "utf-8");
+  git(dir, ["add", "package.json"]);
+  git(dir, ["commit", "-m", "add package"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "typed-existing");
+  assert.ok(classification.markers.includes("package.json"));
+});
+
+test("classifyProject: ignored build/cache-only files do not count as content", (t) => {
+  const dir = makeGitRepo("classify-ignored");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, ".gitignore"), "dist/\n.cache/\n", "utf-8");
+  git(dir, ["add", ".gitignore"]);
+  git(dir, ["commit", "-m", "ignore generated files"]);
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "dist", "bundle.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".cache"), { recursive: true });
+  writeFileSync(join(dir, ".cache", "x"), "cache\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: generated framework/cache dirs do not count as content", (t) => {
+  const dir = makeGitRepo("classify-generated-dirs");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, ".next", "server"), { recursive: true });
+  writeFileSync(join(dir, ".next", "server", "page.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".venv", "lib"), { recursive: true });
+  writeFileSync(join(dir, ".venv", "lib", "site.py"), "generated\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
 test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", (t) => {
   const dir = makeTempDir("v2-gsd");
   t.after(() => cleanup(dir));

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

@@ -172,6 +172,56 @@ test('handlePlanSlice rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanSlice rejects absolute task IO paths outside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const outside = join(tmpdir(), 'outside-checkout', 'index.html');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: [outside],
+          expectedOutput: [outside],
+        },
+      ],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: tasks\[0\]\.inputs contains absolute path outside working directory/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid planning IO must not persist tasks');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice accepts absolute task IO paths inside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const inside = join(base, 'index.html');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: [inside],
+          expectedOutput: [inside],
+        },
+      ],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

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

@@ -79,6 +79,27 @@ test('handlePlanTask rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanTask rejects absolute task IO paths outside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const outside = join(tmpdir(), 'outside-checkout', 'index.html');
+    const result = await handlePlanTask({
+      ...validParams(),
+      inputs: [outside],
+      expectedOutput: [outside],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: inputs contains absolute path outside working directory/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid planning IO must not persist the task');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

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 });
+  }
+});