gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -2,8 +2,7 @@
  * agent-end-retry.test.ts — Regression checks for the agent_end model.
  *
  * The per-unit one-shot resolve function lives at module level in auto-loop.ts
- * (_currentResolve). handleAgentEnd is a thin compatibility wrapper around
- * resolveAgentEnd().
+ * (_currentResolve). agent_end is handled via resolveAgentEnd().
  */
 
 import test from "node:test";
@@ -62,38 +61,6 @@ test("legacy pendingAgentEndRetry state is gone", () => {
   );
 });
 
-test("handleAgentEnd is a thin compatibility wrapper", () => {
-  const source = getAutoTsSource();
-  const fnIdx = source.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
-  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── ", fnIdx + 100));
-
-  assert.ok(
-    fnBlock.includes("resolveAgentEnd("),
-    "handleAgentEnd must delegate to resolveAgentEnd",
-  );
-  assert.ok(
-    !fnBlock.includes("pendingAgentEndRetry"),
-    "handleAgentEnd must not use legacy retry state",
-  );
-  assert.ok(
-    !fnBlock.includes("dispatchNextUnit"),
-    "handleAgentEnd must not dispatch recursively",
-  );
-});
-
-test("handleAgentEnd early return calls resolveAgentEndCancelled", () => {
-  const source = getAutoTsSource();
-  const fnIdx = source.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
-  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── ", fnIdx + 100));
-
-  assert.ok(
-    fnBlock.includes("resolveAgentEndCancelled()"),
-    "handleAgentEnd must call resolveAgentEndCancelled on early return to prevent orphaned promises",
-  );
-});
-
 test("pauseAuto calls resolveAgentEndCancelled to unblock the loop", () => {
   const source = getAutoTsSource();
   const fnIdx = source.indexOf("export async function pauseAuto");

package/src/resources/extensions/gsd/tests/artifact-corruption-2630.test.ts

@@ -46,6 +46,8 @@ function makeSliceRow(overrides?: Partial<SliceRow>): SliceRow {
     observability_impact: '',
     sequence: 4,
     replan_triggered_at: null,
+    is_sketch: 0,
+    sketch_scope: '',
     ...overrides,
   };
 }
@@ -77,6 +79,11 @@ function makeTaskRow(overrides?: Partial<TaskRow>): TaskRow {
     expected_output: [],
     observability_impact: '',
     sequence: 0,
+    blocker_source: '',
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
     ...overrides,
   };
 }

