gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.b6ad8c5f7

package/src/resources/extensions/gsd/setup-catalog.ts

@@ -0,0 +1,105 @@
+// GSD — Setup catalog (single source of truth for onboarding steps + provider sub-views)
+//
+// Re-exports filtered views over PROVIDER_REGISTRY (key-manager.ts) and owns the
+// canonical ONBOARDING_STEPS list. Consumers (CLI wizard, /gsd setup hub,
+// onboarding handler, web alignment) all read from here so adding a step or
+// provider lands in one place. Keep this module thin: no behavior beyond
+// filters + lookup helpers, so it stays cycle-safe even though it depends on
+// key-manager for the provider catalog.
+
+import { PROVIDER_REGISTRY, type ProviderInfo } from "./key-manager.js"
+
+export type OnboardingStepId =
+  | "llm"
+  | "model"
+  | "search"
+  | "remote"
+  | "tool-keys"
+  | "prefs"
+  | "skills"
+  | "doctor"
+  | "project"
+
+export interface OnboardingStepDef {
+  id: OnboardingStepId
+  label: string
+  /** Required steps gate the "complete" flag. Skipped required steps mark the wizard incomplete. */
+  required: boolean
+  /** Short description shown in /gsd setup status hub. */
+  hint: string
+}
+
+/**
+ * Canonical ordered list of onboarding steps.
+ *
+ * To add a new step:
+ *   1. Append here (or insert at the right position).
+ *   2. Bump FLOW_VERSION in onboarding-state.ts so existing users get re-prompted.
+ *   3. Wire its CLI runner in src/onboarding.ts (and handlers/onboarding.ts for --step).
+ */
+export const ONBOARDING_STEPS: readonly OnboardingStepDef[] = [
+  { id: "llm",       label: "LLM provider & auth",      required: true,  hint: "Sign in or paste an API key" },
+  { id: "model",     label: "Default model",            required: false, hint: "Pick a default model for the chosen provider" },
+  { id: "search",    label: "Web search provider",      required: false, hint: "Brave, Tavily, or Anthropic built-in" },
+  { id: "remote",    label: "Remote questions",         required: false, hint: "Discord / Slack / Telegram notifications" },
+  { id: "tool-keys", label: "Tool API keys",            required: false, hint: "Context7, Jina, Groq voice, etc." },
+  { id: "prefs",     label: "Global preferences",       required: false, hint: "Mode, profile, notifications" },
+  { id: "skills",    label: "Skills install",           required: false, hint: "Browse and install skill plugins" },
+  { id: "doctor",    label: "Validate setup",           required: false, hint: "Run provider doctor checks" },
+  { id: "project",   label: "Project init",             required: false, hint: "Bootstrap .gsd/ in this repo" },
+]
+
+const STEP_INDEX = new Map(ONBOARDING_STEPS.map((s, i) => [s.id, i]))
+
+export function getStep(id: string): OnboardingStepDef | undefined {
+  const idx = STEP_INDEX.get(id as OnboardingStepId)
+  return idx === undefined ? undefined : ONBOARDING_STEPS[idx]
+}
+
+export function isValidStepId(id: string): id is OnboardingStepId {
+  return STEP_INDEX.has(id as OnboardingStepId)
+}
+
+/**
+ * Given a possibly-stale resume point, return the nearest next step that is
+ * still defined in the catalog. Falls back to the first step.
+ */
+export function nearestResumeStep(lastResumePoint: string | null, completedSteps: string[]): OnboardingStepId {
+  const completed = new Set(completedSteps)
+  // First incomplete step at or after the lastResumePoint
+  let startIdx = 0
+  if (lastResumePoint && STEP_INDEX.has(lastResumePoint as OnboardingStepId)) {
+    startIdx = STEP_INDEX.get(lastResumePoint as OnboardingStepId) ?? 0
+  }
+  for (let i = startIdx; i < ONBOARDING_STEPS.length; i++) {
+    if (!completed.has(ONBOARDING_STEPS[i].id)) return ONBOARDING_STEPS[i].id
+  }
+  // Everything from the resume point is complete — try from the start
+  for (const step of ONBOARDING_STEPS) {
+    if (!completed.has(step.id)) return step.id
+  }
+  return ONBOARDING_STEPS[0].id
+}
+
+// ─── Provider catalog views ───────────────────────────────────────────────────
+
+export function getLlmProviders(): ProviderInfo[] {
+  return PROVIDER_REGISTRY.filter(p => p.category === "llm")
+}
+
+export function getToolProviders(): ProviderInfo[] {
+  return PROVIDER_REGISTRY.filter(p => p.category === "tool")
+}
+
+export function getSearchProviders(): ProviderInfo[] {
+  return PROVIDER_REGISTRY.filter(p => p.category === "search")
+}
+
+export function getRemoteProviders(): ProviderInfo[] {
+  return PROVIDER_REGISTRY.filter(p => p.category === "remote")
+}
+
+/** Provider IDs that count as "the user has an LLM configured" for shouldRunOnboarding. */
+export function getLlmProviderIds(): string[] {
+  return Array.from(new Set([...getLlmProviders().map(p => p.id), "claude-code"]))
+}

package/src/resources/extensions/gsd/state.ts

