gsd-pi 2.82.0-dev.3709f22a5 → 2.82.0-dev.4285182e8

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -0,0 +1,378 @@
+/**
+ * Tests for /gsd verdict — manual override of milestone validation verdict.
+ *
+ * Covers parseValidationFile section extraction and handleVerdict end-to-end:
+ * pass override, needs-remediation override with rationale, missing rationale
+ * rejection, active-milestone fallback, missing VALIDATION rejection.
+ *
+ * Also asserts the three paused-state messages reference /gsd verdict so the
+ * user has a discoverable recovery path.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { handleVerdict, parseValidationFile } from "../commands-verdict.ts";
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
+
+interface NotifyCall {
+  message: string;
+  kind: string;
+}
+
+function makeMockCtx(): { ctx: any; calls: NotifyCall[] } {
+  const calls: NotifyCall[] = [];
+  const ctx = {
+    ui: {
+      notify: (message: string, kind: string) => {
+        calls.push({ message, kind });
+      },
+    },
+  };
+  return { ctx, calls };
+}
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-verdict-${randomUUID()}-`));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* swallow */ }
+}
+
+function openTestDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+function seedMilestone(milestoneId: string, title: string, status = "active"): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)",
+  ).run(milestoneId, title, status, new Date().toISOString());
+}
+
+function seedSlice(milestoneId: string, sliceId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO slices (milestone_id, id, title, status, created_at) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, `Slice ${sliceId}`, status, new Date().toISOString());
+}
+
+function writeValidation(base: string, milestoneId: string, verdict: string, round = 0): string {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(milestoneDir, { recursive: true });
+  const path = join(milestoneDir, `${milestoneId}-VALIDATION.md`);
+  const md = [
+    "---",
+    `verdict: ${verdict}`,
+    `remediation_round: ${round}`,
+    "---",
+    "",
+    `# Milestone Validation: ${milestoneId}`,
+    "",
+    "## Success Criteria Checklist",
+    "- [x] Criterion A met",
+    "- [x] Criterion B met",
+    "",
+    "## Slice Delivery Audit",
+    "| Slice | Result |",
+    "| --- | --- |",
+    "| S01 | delivered |",
+    "",
+    "## Cross-Slice Integration",
+    "No cross-slice mismatches detected.",
+    "",
+    "## Requirement Coverage",
+    "All requirements covered.",
+    "",
+    "## Verdict Rationale",
+    `Initial verdict was ${verdict}.`,
+    "",
+  ].join("\n");
+  writeFileSync(path, md);
+  return path;
+}
+
+// ─── parseValidationFile ────────────────────────────────────────────────
+
+test("parseValidationFile extracts all standard sections and frontmatter", () => {
+  const md = [
+    "---",
+    "verdict: needs-attention",
+    "remediation_round: 2",
+    "---",
+    "",
+    "# Milestone Validation: M001",
+    "",
+    "## Success Criteria Checklist",
+    "- [x] First",
+    "- [ ] Second",
+    "",
+    "## Slice Delivery Audit",
+    "| Slice | Delivered |",
+    "",
+    "## Cross-Slice Integration",
+    "Boundary intact.",
+    "",
+    "## Requirement Coverage",
+    "R001 covered.",
+    "",
+    "## Verification Class Compliance",
+    "Operational: MET",
+    "",
+    "## Verdict Rationale",
+    "Acceptance proof incomplete.",
+    "",
+    "## Remediation Plan",
+    "Address acceptance proof.",
+    "",
+  ].join("\n");
+
+  const parsed = parseValidationFile(md);
+
+  assert.equal(parsed.verdict, "needs-attention");
+  assert.equal(parsed.remediationRound, 2);
+  assert.match(parsed.successCriteriaChecklist, /First/);
+  assert.match(parsed.successCriteriaChecklist, /Second/);
+  assert.match(parsed.sliceDeliveryAudit, /Delivered/);
+  assert.match(parsed.crossSliceIntegration, /Boundary intact/);
+  assert.match(parsed.requirementCoverage, /R001 covered/);
+  assert.match(parsed.verificationClasses ?? "", /Operational: MET/);
+  assert.match(parsed.verdictRationale, /Acceptance proof incomplete/);
+  assert.match(parsed.remediationPlan ?? "", /Address acceptance proof/);
+});
+
+test("parseValidationFile omits optional sections when absent", () => {
+  const md = [
+    "---",
+    "verdict: pass",
+    "remediation_round: 0",
+    "---",
+    "",
+    "## Success Criteria Checklist",
+    "- [x] All met",
+    "",
+    "## Slice Delivery Audit",
+    "Done.",
+    "",
+    "## Cross-Slice Integration",
+    "Clean.",
+    "",
+    "## Requirement Coverage",
+    "Complete.",
+    "",
+    "## Verdict Rationale",
+    "All criteria met.",
+  ].join("\n");
+
+  const parsed = parseValidationFile(md);
+
+  assert.equal(parsed.verdict, "pass");
+  assert.equal(parsed.remediationRound, 0);
+  assert.equal(parsed.verificationClasses, undefined);
+  assert.equal(parsed.remediationPlan, undefined);
+});
+
+// ─── handleVerdict — argument validation ────────────────────────────────
+
+test("handleVerdict rejects missing verdict", async () => {
+  const { ctx, calls } = makeMockCtx();
+  await handleVerdict("", ctx, "/tmp/unused");
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /Usage: \/gsd verdict/);
+  assert.equal(calls[0].kind, "warning");
+});
+
+test("handleVerdict rejects invalid verdict", async () => {
+  const { ctx, calls } = makeMockCtx();
+  await handleVerdict("yolo", ctx, "/tmp/unused");
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /Invalid verdict "yolo"/);
+  assert.equal(calls[0].kind, "warning");
+});
+
+test("handleVerdict rejects needs-remediation without --rationale", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    writeValidation(base, "M001", "pass");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("needs-remediation --milestone M001", ctx, base);
+
+    assert.ok(
+      calls.some((c) => /--rationale is required/.test(c.message)),
+      `expected rationale-required warning, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict rejects when VALIDATION file is missing", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    assert.ok(
+      calls.some((c) => /No VALIDATION file found/.test(c.message)),
+      `expected missing-VALIDATION warning, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+// ─── handleVerdict — pass override flow ─────────────────────────────────
+
+test("handleVerdict pass override flips verdict and preserves sections", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    const validationPath = writeValidation(base, "M001", "needs-attention");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: pass$/m, "verdict should flip to pass");
+    assert.match(rewritten, /Criterion A met/, "success criteria preserved");
+    assert.match(rewritten, /S01 \| delivered/, "slice audit preserved");
+    assert.match(rewritten, /Manually overridden via \/gsd verdict/, "default rationale applied");
+
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /needs-attention.*->.*pass/.test(c.message)),
+      `expected success notification, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict needs-remediation override with --rationale rewrites verdict", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    const validationPath = writeValidation(base, "M001", "pass");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict(
+      'needs-remediation --milestone M001 --rationale "found missing slice"',
+      ctx,
+      base,
+    );
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: needs-remediation$/m);
+    assert.match(rewritten, /found missing slice/);
+
+    assert.ok(
+      calls.some((c) => /gsd_reassess_roadmap/.test(c.message)),
+      "needs-remediation override should suggest gsd_reassess_roadmap follow-up",
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict resolves active milestone when --milestone omitted", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M042", "Active Milestone");
+    seedSlice("M042", "S01", "complete");
+    const validationPath = writeValidation(base, "M042", "needs-attention");
+
+    const { ctx, calls } = makeMockCtx();
+    invalidateStateCache();
+    await handleVerdict("pass", ctx, base);
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: pass$/m);
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /M042/.test(c.message)),
+      `expected success notification naming M042, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+// ─── Pause messages reference /gsd verdict ─────────────────────────────
+
+test("auto-dispatch needs-attention pause message references /gsd verdict", async () => {
+  const { DISPATCH_RULES } = await import("../auto-dispatch.ts");
+  const rule = DISPATCH_RULES.find((r) => r.name === "completing-milestone → complete-milestone");
+  assert.ok(rule, "completing-milestone rule should exist");
+
+  const base = mkdtempSync(join(tmpdir(), "gsd-verdict-paused-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds work.\n",
+    );
+
+    const result = await rule!.match({
+      mid: "M001",
+      midTitle: "Test",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    } as any);
+
+    assert.ok(result !== null);
+    assert.equal(result!.action, "stop");
+    if (result!.action === "stop") {
+      assert.match(result!.reason, /\/gsd verdict/);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("state.ts needs-remediation blocker messages reference /gsd verdict", async () => {
+  // We don't need to invoke deriveState — just assert the substring is in the
+  // source. The blocker strings are constructed inline and shipped to the user
+  // verbatim, so a static check is sufficient and avoids fragile DB setup.
+  const stateSource = readFileSync(
+    new URL("../state.ts", import.meta.url).pathname,
+    "utf-8",
+  );
+  const occurrences = stateSource.match(/`\/gsd verdict /g) ?? [];
+  assert.ok(
+    occurrences.length >= 2,
+    `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
+  );
+});

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

@@ -225,6 +225,25 @@ test("clearLock removes the session_file row for the active worker", (t) => {
     "session_file row deleted by clearLock");
 });
 
+test("clearLock marks stale worker crashed when no current-process worker matches", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  setRuntimeKv("worker", workerId, "session_file", "/tmp/stale-session.jsonl");
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+  assert.ok(readCrashLock(base), "stale worker is detected before clearLock");
+
+  clearLock(base);
+
+  assert.equal(getAutoWorker(workerId)?.status, "crashed");
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), null);
+  assert.equal(readCrashLock(base), null);
+});
+
 test("clearStaleWorkerLock crashes stale worker and cancels latest active dispatch", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
@@ -264,3 +283,27 @@ test("clearStaleWorkerLock crashes stale worker and cancels latest active dispat
   assert.equal(getRuntimeKv("worker", workerId, "session_file"), null);
   assert.equal(readCrashLock(base), null);
 });
+
+test("clearLock marks stale worker crashed and releases held milestone lease", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+  assert.ok(readCrashLock(base), "stale worker is detected before clearLock");
+
+  clearLock(base);
+
+  assert.equal(getAutoWorker(workerId)?.status, "crashed");
+  const leaseRow = _getAdapter()!.prepare(
+    `SELECT status FROM milestone_leases WHERE milestone_id = :m`,
+  ).get({ ":m": "M001" }) as { status: string } | undefined;
+  assert.equal(leaseRow?.status, "released");
+});

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -98,6 +98,8 @@ function makeMockPi() {
     sendMessage: (...args: unknown[]) => {
       calls.push(args);
     },
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
     calls,
   } as any;
 }

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -10,6 +10,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
 
 import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
 import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