package/src/resources/extensions/gsd/tests/artifacts-table-preserved-on-cache-invalidate.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Regression test: invalidateAllCaches() must NOT wipe the artifacts table.
+ *
+ * Prior to this fix, `cache.ts` bundled `clearArtifacts()` (which runs
+ * `DELETE FROM artifacts`) into `invalidateAllCaches()`. That helper fires
+ * on every post-unit pass, so rows written by `saveArtifactToDb` and
+ * `writeAndStore` (RESEARCH, CONTEXT, VALIDATION, ASSESSMENT, PLAN,
+ * ROADMAP, task PLAN, task SUMMARY) got deleted within seconds of being
+ * written. The milestone completed on disk, but `SELECT COUNT(*) FROM
+ * artifacts` returned 0, and the agent fell into a "file exists but DB
+ * record missing" recovery loop.
+ *
+ * The artifacts table is a write-through store, not a read cache. Routine
+ * cache invalidation must preserve its contents.
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertArtifact,
+  isDbAvailable,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+afterEach(() => {
+  if (isDbAvailable()) {
+    try {
+      closeDatabase();
+    } catch {
+      /* best-effort teardown */
+    }
+  }
+});
+
+describe("invalidateAllCaches() must preserve the artifacts table", () => {
+  test("rows survive a single invalidate call", () => {
+    const opened = openDatabase(":memory:");
+    assert.equal(opened, true, "in-memory DB must open");
+
+    insertArtifact({
+      path: "milestones/M001/slices/S01/S01-RESEARCH.md",
+      artifact_type: "RESEARCH",
+      milestone_id: "M001",
+      slice_id: "S01",
+      task_id: null,
+      full_content: "# Research\n\nFindings go here.\n",
+    });
+
+    invalidateAllCaches();
+
+    const adapter = _getAdapter();
+    assert.ok(adapter, "adapter should be available");
+    const row = adapter!
+      .prepare(
+        "SELECT path, artifact_type, length(full_content) AS len FROM artifacts WHERE path = :path",
+      )
+      .get({ ":path": "milestones/M001/slices/S01/S01-RESEARCH.md" }) as
+      | { path: string; artifact_type: string; len: number }
+      | undefined;
+
+    assert.ok(
+      row,
+      "artifact row must still exist after invalidateAllCaches — this is the Phase B bug",
+    );
+    assert.equal(row!.artifact_type, "RESEARCH");
+    assert.ok((row!.len ?? 0) > 0, "full_content must not be truncated");
+  });
+
+  test("multiple rows for a full milestone survive repeated invalidates", () => {
+    openDatabase(":memory:");
+
+    const inserts = [
+      {
+        path: "milestones/M001/M001-ROADMAP.md",
+        artifact_type: "ROADMAP",
+        milestone_id: "M001",
+        slice_id: null,
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/S01-RESEARCH.md",
+        artifact_type: "RESEARCH",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/S01-PLAN.md",
+        artifact_type: "PLAN",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/tasks/T01-PLAN.md",
+        artifact_type: "PLAN",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: "T01",
+      },
+      {
+        path: "milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
+        artifact_type: "SUMMARY",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: "T01",
+      },
+      {
+        path: "milestones/M001/M001-SUMMARY.md",
+        artifact_type: "SUMMARY",
+        milestone_id: "M001",
+        slice_id: null,
+        task_id: null,
+      },
+    ];
+
+    for (const i of inserts) {
+      insertArtifact({ ...i, full_content: `# ${i.artifact_type} content\n` });
+    }
+
+    // Simulate a full milestone's worth of post-unit cycles.
+    for (let i = 0; i < 10; i++) {
+      invalidateAllCaches();
+    }
+
+    const adapter = _getAdapter()!;
+    const count = (
+      adapter.prepare("SELECT COUNT(*) AS n FROM artifacts").get() as { n: number }
+    ).n;
+
+    assert.equal(
+      count,
+      inserts.length,
+      `all ${inserts.length} artifact rows must survive repeated invalidate calls; got ${count}`,
+    );
+  });
+});
+
+describe("cache.ts must not re-import clearArtifacts into invalidateAllCaches", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "cache.ts"),
+    "utf-8",
+  );
+
+  test("clearArtifacts is not imported from gsd-db", () => {
+    assert.ok(
+      !/import\s*\{[^}]*clearArtifacts[^}]*\}\s*from\s*['"]\.\/gsd-db/.test(src),
+      "cache.ts must not import clearArtifacts — it causes the artifacts-table-wipe regression",
+    );
+  });
+
+  test("invalidateAllCaches does not call clearArtifacts", () => {
+    const fnIdx = src.indexOf("function invalidateAllCaches");
+    assert.ok(fnIdx !== -1);
+    const body = src.slice(fnIdx, fnIdx + 1000);
+    assert.ok(
+      !/\bclearArtifacts\s*\(/.test(body),
+      "invalidateAllCaches must not call clearArtifacts() — it wipes the write-through store",
+    );
+  });
+
+  test("cache.ts documents why clearArtifacts is not bundled here", () => {
+    // Future reviewers need to see the rationale or they'll re-add it.
+    assert.ok(
+      /artifacts.*NOT included|write-through store/i.test(src),
+      "cache.ts must explain why the artifacts table is NOT invalidated here",
+    );
+  });
+});

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

@@ -313,6 +313,42 @@ test("runUnit re-applies the selected unit model after newSession before dispatc
   assert.equal(pi.calls.length, 1);
 });
 
+test("runUnit cancels before dispatch when model restore fails after newSession", async () => {
+  _resetPendingResolve();
+
+  const notifications: Array<{ message: string; level: string }> = [];
+  const ctx = makeMockCtx();
+  ctx.ui.notify = (message: string, level: string) => {
+    notifications.push({ message, level });
+  };
+
+  const pi = makeMockPi();
+  pi.setModel = async (...args: unknown[]) => {
+    pi.setModelCalls.push(args);
+    return false;
+  };
+
+  const s = makeMockSession();
+  s.currentUnitModel = { provider: "openai-codex", id: "gpt-5.4" };
+
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.match(
+    result.errorContext?.message ?? "",
+    /Failed to restore configured model openai-codex\/gpt-5\.4 after session creation/,
+  );
+  assert.equal(pi.setModelCalls.length, 1);
+  assert.equal(pi.calls.length, 0, "unit must not dispatch on the session default model");
+  assert.deepEqual(notifications, [
+    {
+      message: "Failed to restore configured model openai-codex/gpt-5.4 after session creation. Cancelling unit before dispatch.",
+      level: "warning",
+    },
+  ]);
+});
+
 // ─── Structural assertions ───────────────────────────────────────────────────
 
 test("auto-loop.ts exports autoLoop, runUnit, resolveAgentEnd", async () => {
@@ -1267,7 +1303,7 @@ test("auto-loop.ts barrel re-exports autoLoop, runUnit, and resolveAgentEnd", ()
   );
 });
 