@@ -44,6 +44,8 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
+import { loadEffectiveGSDPreferences } from './preferences.js';
+import { detectPendingEscalation } from './escalation.js';
 
 import {
   isDbAvailable,
@@ -60,6 +62,7 @@ import {
   updateSliceStatus,
   updateTaskStatus,
   getPendingGateCountForTurn,
+  autoHealSketchFlags,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -849,7 +852,15 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     return handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress);
   }
 
-  const activeSliceContext = resolveSliceDependencies(activeMilestoneSlices);
+  // ADR-011 auto-heal: if a slice has a PLAN on disk but is still flagged is_sketch=1
+  // (e.g. a crash between plan-slice write and the sketch flip), reconcile before
+  // running phase derivation so the flag doesn't misroute state.
+  autoHealSketchFlags(activeMilestone.id, (sid) =>
+    !!resolveSliceFile(basePath, activeMilestone.id, sid, "PLAN"),
+  );
+  // Re-read slices after auto-heal so downstream reads see fresh is_sketch values.
+  const healedSlices = getMilestoneSlices(activeMilestone.id);
+  const activeSliceContext = resolveSliceDependencies(healedSlices);
   if (!activeSliceContext.activeSlice) {
     // If locked slice wasn't found, it returns null but logs warning, we need to return 'blocked'
     if (process.env.GSD_SLICE_LOCK) {
@@ -869,10 +880,24 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       progress: { milestones: milestoneProgress, slices: sliceProgress },
     };
   }
-  const { activeSlice } = activeSliceContext;
+  const { activeSlice, activeSliceRow } = activeSliceContext;
 
   const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
   if (!planFile) {
+    // ADR-011: sketch slices with progressive_planning enabled enter the
+    // `refining` phase — a refine-slice unit expands the sketch into a full plan
+    // before execution. When the flag is off, sketches are indistinguishable
+    // from a missing plan and fall through to the normal `planning` phase.
+    const progressive = loadEffectiveGSDPreferences()?.preferences?.phases?.progressive_planning === true;
+    if (progressive && activeSliceRow?.is_sketch === 1) {
+      return {
+        activeMilestone, activeSlice, activeTask: null,
+        phase: 'refining', recentDecisions: [], blockers: [],
+        nextAction: `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`,
+        registry, requirements,
+        progress: { milestones: milestoneProgress, slices: sliceProgress },
+      };
+    }
     return {
       activeMilestone, activeSlice, activeTask: null,
       phase: 'planning', recentDecisions: [], blockers: [],
@@ -965,6 +990,29 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     }
   }
 
+  // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
+  // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
+  // surfaced here — they let the loop continue.
+  //
+  // We do NOT gate this on `phases.mid_execution_escalation` — creation of
+  // new escalations is gated at the write site (tools/complete-task.ts:315),
+  // but any escalation_pending row already persisted in the DB must be
+  // honored even if the user later toggles the flag off. Otherwise those
+  // rows would silently orphan, the loop would advance past the paused task,
+  // and the user's prior resolution never lands.
+  const escalatingTaskId = detectPendingEscalation(tasks, basePath);
+  if (escalatingTaskId) {
+    return {
+      activeMilestone, activeSlice, activeTask,
+      phase: 'escalating-task', recentDecisions: [],
+      blockers: [`Task ${escalatingTaskId} requires a user decision before the loop can proceed`],
+      nextAction: `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`,
+      activeWorkspace: undefined,
+      registry, requirements,
+      progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+    };
+  }
+
   if (!blockerTaskId) {
     const isTriggered = checkReplanTrigger(basePath, activeMilestone.id, activeSlice.id);
     if (isTriggered) {

package/src/resources/extensions/gsd/templates/PREFERENCES.md

@@ -44,19 +44,19 @@ uok:
   legacy_fallback:
     enabled: false
   gates:
-    enabled: false
+    enabled: true
   model_policy:
-    enabled: false
+    enabled: true
   execution_graph:
-    enabled: false
+    enabled: true
   gitops:
-    enabled: false
-    turn_action: status-only
+    enabled: true
+    turn_action: commit
     turn_push: false
   audit_unified:
-    enabled: false
+    enabled: true
   plan_v2:
-    enabled: false
+    enabled: true
 auto_visualize:
 auto_report:
 parallel:

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/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 dispatches through the UOK kernel wrapper (legacy loop adapter)", () => {
+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",
@@ -1283,8 +1319,12 @@ test("auto.ts startAuto dispatches through the UOK kernel wrapper (legacy loop a
     "startAuto must dispatch through runAutoLoopWithUok()",
   );
   assert.ok(
-    fnBlock.includes("runLegacyLoop: autoLoop"),
-    "startAuto must preserve the legacy autoLoop adapter in kernel dispatch",
+    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",
   );
 });
 
@@ -1332,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",
@@ -1347,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()"),
@@ -1389,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

@@ -247,6 +247,18 @@ test("model policy receives task metadata for requirement-vector decisions", ()
   );
 });
 
+test("dynamic routing passes provider-qualified model keys to the router", () => {
+  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
+  assert.ok(
+    src.includes("routingEligibleModels.map(m => `${m.provider}/${m.id}`)"),
+    "selectAndApplyModel should preserve provider prefixes for dynamic routing candidates",
+  );
+  assert.ok(
+    !src.includes("routingEligibleModels.map(m => m.id)"),
+    "selectAndApplyModel must not strip providers before resolving tier_models",
+  );
+});
+
 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-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);
+  }
+});