@@ -23,6 +24,14 @@ function makeBase(): string {
   return base;
 }
 
+function initGitRepo(base: string): void {
+  execFileSync("git", ["init"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base, stdio: "ignore" });
+}
+
 function buildDispatchCtx(basePath: string): DispatchContext {
   return {
     basePath,
@@ -76,6 +85,24 @@ describe("completing-milestone dispatch guard (#4324)", () => {
     assert.equal(result?.unitType, "complete-milestone");
     assert.equal(result?.unitId, "M001");
   });
+
+  test("dispatches complete-milestone when only .gsd/ files exist in git history (#5097)", async () => {
+    base = makeBase();
+    rmSync(join(base, "implementation.txt"), { force: true });
+    initGitRepo(base);
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: planning artifacts only"], { cwd: base, stdio: "ignore" });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const result = await rule.match(buildDispatchCtx(base));
+
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
+  });
 });
 
 describe("complete phase dispatch guard (#5683)", () => {

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

@@ -37,6 +37,7 @@ import {
   checkpointDatabase,
   refreshOpenDatabaseFromDisk,
   tryCreateMemoriesFts,
+  _isLikelyWslDrvFsPathForTest,
 } from '../gsd-db.ts';
 import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
 
@@ -345,6 +346,16 @@ describe('gsd-db', () => {
     });
   });
 