-test("auto.ts startAuto calls autoLoop (not dispatchNextUnit as first dispatch)", () => {
+test("auto.ts startAuto dispatches through the UOK kernel wrapper with explicit kernel and legacy paths", () => {
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto.ts"),
     "utf-8",
@@ -1279,8 +1315,16 @@ test("auto.ts startAuto calls autoLoop (not dispatchNextUnit as first dispatch)"
   const fnBlock =
     fnEnd > -1 ? src.slice(fnIdx, fnEnd) : src.slice(fnIdx, fnIdx + 5000);
   assert.ok(
-    fnBlock.includes("autoLoop("),
-    "startAuto must call autoLoop() instead of dispatchNextUnit()",
+    fnBlock.includes("runAutoLoopWithUok("),
+    "startAuto must dispatch through runAutoLoopWithUok()",
+  );
+  assert.ok(
+    fnBlock.includes("runKernelLoop: runUokKernelLoop"),
+    "startAuto must wire the explicit UOK kernel loop path",
+  );
+  assert.ok(
+    fnBlock.includes("runLegacyLoop: runLegacyAutoLoop"),
+    "startAuto must preserve explicit legacy fallback dispatch",
   );
 });
 
@@ -1328,7 +1372,7 @@ test("startAuto guards against concurrent invocation (#2923)", () => {
   );
 });
 
-test("agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
+test("agent_end handler calls resolveAgentEnd (not the legacy auto.ts path)", () => {
   const hooksSrc = readFileSync(
     resolve(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
     "utf-8",
@@ -1343,7 +1387,7 @@ test("agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
   );
   assert.ok(
     recoverySrc.includes("resolveAgentEnd(event)"),
-    "agent_end success path must call resolveAgentEnd(event) instead of handleAgentEnd(ctx, pi)",
+    "agent_end success path must call resolveAgentEnd(event) instead of legacy wrappers",
   );
   assert.ok(
     recoverySrc.includes("isSessionSwitchInFlight()"),
@@ -1385,32 +1429,6 @@ test("auto-timeout-recovery.ts calls resolveAgentEnd instead of dispatchNextUnit
   );
 });
 
-test("handleAgentEnd in auto.ts is a thin wrapper calling resolveAgentEnd", () => {
-  const src = readFileSync(
-    resolve(import.meta.dirname, "..", "auto.ts"),
-    "utf-8",
-  );
-  const fnIdx = src.indexOf("export async function handleAgentEnd");
-  assert.ok(fnIdx > -1, "handleAgentEnd must exist");
-  const fnEnd = src.indexOf("\n// ─── ", fnIdx + 100);
-  const fnBlock =
-    fnEnd > -1 ? src.slice(fnIdx, fnEnd) : src.slice(fnIdx, fnIdx + 1000);
-  assert.ok(
-    fnBlock.includes("resolveAgentEnd("),
-    "handleAgentEnd must call resolveAgentEnd",
-  );
-  // The function should be short — no reentrancy guard, no verification, no dispatch
-  assert.ok(
-    !fnBlock.includes("dispatchNextUnit"),
-    "handleAgentEnd must not call dispatchNextUnit (it's now a thin wrapper)",
-  );
-  assert.ok(
-    !fnBlock.includes("postUnitPreVerification") &&
-      !fnBlock.includes("postUnitPostVerification"),
-    "handleAgentEnd must not contain verification logic (moved to autoLoop)",
-  );
-});
-
 // ── Stuck counter tests ──────────────────────────────────────────────────────
 
 test("stuck detection: stops when sliding window detects same unit 3 consecutive times", async () => {

package/src/resources/extensions/gsd/tests/auto-migrating-recovery.test.ts

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { recoverFailedMigration } from "../migrate-external.ts";
+
+// Regression tests for #4416: `.gsd.migrating` must be healed before auto-mode
+// proceeds, including on the resume path in auto.ts (fixed at auto.ts:1325).
+// The `recoverFailedMigration` function is already called in `auto-start.ts:350`
+// for fresh-start sessions. The fix adds an identical call to `auto.ts:startAuto`
+// so that resume sessions (triggered by a persisted paused-session.json) also heal
+// a leftover `.gsd.migrating` directory before acquiring the session lock.
+
+test("recoverFailedMigration renames .gsd.migrating to .gsd when .gsd is absent", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-recovery-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const migratingPath = join(base, ".gsd.migrating");
+  mkdirSync(join(migratingPath, "milestones"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected recovery to succeed");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd must exist after recovery");
+  assert.ok(!existsSync(migratingPath), ".gsd.migrating must not exist after recovery");
+});
+
+test("recoverFailedMigration returns false when .gsd.migrating is absent (nothing to do)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-noop-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const recovered = recoverFailedMigration(base);
+  assert.equal(recovered, false, "no migration to recover");
+});
+
+test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exist (ambiguous)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-ambig-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+  assert.equal(recovered, false, "should not touch ambiguous state");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd must still exist");
+  assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
+});
+
+test("recoverFailedMigration preserves contents of .gsd.migrating", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-contents-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const migratingPath = join(base, ".gsd.migrating");
+  mkdirSync(join(migratingPath, "milestones", "M001"), { recursive: true });
+  writeFileSync(join(migratingPath, "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+  recoverFailedMigration(base);
+
+  const roadmap = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+  assert.ok(existsSync(roadmap), "Milestone file must be accessible via .gsd after recovery");
+});

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -227,6 +227,26 @@ test("model change notify in selectAndApplyModel is gated behind verbose flag",
   );
 });
 
+test("model policy resolves candidates from the policy-eligible pool", () => {
+  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
+  assert.ok(
+    src.includes("const resolutionPool = uokFlags.modelPolicy ? routingEligibleModels : availableModels"),
+    "selectAndApplyModel should resolve model IDs against policy-eligible models when model policy is enabled",
+  );
+});
+
+test("model policy receives task metadata for requirement-vector decisions", () => {
+  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
+  assert.ok(
+    src.includes("taskMetadata: taskMetadataForPolicy"),
+    "applyModelPolicyFilter should receive task metadata so requirement vectors are unit-aware",
+  );
+  assert.ok(
+    src.includes("extractTaskMetadata(unitId, basePath)"),
+    "execute-task dispatch should derive metadata before policy filtering",
+  );
+});
+
 test("resolveModelId: anthropic wins over claude-code when session provider is not claude-code", () => {
   const availableModels = [
     { id: "claude-sonnet-4-6", provider: "claude-code" },

package/src/resources/extensions/gsd/tests/auto-project-root-env.test.ts

@@ -13,11 +13,15 @@ test("auto-mode captures GSD_PROJECT_ROOT before entering the dispatch loop", ()
   const resumeCallIdx = source.indexOf("captureProjectRootEnv(s.originalBasePath || s.basePath);");
   assert.ok(resumeCallIdx > -1, "auto.ts should capture GSD_PROJECT_ROOT before resume autoLoop");
 
-  const firstAutoLoopIdx = source.indexOf("await autoLoop(ctx, pi, s, buildLoopDeps());");
-  assert.ok(firstAutoLoopIdx > -1, "auto.ts should invoke autoLoop()");
+  const firstLoopIdxCandidates = [
+    source.indexOf("await runAutoLoopWithUok({"),
+    source.indexOf("await autoLoop(ctx, pi, s, buildLoopDeps());"),
+  ].filter((idx) => idx > -1);
+  const firstAutoLoopIdx = firstLoopIdxCandidates.length > 0 ? Math.min(...firstLoopIdxCandidates) : -1;
+  assert.ok(firstAutoLoopIdx > -1, "auto.ts should invoke the auto dispatch loop");
   assert.ok(
     resumeCallIdx < firstAutoLoopIdx,
-    "auto.ts must set GSD_PROJECT_ROOT before the first autoLoop() call",
+    "auto.ts must set GSD_PROJECT_ROOT before the first loop call",
   );
 });
 

package/src/resources/extensions/gsd/tests/auto-prompts-fallback.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildSourceFilePaths } from "../auto-prompts.ts";
+
+// Regression test for #4416: the fallback string must not mention `rg` because
+// auto-mode runs on systems where ripgrep is not installed (e.g. Windows).
+test("buildSourceFilePaths fallback does not reference rg or ripgrep", (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-prompts-fallback-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // No GSD files exist in tmp — forces the fallback branch.
+  const result = buildSourceFilePaths(tmp, "M001");
+
+  assert.ok(
+    !result.includes("rg ") && !result.includes("`rg`") && !result.includes("ripgrep"),
+    `Fallback string must not reference rg/ripgrep. Got: ${result}`,
+  );
+  assert.ok(result.length > 0, "Fallback string must not be empty");
+});
+
+test("buildSourceFilePaths with sid also produces rg-free fallback", (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-prompts-fallback-sid-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const result = buildSourceFilePaths(tmp, "M001", "S01");
+
+  assert.ok(
+    !result.includes("rg ") && !result.includes("`rg`") && !result.includes("ripgrep"),
+    `Fallback string must not reference rg/ripgrep. Got: ${result}`,
+  );
+});

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -5,7 +5,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
+import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
+import { resolveMilestoneFile } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
@@ -712,3 +713,124 @@ test("verifyExpectedArtifact checks pending gate-evaluate artifacts without ESM
 
   assert.equal(verified, false, "pending gates should keep gate-evaluate unverified");
 });
+
+// ─── #4414 regressions ────────────────────────────────────────────────────────
+
+test("#4414: writeBlockerPlaceholder invalidates path cache so dispatch guard sees file", () => {
+  const base = makeTmpBase();
+  try {
+    // Prime the readdir cache by resolving a DIFFERENT file first — this
+    // mirrors the stuck-loop condition where the dispatch guard cached an
+    // empty directory listing before the placeholder was written.
+    invalidateAllCaches();
+    assert.equal(
+      resolveMilestoneFile(base, "M001", "RESEARCH"),
+      null,
+      "no RESEARCH file yet",
+    );
+
+    const result = writeBlockerPlaceholder(
+      "research-milestone",
+      "M001",
+      base,
+      "verification retries exhausted",
+    );
+    assert.ok(result, "placeholder path returned");
+
+    // After writeBlockerPlaceholder, the dispatch guard must see the new file
+    // immediately — otherwise the rule re-fires (#4414, 7× re-dispatch).
+    const postResolve = resolveMilestoneFile(base, "M001", "RESEARCH");
+    assert.ok(
+      postResolve,
+      "resolveMilestoneFile finds the placeholder post-write (cache invalidated)",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("#4414: parallel-research sentinel path does not collide with RESEARCH suffix", () => {
+  const base = makeTmpBase();
+  try {
+    // Write only the parallel-research blocker (sentinel).
+    const sentinel = resolveExpectedArtifactPath(
+      "research-slice",
+      "M001/parallel-research",
+      base,
+    );
+    assert.ok(sentinel, "sentinel path resolves for parallel-research");
+    writeFileSync(sentinel!, "# blocker\n", "utf-8");
+
+    // Critical: the sentinel filename must NOT be matched by the legacy regex
+    // used when callers look up milestone-level RESEARCH. Otherwise the
+    // dispatch guard for research-milestone would short-circuit falsely.
+    const milestoneResearch = resolveMilestoneFile(base, "M001", "RESEARCH");
+    assert.equal(
+      milestoneResearch,
+      null,
+      "sentinel must not be mistaken for M001-RESEARCH.md via legacy pattern match",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("#4414: verifyExpectedArtifact parallel-research succeeds when all research-ready slices have RESEARCH", () => {
+  const base = makeTmpBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S03", "tasks"), { recursive: true });
+
+    // Minimal roadmap with three slices
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      [
+        "# M001: Regression",
+        "",
+        "## Slices",
+        "",
+        "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+        "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+        "- [ ] **S03: Gamma** `risk:low` `depends:[]`",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    // Only 2 of 3 have RESEARCH — should fail verification
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+      "# research",
+      "utf-8",
+    );
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-RESEARCH.md"),
+      "# research",
+      "utf-8",
+    );
+
+    clearParseCache();
+    invalidateAllCaches();
+    assert.equal(
+      verifyExpectedArtifact("research-slice", "M001/parallel-research", base),
+      false,
+      "missing S03 RESEARCH → verification fails",
+    );
+
+    // All three RESEARCH present → verification passes
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S03", "S03-RESEARCH.md"),
+      "# research",
+      "utf-8",
+    );
+    clearParseCache();
+    invalidateAllCaches();
+    assert.equal(
+      verifyExpectedArtifact("research-slice", "M001/parallel-research", base),
+      true,
+      "all slices have RESEARCH → verification passes",
+    );
+  } finally {
+    cleanup(base);
+  }
+});