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

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

@@ -19,14 +19,15 @@ import {
   insertMilestone,
   _getAdapter,
 } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
 import { claimMilestoneLease } from "../db/milestone-leases.ts";
-import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { getLatestForUnit, markRunning, recordDispatchClaim } from "../db/unit-dispatches.ts";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
 import {
   writeLock,
   readCrashLock,
   clearLock,
+  clearStaleWorkerLock,
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
@@ -206,6 +207,24 @@ test("writeLock stores the session_file in runtime_kv (worker scope)", (t) => {
   assert.equal(lock!.sessionFile, "/tmp/session-xyz.jsonl");
 });
 
+test("writeLock without session file clears stale worker session_file pointer", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session-stale.jsonl");
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), "/tmp/session-stale.jsonl");
+
+  writeLock(base, "execute-task", "M001/S01/T01");
+  assert.equal(
+    getRuntimeKv("worker", workerId, "session_file"),
+    null,
+    "preliminary lock write must clear stale session_file pointer",
+  );
+});
+
 test("clearLock removes the session_file row for the active worker", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
@@ -223,3 +242,86 @@ test("clearLock removes the session_file row for the active worker", (t) => {
   assert.equal(getRuntimeKv("worker", workerId, "session_file"), null,
     "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));
+  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;
+  const claim = recordDispatchClaim({
+    traceId: "t1",
+    workerId,
+    milestoneLeaseToken: lease.token,
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T02",
+    unitType: "hook/codex-review",
+    unitId: "M001/S01/T02",
+  });
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+  markRunning(claim.dispatchId);
+  setRuntimeKv("worker", workerId, "session_file", "/tmp/pi-session-hook.jsonl");
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  assert.ok(readCrashLock(base), "stale worker is detected before cleanup");
+
+  clearStaleWorkerLock(base);
+
+  assert.equal(getAutoWorker(workerId)?.status, "crashed");
+  const dispatch = getLatestForUnit("M001/S01/T02");
+  assert.ok(dispatch);
+  assert.equal(dispatch!.status, "canceled");
+  assert.equal(dispatch!.exit_reason, "crash-recovered");
+  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/db-authority-regression.test.ts

@@ -0,0 +1,208 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for DB authority over markdown projections.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  closeDatabase,
+  getAllMilestones,
+  getSliceTasks,
+  insertMilestone,
+  insertRequirement,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import { checkMarkdownHierarchyAgainstDb } from "../migration-auto-check.ts";
+import { queryDecisions } from "../context-store.ts";
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
+import type { Requirement } from "../types.ts";
+
+function makeBase(prefix = "gsd-db-authority-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  rmSync(base, { recursive: true, force: true });
+}
+
+function openProjectDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+function activeRequirement(id: string): Requirement {
+  return {
+    id,
+    class: "functional",
+    status: "active",
+    description: `${id} from DB`,
+    why: "DB authority regression fixture",
+    source: "test",
+    primary_owner: "M999/S01",
+    supporting_slices: "",
+    validation: "derive state",
+    notes: "",
+    full_content: `${id} from DB`,
+    superseded_by: null,
+  };
+}
+
+test("DB authority: PROJECT.md and QUEUE-ORDER projections do not choose runtime milestone", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PROJECT.md"),
+    [
+      "# Projection Project",
+      "",
+      "## Milestone Sequence",
+      "- [ ] M001: Projection Only -- should not become active",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "QUEUE-ORDER.json"),
+    JSON.stringify({ order: ["M001", "M999"], updatedAt: new Date().toISOString() }),
+  );
+
+  openProjectDb(base);
+  insertMilestone({ id: "M999", title: "DB Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M999", title: "DB Slice", status: "pending", risk: "low", depends: [], demo: "DB demo", sequence: 1 });
+
+  invalidateStateCache();
+  const state = await deriveStateFromDb(base);
+
+  assert.equal(state.activeMilestone?.id, "M999");
+  assert.equal(state.registry.some((entry) => entry.id === "M001"), false);
+});
+
+test("DB authority: REQUIREMENTS.md and DECISIONS.md projections do not populate DB reads", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  writeFileSync(
+    join(base, ".gsd", "REQUIREMENTS.md"),
+    [
+      "# Requirements",
+      "",
+      "## Active",
+      "### R001 - Projection-only requirement",
+      "- Class: functional",
+      "- Status: active",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "DECISIONS.md"),
+    [
+      "# Decisions",
+      "",
+      "| # | When / Context | Scope | Decision | Choice | Rationale | Revisable | Made By |",
+      "|---|----------------|-------|----------|--------|-----------|----------|---------|",
+      "| D001 | Now | global | Projection-only decision | Ignore | DB is authority | Yes | human |",
+      "",
+    ].join("\n"),
+  );
+
+  openProjectDb(base);
+  insertMilestone({ id: "M999", title: "DB Milestone", status: "active" });
+
+  invalidateStateCache();
+  const state = await deriveStateFromDb(base);
+
+  assert.deepEqual(state.requirements, {
+    active: 0,
+    validated: 0,
+    deferred: 0,
+    outOfScope: 0,
+    blocked: 0,
+    total: 0,
+  });
+  assert.deepEqual(queryDecisions(), []);
+});
+
+test("DB authority: DB requirements remain canonical when REQUIREMENTS.md disagrees", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  writeFileSync(
+    join(base, ".gsd", "REQUIREMENTS.md"),
+    [
+      "# Requirements",
+      "",
+      "## Active",
+      "### R999 - Projection-only requirement",
+      "- Class: functional",
+      "- Status: active",
+      "",
+    ].join("\n"),
+  );
+
+  openProjectDb(base);
+  insertMilestone({ id: "M999", title: "DB Milestone", status: "active" });
+  insertRequirement(activeRequirement("R001"));
+
+  invalidateStateCache();
+  const state = await deriveStateFromDb(base);
+
+  assert.ok(state.requirements);
+  assert.equal(state.requirements.active, 1);
+  assert.equal(state.requirements.total, 1);
+});
+
+test("explicit markdown import remains opt-in and is not run by startup mismatch check", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Imported Explicitly",
+      "",
+      "**Vision:** Explicit recovery import only",
+      "",
+      "## Slices",
+      "- [ ] **S01: Slice** `risk:low` `depends:[]`",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Slice",
+      "",
+      "**Goal:** prove explicit import",
+      "",
+      "## Tasks",
+      "- [ ] **T01: Task** `est:5m`",
+      "",
+    ].join("\n"),
+  );
+
+  openProjectDb(base);
+  const check = await checkMarkdownHierarchyAgainstDb(base);
+  assert.equal(check.action, "recovery-required");
+  assert.equal(getAllMilestones().length, 0, "startup mismatch check must not import markdown");
+
+  const imported = migrateHierarchyToDb(base);
+  assert.deepEqual(imported, { milestones: 1, slices: 1, tasks: 1 });
+  assert.equal(getAllMilestones().length, 1);
+  assert.equal(getSliceTasks("M001", "S01").length, 1);
+});

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

