gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

package/src/resources/extensions/gsd/tests/stuck-state-via-db.test.ts

@@ -19,13 +19,17 @@ import {
   closeDatabase,
   insertMilestone,
 } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { registerAutoWorker, markWorkerCrashed } from "../db/auto-workers.ts";
 import { claimMilestoneLease } from "../db/milestone-leases.ts";
 import {
   recordDispatchClaim,
+  markFailed,
+  markCanceled,
   getRecentUnitKeysForWorker,
+  getRecentUnitKeysForProjectRoot,
 } from "../db/unit-dispatches.ts";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
+import { detectStuck } from "../auto/detect-stuck.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-stuck-state-db-"));
@@ -67,6 +71,65 @@ test("getRecentUnitKeysForWorker reconstructs the recentUnits sliding window", (
   assert.deepEqual(window.map(w => w.key), ["U1", "U2", "U3"]);
 });
 
+test("getRecentUnitKeysForProjectRoot restores compound keys used by stuck detection", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  insertMilestone({ id: "M002", title: "Crashed", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  for (let i = 0; i < 2; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `t${i}`,
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      sliceId: "S01",
+      unitType: "complete-slice",
+      unitId: "M001/S01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markCanceled(claim.dispatchId, "pause");
+  }
+
+  const crashedWorker = registerAutoWorker({ projectRootRealpath: base });
+  const crashedLease = claimMilestoneLease(crashedWorker, "M002");
+  assert.equal(crashedLease.ok, true);
+  if (!crashedLease.ok) return;
+
+  for (let i = 0; i < 3; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `crashed-${i}`,
+      workerId: crashedWorker,
+      milestoneLeaseToken: crashedLease.token,
+      milestoneId: "M002",
+      sliceId: "S01",
+      taskId: "T01",
+      unitType: "execute-task",
+      unitId: "M002/S01/T01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "worker crashed" });
+  }
+  markWorkerCrashed(crashedWorker);
+
+  const window = getRecentUnitKeysForProjectRoot(base, 3);
+  assert.deepEqual(window.map(w => w.key), [
+    "complete-slice/M001/S01",
+    "complete-slice/M001/S01",
+  ]);
+
+  const result = detectStuck([...window, { key: "complete-slice/M001/S01" }]);
+  assert.equal(result?.stuck, true);
+  assert.match(result?.reason ?? "", /3 consecutive times/);
+});
+
 test("getRecentUnitKeysForWorker honors the limit parameter", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -91,8 +91,9 @@ test("buildReactiveExecutePrompt injects subagent model when provided", async (t
   );
 
   assert.match(prompt, /model: "claude-opus-4-6"/);
-  assert.match(prompt, /Context Mode \(execution lane\):/);
+  assert.match(prompt, /Lane: \*\*execution lane\*\*\./);
   assert.match(prompt, /## Context Mode/);
+  assert.doesNotMatch(prompt, /You are executing GSD auto-mode\./);
 });
 
 test("buildReactiveExecutePrompt omits model instruction when subagentModel is omitted", async (t) => {

package/src/resources/extensions/gsd/tests/summary-render-parity.test.ts

@@ -175,13 +175,17 @@ const verificationEvidence = [
   );
 }
 
-// Test 11: empty key_files renders YAML placeholder, not empty array
+// Test 11: empty key_files renders an empty YAML list, not a sentinel path
 {
   const noFiles = { ...taskRow, key_files: [] };
   const output = renderSummaryContent(noFiles, SLICE_ID, MILESTONE_ID);
   assertTrue(
-    output.includes("key_files:\n  - (none)"),
-    "empty key_files must render as YAML list with (none) placeholder",
+    output.includes("key_files: []"),
+    "empty key_files must render as an empty YAML list",
+  );
+  assertTrue(
+    !output.includes("key_files:\n  - (none)"),
+    "empty key_files must not render (none) as a path-like list item",
   );
 }
 

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -153,6 +153,7 @@ const laneLabelByMode: Record<string, string> = {
   verification: "verification",
   orchestration: "orchestration",
   docs: "documentation",
+  triage: "triage",
 };
 
 test("Context Mode composer: every known eligible unit renders its configured lane and required tools", () => {

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -7,13 +7,17 @@ import {
   ARTIFACT_KEYS,
   KNOWN_UNIT_TYPES,
   UNIT_MANIFESTS,
+  resolveSubagentPermissionContract,
   resolveManifest,
   type ArtifactKey,
   type ContextModePolicy,
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
-import { ALLOWED_PLANNING_DISPATCH_AGENTS } from "../bootstrap/write-gate.ts";
+import {
+  ALLOWED_PLANNING_DISPATCH_AGENTS,
+  shouldBlockPlanningUnit,
+} from "../bootstrap/write-gate.ts";
 import {
   getRequiredWorkflowToolsForAutoUnit,
   getRequiredWorkflowToolsForGuidedUnit,
@@ -106,8 +110,10 @@ test("Context Mode: every manifest declares the expected contextMode lane", () =
     "reassess-roadmap": "planning",
     "execute-task": "execution",
     "reactive-execute": "execution",
+    "quick-task": "execution",
     "run-uat": "verification",
     "gate-evaluate": "verification",
+    "triage-captures": "triage",
     "validate-milestone": "verification",
     "complete-slice": "verification",
     "complete-milestone": "verification",
@@ -216,7 +222,7 @@ test("#4934: every manifest declares a tools policy", () => {
 });
 
 test("#4934: tools.mode is one of the declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs"]);
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -226,32 +232,130 @@ test("#4934: tools.mode is one of the declared policies", () => {
   }
 });
 
-test('#4934: only execute-task and reactive-execute may use tools.mode "all" (full source-tree write access)', () => {
-  const allowedAllUnits = new Set(["execute-task", "reactive-execute"]);
+test('#4934: only execution units, quick-task, and closeout units may use tools.mode "all"', () => {
+  const allowedAllUnits = new Set([
+    "execute-task",
+    "reactive-execute",
+    "quick-task",
+    "validate-milestone",
+    "complete-milestone",
+    "complete-slice",
+  ]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     if (mode === "all") {
       assert.ok(
         allowedAllUnits.has(unitType),
-        `manifest "${unitType}" declares tools.mode = "all" but is not on the execute-track. ` +
-        'Only execute-task and reactive-execute should have full source write access; ' +
+        `manifest "${unitType}" declares tools.mode = "all" but is not explicitly allowed. ` +
+        'Only execute-task/reactive-execute, quick-task, and closeout units should have full source write access; ' +
         'planning/discuss/research units must use "planning" or "planning-dispatch" (or "docs" for rewrite-docs).',
       );
     }
   }
 });
 
+test("#5453: complete-milestone uses all tools so bash verification is not planning-dispatch blocked", () => {
+  const manifest = UNIT_MANIFESTS["complete-milestone"];
+
+  assert.strictEqual(manifest.tools.mode, "all");
+  assert.deepEqual(resolveSubagentPermissionContract("complete-milestone"), {
+    allowed: true,
+    allowedSubagents: ["*"],
+    toolsMode: "all",
+  });
+  // Runtime gate-level regression: these verification commands were blocked
+  // under planning-dispatch in #5453; complete-milestone must bypass that gate.
+  for (const cmd of ["git diff --name-only HEAD~1", "git log -n1 --oneline"]) {
+    const result = shouldBlockPlanningUnit(
+      "bash",
+      cmd,
+      process.cwd(),
+      "complete-milestone",
+      manifest.tools,
+    );
+    assert.strictEqual(
+      result.block,
+      false,
+      `shouldBlockPlanningUnit must not block ${cmd} for complete-milestone: ${result.reason}`,
+    );
+  }
+});
+
+test("#5731: validate-milestone and complete-slice use all tools so closeout verification is not planning-dispatch blocked", () => {
+  for (const unitType of ["validate-milestone", "complete-slice"] as const) {
+    const manifest = UNIT_MANIFESTS[unitType];
+    assert.strictEqual(manifest.tools.mode, "all");
+    const result = shouldBlockPlanningUnit(
+      "bash",
+      "go test -short -count=1 ./...",
+      process.cwd(),
+      unitType,
+      manifest.tools,
+    );
+    assert.strictEqual(
+      result.block,
+      false,
+      `${unitType} must allow verification bash commands: ${result.reason}`,
+    );
+  }
+});
+
+test("#5843: run-uat uses verification tools policy so build/test commands can run", () => {
+  const manifest = UNIT_MANIFESTS["run-uat"];
+
+  assert.strictEqual(manifest.tools.mode, "verification");
+
+  const buildResult = shouldBlockPlanningUnit(
+    "bash",
+    "npm run build 2>&1",
+    process.cwd(),
+    "run-uat",
+    manifest.tools,
+  );
+  assert.strictEqual(
+    buildResult.block,
+    false,
+    `run-uat must allow build verification commands: ${buildResult.reason}`,
+  );
+
+  const sourceWriteResult = shouldBlockPlanningUnit(
+    "edit",
+    "src/main.ts",
+    process.cwd(),
+    "run-uat",
+    manifest.tools,
+  );
+  assert.strictEqual(sourceWriteResult.block, true);
+  assert.match(sourceWriteResult.reason!, /tools-policy "verification"/);
+});
+
+test("planning-dispatch hard block message omits internal tracker references", () => {
+  const manifest = UNIT_MANIFESTS["plan-slice"];
+  assert.strictEqual(manifest.tools.mode, "planning-dispatch");
+
+  const result = shouldBlockPlanningUnit(
+    "task",
+    "scout",
+    process.cwd(),
+    "plan-slice",
+    manifest.tools,
+  );
+
+  assert.strictEqual(result.block, true);
+  assert.ok(result.reason, "blocked dispatch should include a user-facing reason");
+  assert.doesNotMatch(result.reason!, /#[0-9]{3,}/);
+});
+
 test('planning-dispatch mode is reserved for slice-level decomposition and completion units', () => {
   const allowedDispatchUnits = new Set([
     "plan-slice",
+    "research-slice",
     "refine-slice",
-    "complete-slice",
-    "complete-milestone",
+    "gate-evaluate",
     // Deep planning mode: research-project orchestrates 4 parallel research
     // subagents (stack/features/architecture/pitfalls). Subagent dispatch is
     // the unit's core mechanism — without it, the unit cannot do its job.
     "research-project",
-    "validate-milestone",
   ]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
@@ -265,6 +369,24 @@ test('planning-dispatch mode is reserved for slice-level decomposition and compl
   }
 });
 
+test('Unit Tool Contract exposes subagent dispatch permissions', () => {
+  assert.deepEqual(resolveSubagentPermissionContract("plan-slice"), {
+    allowed: true,
+    allowedSubagents: ["scout", "planner"],
+    toolsMode: "planning-dispatch",
+  });
+  assert.deepEqual(resolveSubagentPermissionContract("gate-evaluate"), {
+    allowed: true,
+    allowedSubagents: ["reviewer", "security", "tester"],
+    toolsMode: "planning-dispatch",
+  });
+  assert.deepEqual(resolveSubagentPermissionContract("discuss-milestone"), {
+    allowed: false,
+    allowedSubagents: [],
+    toolsMode: "planning",
+  });
+});
+
 test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     if (manifest.tools.mode !== "planning-dispatch") continue;

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
@@ -12,6 +12,10 @@ function run(cmd: string, cwd: string): string {
 
 function makeRepo(): string {
   const repo = mkdtempSync(join(tmpdir(), "gsd-uok-gitops-"));
+  return initRepo(repo);
+}
+
+function initRepo(repo: string): string {
   run("git init", repo);
   run('git config user.email "test@example.com"', repo);
   run('git config user.name "Test User"', repo);
@@ -32,6 +36,7 @@ test("uok gitops turn action status-only reports working tree dirtiness", () =>
     });
     assert.equal(clean.status, "ok");
     assert.equal(clean.dirty, false);
+    assert.deepEqual(clean.dirtyRepositories, { project: false });
 
     writeFileSync(join(repo, "README.md"), "# Dirty\n", "utf-8");
     const dirty = runTurnGitAction({
@@ -42,11 +47,57 @@ test("uok gitops turn action status-only reports working tree dirtiness", () =>
     });
     assert.equal(dirty.status, "ok");
     assert.equal(dirty.dirty, true);
+    assert.deepEqual(dirty.dirtyRepositories, { project: true });
   } finally {
     rmSync(repo, { recursive: true, force: true });
   }
 });
 
+test("uok gitops turn action status-only reports per-repository dirtiness in parent mode", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-uok-gitops-parent-"));
+  try {
+    initRepo(root);
+    mkdirSync(join(root, ".gsd"), { recursive: true });
+    mkdirSync(join(root, "frontend"), { recursive: true });
+    mkdirSync(join(root, "backend"), { recursive: true });
+    initRepo(join(root, "frontend"));
+    initRepo(join(root, "backend"));
+    writeFileSync(join(root, ".gitignore"), "frontend/\nbackend/\n", "utf-8");
+    run("git add .gitignore", root);
+    run('git commit -m "chore: ignore nested repos"', root);
+    writeFileSync(join(root, ".gsd", "PREFERENCES.md"), `---
+version: 1
+workspace:
+  mode: parent
+  repositories:
+    frontend:
+      path: frontend
+    backend:
+      path: backend
+---
+`, "utf-8");
+    run("git add .gsd/PREFERENCES.md", root);
+    run('git commit -m "chore: configure parent workspace repos"', root);
+
+    writeFileSync(join(root, "frontend", "README.md"), "# Dirty frontend\n", "utf-8");
+
+    const result = runTurnGitAction({
+      basePath: root,
+      action: "status-only",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+
+    assert.equal(result.status, "ok");
+    assert.equal(result.dirty, true);
+    assert.equal(result.dirtyRepositories?.project, false);
+    assert.equal(result.dirtyRepositories?.frontend, true);
+    assert.equal(result.dirtyRepositories?.backend, false);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("uok gitops turn action snapshot writes snapshot refs", () => {
   const repo = makeRepo();
   try {
@@ -84,6 +135,55 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
   }
 });
 
+test("uok gitops turn action commit honors per-repo commit_policy skip", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-uok-gitops-commit-policy-"));
+  try {
+    initRepo(root);
+    mkdirSync(join(root, ".gsd"), { recursive: true });
+    mkdirSync(join(root, "frontend"), { recursive: true });
+    mkdirSync(join(root, "backend"), { recursive: true });
+    initRepo(join(root, "frontend"));
+    initRepo(join(root, "backend"));
+    writeFileSync(join(root, ".gitignore"), "frontend/\nbackend/\n", "utf-8");
+    run("git add .gitignore", root);
+    run('git commit -m "chore: ignore nested repos"', root);
+    writeFileSync(join(root, ".gsd", "PREFERENCES.md"), `---
+version: 1
+workspace:
+  mode: parent
+  repositories:
+    frontend:
+      path: frontend
+      commit_policy: skip
+    backend:
+      path: backend
+---
+`, "utf-8");
+    run("git add .gsd/PREFERENCES.md", root);
+    run('git commit -m "chore: configure commit policies"', root);
+
+    writeFileSync(join(root, "frontend", "README.md"), "# frontend dirty\n", "utf-8");
+    writeFileSync(join(root, "backend", "README.md"), "# backend dirty\n", "utf-8");
+
+    const result = runTurnGitAction({
+      basePath: root,
+      action: "commit",
+      unitType: "execute-task",
+      unitId: "M001/S01/T03",
+      targetRepositories: ["frontend", "backend"],
+    });
+
+    assert.equal(result.status, "ok");
+    assert.deepEqual(result.skippedRepositories, ["frontend"]);
+    assert.equal(typeof result.commitMessages?.backend, "string");
+    assert.equal(result.commitMessages?.frontend, undefined);
+    assert.equal(run("git status --porcelain", join(root, "frontend")).length > 0, true);
+    assert.equal(run("git status --porcelain", join(root, "backend")), "");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("uok gitops turn action rethrows infrastructure failures", () => {
   const err = Object.assign(new Error("ENFILE: file table overflow"), { code: "ENFILE" });
 
@@ -97,3 +197,13 @@ test("uok gitops turn action keeps non-infrastructure git failures recoverable",
   assert.equal(result.status, "failed");
   assert.equal(result.error, "nothing to commit");
 });
+
+test("uok gitops turn action prefers stderr details for git failures", () => {
+  const err = Object.assign(new Error("Command failed: git commit -F -"), {
+    stderr: "fatal: unable to auto-detect email address",
+  });
+
+  const result = handleTurnGitActionError("commit", err);
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "fatal: unable to auto-detect email address");
+});

package/src/resources/extensions/gsd/tests/validate-milestone-stuck-guard.test.ts

@@ -162,7 +162,7 @@ describe("validate-milestone stuck-loop guard (#4094)", () => {
     assert.equal(pauseAutoMock.mock.callCount(), 0);
   });
 
-  test("continues when no VALIDATION file exists yet", async () => {
+  test("retries when no VALIDATION file exists yet", async () => {
     insertMilestone({ id: "M001" });
     insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
 
@@ -173,7 +173,34 @@ describe("validate-milestone stuck-loop guard (#4094)", () => {
 
     const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
 
-    assert.equal(result, "continue");
+    assert.equal(result, "retry");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.ok(s.pendingVerificationRetry);
+    assert.equal(s.pendingVerificationRetry!.unitId, "M001");
+    assert.match(s.pendingVerificationRetry!.failureContext, /gsd_validate_milestone/);
+    assert.equal(s.pendingVerificationRetry!.attempt, 1);
+  });
+
+  test("retries when VALIDATION file exists but is empty", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+
+    const path = join(tempDir, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    writeFileSync(path, "", "utf-8");
+    invalidateAllCaches();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "retry");
     assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.ok(s.pendingVerificationRetry);
+    assert.equal(s.pendingVerificationRetry!.unitId, "M001");
+    assert.match(s.pendingVerificationRetry!.failureContext, /exists but is empty/);
+    assert.equal(s.pendingVerificationRetry!.attempt, 1);
   });
 });

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -150,4 +150,72 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.equal(row?.trace_id, "trace-val-1");
     assert.equal(row?.turn_id, "turn-val-1");
   });
+
+  it("rejects verificationClasses that omit planned Operational class", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        verificationOperational: "Camoufox subprocess lifecycle/cleanup proof",
+      },
+    });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const result = await handleValidateMilestone(
+      { ...VALID_PARAMS, verificationClasses: "| Check | Result |\n| --- | --- |\n| Generic verification | PASS |" },
+      base,
+    );
+    assert.ok("error" in result, "expected validation to fail");
+    assert.match(result.error, /must include canonical row "Operational"/);
+
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT status FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string } | undefined;
+    assert.equal(row, undefined, "assessment row should not be written when verification classes are invalid");
+  });
+
+  it("accepts verificationClasses when planned Operational class is present", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        verificationOperational: "Camoufox subprocess lifecycle/cleanup proof",
+      },
+    });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const result = await handleValidateMilestone(
+      {
+        ...VALID_PARAMS,
+        verificationClasses:
+          "| Class | Planned Check | Evidence | Verdict |\n| --- | --- | --- | --- |\n| Operational | Camoufox subprocess lifecycle/cleanup proof | S01 + process-death evidence | NEEDS-ATTENTION |",
+      },
+      base,
+    );
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+  });
+
+  it("treats 'not required - ...' verification values as not applicable", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        verificationOperational: "not required - backend-only",
+      },
+    });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const result = await handleValidateMilestone(
+      { ...VALID_PARAMS, verificationClasses: "| Check | Result |\n| --- | --- |\n| Generic verification | PASS |" },
+      base,
+    );
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+  });
 });

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