+  test('gsd-db: detects WSL DrvFs mount paths for conservative pragmas', () => {
+    withPlatform('linux', () => {
+      assert.equal(_isLikelyWslDrvFsPathForTest('/mnt/d/code/project/.gsd/gsd.db'), true);
+      assert.equal(_isLikelyWslDrvFsPathForTest('/tmp/gsd.db'), false);
+    });
+    withPlatform('darwin', () => {
+      assert.equal(_isLikelyWslDrvFsPathForTest('/mnt/d/code/project/.gsd/gsd.db'), false);
+    });
+  });
+
   test('gsd-db: transaction rollback on error', () => {
     openDatabase(':memory:');
 

package/src/resources/extensions/gsd/tests/gsdroot-worktree-detection.test.ts

@@ -3,7 +3,7 @@
  *
  * gsdRoot() must return the canonical project .gsd directory when basePath
  * is inside a .gsd/worktrees/<name>/ structure. Worktree-local .gsd folders
- * are legacy projection roots only; runtime state is DB-authoritative at the
+ * are projection roots; runtime/control state stays DB-authoritative at the
  * project .gsd.
  *
  * The bug: when a git worktree lives at /project/.gsd/worktrees/M008/,
@@ -21,7 +21,7 @@ import { mkdtempSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 
-import { gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
+import { gsdProjectionRoot, gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
 
 describe("gsdRoot() worktree detection (#2594)", () => {
   let projectRoot: string;
@@ -76,6 +76,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
     assert.equal(resolveGsdPathContract(worktreeBase).worktreeGsd, worktreeGsd);
+    assert.equal(gsdProjectionRoot(worktreeBase), worktreeGsd);
   });
 
   test("returns project .gsd when worktree .gsd does not exist yet", () => {
@@ -89,6 +90,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       projectGsd,
       `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
+    assert.equal(gsdProjectionRoot(worktreeBase), join(worktreeBase, ".gsd"));
   });
 
   test("returns project .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
@@ -116,6 +118,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       projectGsd,
       `Expected canonical project .gsd (${projectGsd}), got ${gsdResult}`,
     );
+    assert.equal(gsdProjectionRoot(worktreeBase), join(worktreeBase, ".gsd"));
 
     // Cleanup worktree
     spawnSync("git", ["worktree", "remove", "--force", worktreeBase], {

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -1168,6 +1168,15 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: rejects milestone branches', () => {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "milestone/M001");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "milestone branches are not recorded as integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: still records legitimate branches ────────
 
   test('Integration branch: records non-ephemeral gsd branches', () => {

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

@@ -22,6 +22,7 @@ import type { IterationContext, LoopState, PreDispatchData, IterationData } from
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
+import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
   closeDatabase,
   insertMilestone,
@@ -160,6 +161,8 @@ function makeIC(
     pi: {
       sendMessage: () => {},
       setModel: async () => true,
+      getThinkingLevel: () => "off",
+      setThinkingLevel: () => {},
     } as any,
     s: makeSession(),
     deps,
@@ -868,6 +871,49 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
   assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01"), 2);
 });
 
+test("runUnitPhase pre-dispatch model validation failures do not emit unit-start or dispatch runtime state", async (t) => {
+  const capture = createEventCapture();
+  const base = mkdtempSync(join(tmpdir(), `gsd-pre-dispatch-block-${randomUUID()}`));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const deps = makeMockDeps(capture, {
+    selectAndApplyModel: async () => {
+      throw new ModelPolicyDispatchBlockedError("execute-task", "M001/S01/T01", []);
+    },
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+    } as any,
+  });
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    prompt: "do stuff",
+    finalPrompt: "do stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+
+  const startEvents = capture.events.filter(e => e.eventType === "unit-start");
+  assert.equal(startEvents.length, 0, "pre-dispatch validation failures must not emit unit-start");
+  assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01") ?? 0, 0, "dispatch count must not increment on pre-dispatch validation failure");
+  assert.equal(
+    readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01"),
+    null,
+    "pre-dispatch validation failures must not persist a dispatched runtime record",
+  );
+});
+
 test("all events from a mock iteration have monotonically increasing seq and same flowId", async () => {
   const capture = createEventCapture();
   const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");