@@ -47,6 +47,7 @@ describe("db-task-slice-rows", () => {
       replan_triggered_at: null,
       is_sketch: 0,
       sketch_scope: "",
+      target_repositories: [],
     });
   });
 

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -10,7 +10,7 @@ import { runDispatch, runPreDispatch } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";
-import { postUnitPreVerification } from "../auto-post-unit.ts";
+import { postUnitPostVerification, postUnitPreVerification } from "../auto-post-unit.ts";
 import { resolveDispatch, setResearchProjectPromptBuilderForTest } from "../auto-dispatch.ts";
 import { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { finalizeProjectResearchTimeout } from "../project-research-policy.ts";
@@ -272,6 +272,7 @@ test("deep project setup: bootstrap can start auto-mode without an active milest
       {
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
           adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
@@ -386,6 +387,7 @@ test("deep project setup: bootstrap continues queued M002 without milestone cont
       {
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
           adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
@@ -1587,6 +1589,63 @@ test("deep project setup: discuss-milestone question failure pauses instead of a
   }
 });
 
+test("verified task git closeout failure retries and continues auto-mode", async () => {
+  const base = makeBase();
+  try {
+    execFileSync("git", ["init"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Test User"], { cwd: base, stdio: "ignore" });
+    const hookPath = join(base, ".git", "hooks", "pre-commit");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        "count_file=.git/pre-commit-count",
+        "count=0",
+        "if [ -f \"$count_file\" ]; then count=$(cat \"$count_file\"); fi",
+        "count=$((count + 1))",
+        "printf \"%s\" \"$count\" > \"$count_file\"",
+        "echo blocked by test hook >&2",
+        "exit 1",
+      ].join("\n"),
+    );
+    chmodSync(hookPath, 0o755);
+    writeFileSync(join(base, "work.txt"), "changed\n");
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    let pauseCalled = false;
+    const notifications: Array<{ message: string; severity?: string }> = [];
+    const result = await postUnitPostVerification({
+      s,
+      ctx: { ui: { notify: (message: string, severity?: string) => notifications.push({ message, severity }) } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => { pauseCalled = true; },
+      updateProgressWidget: () => {},
+    });
+
+    assert.equal(result, "continue");
+    assert.equal(pauseCalled, false);
+    assert.equal(s.lastGitActionStatus, "failed");
+    const preCommitCount = Number(readFileSync(join(base, ".git", "pre-commit-count"), "utf-8"));
+    assert.equal(Number.isFinite(preCommitCount), true);
+    assert.ok(preCommitCount >= 3, "git closeout should retry the failing commit path");
+    assert.ok(
+      notifications.some((entry) => entry.severity === "warning" && entry.message.includes("Git commit failed")),
+      "verified task git closeout failure should warn instead of stopping auto-mode",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: approval wait wins over deterministic write-gate placeholder", async () => {
   const base = makeBase();
   try {

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

@@ -10,9 +10,10 @@ 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";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
@@ -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,68 @@ 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" });
+
+    const result = await rule.match(buildDispatchCtx(base));
+
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
+  });
+
+  test("blocks complete-milestone dispatch when the working tree is dirty (#6132)", async () => {
+    base = makeBase();
+    initGitRepo(base);
+    writeFileSync(join(base, "implementation.txt"), "dirty\n");
+
+    const result = await rule.match(buildDispatchCtx(base));
+
+    assert.equal(result?.action, "stop");
+    assert.match(result?.reason ?? "", /uncommitted changes detected/i);
+  });
+
+  test("blocks complete-milestone dispatch when UAT verdict is non-PASS and uat_dispatch is enabled (#6132)", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md"),
+      "---\nverdict: fail\n---\n\nUAT failed.\n",
+    );
+
+    const ctx = buildDispatchCtx(base);
+    ctx.prefs = { uat_dispatch: true } as DispatchContext["prefs"];
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "stop");
+    assert.match(result?.reason ?? "", /manual UAT sign-off \(PASS\) is required/i);
+  });
+
+  test("blocks complete-milestone dispatch when UAT verdict is missing and uat_dispatch is enabled (#6132)", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md"),
+      "# UAT\n\nNo verdict yet.\n",
+    );
+
+    const ctx = buildDispatchCtx(base);
+    ctx.prefs = { uat_dispatch: true } as DispatchContext["prefs"];
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "stop");
+    assert.match(result?.reason ?? "", /manual UAT sign-off \(PASS\) is required/i);
+  });
 });
 
 describe("complete phase dispatch guard (#5683)", () => {
@@ -118,3 +189,42 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.reason, "All milestones complete.");
   });
 });