@@ -13,7 +13,7 @@ import { buildCompleteMilestonePrompt, buildValidateMilestonePrompt } from "../a
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
-import { closeDatabase, insertMilestone, insertSlice, openDatabase, getMilestone } from "../gsd-db.ts";
+import { closeDatabase, insertAssessment, insertMilestone, insertSlice, openDatabase, getMilestone } from "../gsd-db.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -205,6 +205,47 @@ test("deriveState returns blocked when needs-remediation has no incomplete slice
   }
 });
 
+test("deriveState parks milestone when validation verdict is needs-attention and no summary (#6136)", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds attention.");
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "pre-planning");
+    assert.equal(state.activeMilestone, null);
+    assert.equal(state.registry.find(entry => entry.id === "M001")?.status, "parked");
+    assert.ok(state.nextAction.includes("parked"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState parks DB-backed milestone when validation verdict is needs-attention (#6136)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [] });
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    insertAssessment({
+      path: join(".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      milestoneId: "M001",
+      status: "needs-attention",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds attention.",
+    });
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "pre-planning");
+    assert.equal(state.activeMilestone, null);
+    assert.equal(state.registry.find(entry => entry.id === "M001")?.status, "parked");
+    assert.ok(state.nextAction.includes("parked"));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("deriveState returns complete when both VALIDATION and SUMMARY exist", async () => {
   const base = makeTmpBase();
   try {