+
+describe("complete milestone context recovery guard (#5831)", () => {
+  let base = "";
+  const executionEntryRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "execution-entry phase (no context) → discuss-milestone",
+  );
+  const prePlanningRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "pre-planning (no context) → discuss-milestone",
+  );
+  assert.ok(executionEntryRule, "execution-entry missing-context rule should exist");
+  assert.ok(prePlanningRule, "pre-planning missing-context rule should exist");
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
+  });
+
+  test("does not discuss a complete execution-entry milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "completing-milestone";
+
+    const result = await executionEntryRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+
+  test("does not discuss a complete pre-planning milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "pre-planning";
+
+    const result = await prePlanningRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+});

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

@@ -3,7 +3,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 { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { getConsecutiveDispatchBlocker, getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
 
 /** Helper: create temp dir and open an in-dir DB for dispatch-guard tests */
@@ -47,6 +47,33 @@ test("dispatch guard blocks when prior milestone has incomplete slices", (t) =>
   );
 });
 
+test("dispatch guard skips prior DB parked or deferred milestones without marker files", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Parked", status: "parked" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Incomplete", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M002", title: "Deferred", status: "deferred" });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "Incomplete", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M003", title: "Current", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
+    null,
+  );
+});
+
 test("dispatch guard blocks later slice in same milestone when earlier incomplete", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));
@@ -254,6 +281,46 @@ test("dispatch guard does not skip prior milestone from SUMMARY projection when
   );
 });
 
+test("consecutive dispatch guard blocks complete-milestone after repeat cap", () => {
+  // REPEAT_CAP = 2: two same-unit dispatches are allowed; the third is blocked.
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009"), null);
+  assert.match(
+    getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009") ?? "",
+    /same-unit repeat cap reached/,
+  );
+});
+
+test("consecutive dispatch guard resets when unit changes", () => {
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "research-slice", "M001/parallel-research"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+});
+
+test("consecutive dispatch guard resets when phase changes", () => {
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "validate-milestone", "M001"), null);
+});
+
 test("dispatch guard does not skip failed milestone SUMMARY without blocker prose", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));