@opengsd/gsd-pi 1.0.1 → 1.0.2-dev.0ee79e5

package/src/resources/extensions/gsd/auto/phases.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-loop pipeline phases, merge closeout, and finalize handling.
 /**
  * auto/phases.ts — Pipeline phases for the auto-loop.
@@ -77,6 +77,7 @@ import {
   getRequiredWorkflowToolsForAutoUnit,
   supportsStructuredQuestions,
 } from "../workflow-mcp.js";
+import type { DispatchAction } from "../auto-dispatch.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule, type WorktreeSafetyResult } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
@@ -92,6 +93,16 @@ import {
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
 
+export function resolveDispatchRecoveryAttempts(
+  unitRecoveryCount: Map<string, number>,
+  unitType: string,
+  unitId: string,
+): number | undefined {
+  return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
+    ? 0
+    : undefined;
+}
+
 // ─── Path Comparison Helper ───────────────────────────────────────────────
 /** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
 function isSamePathLocal(a: string, b: string): boolean {
@@ -844,6 +855,7 @@ export async function runPreDispatch(
 
   // Pre-dispatch health gate
   try {
+    const expectedCurrentUnit = null;
     const healthGate = await deps.preDispatchHealthGate(s.basePath);
     if (healthGate.fixesApplied.length > 0) {
       ctx.ui.notify(
@@ -864,7 +876,7 @@ export async function runPreDispatch(
         healthGate.reason || "Pre-dispatch health check failed — run /gsd doctor for details.",
         "error",
       );
-      await deps.pauseAuto(ctx, pi);
+      await deps.pauseAuto(ctx, pi, undefined, { expectedCurrentUnit });
       debugLog("autoLoop", { phase: "exit", reason: "health-gate-failed" });
       return { action: "break", reason: "health-gate-failed" };
     }
@@ -1384,6 +1396,13 @@ export async function runPreDispatch(
 
 // ─── runDispatch ──────────────────────────────────────────────────────────────
 
+function isUnhandledPhaseWarning(dispatchResult: DispatchAction): dispatchResult is Extract<DispatchAction, { action: "stop" }> {
+  return dispatchResult.action === "stop" &&
+    dispatchResult.level === "warning" &&
+    dispatchResult.matchedRule === "<no-match>" &&
+    /^Unhandled phase "/.test(dispatchResult.reason);
+}
+
 /**
  * Phase 3: Dispatch resolution — resolve next unit, stuck detection, pre-dispatch hooks.
  * Returns break/continue to control the loop, or next with IterationData on success.
@@ -1412,7 +1431,7 @@ export async function runDispatch(
       }) ? "true" : "false";
 
   debugLog("autoLoop", { phase: "dispatch-resolve", iteration: ic.iteration });
-  const dispatchResult = await deps.resolveDispatch({
+  let dispatchResult = await deps.resolveDispatch({
     basePath: s.basePath,
     mid,
     midTitle,
@@ -1424,6 +1443,30 @@ export async function runDispatch(
     sessionProvider: ctx.model?.provider,
     modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
   });
+  if (isUnhandledPhaseWarning(dispatchResult)) {
+    deps.invalidateAllCaches();
+    const freshState = await deps.deriveState(s.canonicalProjectRoot);
+    const freshMid = freshState.activeMilestone?.id ?? mid;
+    const freshMidTitle = freshState.activeMilestone?.title ?? freshMid ?? midTitle;
+    debugLog("autoLoop", {
+      phase: "dispatch-unhandled-phase-retry",
+      iteration: ic.iteration,
+      stalePhase: state.phase,
+      freshPhase: freshState.phase,
+    });
+    dispatchResult = await deps.resolveDispatch({
+      basePath: s.basePath,
+      mid: freshMid,
+      midTitle: freshMidTitle,
+      state: freshState,
+      prefs,
+      session: s,
+      structuredQuestionsAvailable,
+      sessionContextWindow: ctx.model?.contextWindow,
+      sessionProvider: ctx.model?.provider,
+      modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
+    });
+  }
 
   if (dispatchResult.action === "stop") {
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });
@@ -2261,7 +2304,7 @@ export async function runUnitPhase(
       lastProgressAt: unitStartedAt,
       progressCount: 0,
       lastProgressKind: "dispatch",
-      recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
+      recoveryAttempts: resolveDispatchRecoveryAttempts(s.unitRecoveryCount, unitType, unitId),
     },
   );
 

package/src/resources/extensions/gsd/auto/run-unit.ts

@@ -1,4 +1,4 @@
-// GSD-2 + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
+// gsd-pi + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
 
 /**
  * auto/run-unit.ts — Single unit execution: session create → prompt → await agent_end.
@@ -26,9 +26,12 @@ import { debugLog } from "../debug-logger.js";
 import { logWarning, logError } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord, type AutoUnitRuntimeRecord } from "../unit-runtime.js";
+import { consumeAutoWakeup } from "./schedule-wakeup.js";
 
 const UNIT_FAILSAFE_BUFFER_MS = 30_000;
 const UNIT_FAILSAFE_RECHECK_MS = 30_000;
+const WAKEUP_SLEEP_CHUNK_MS = 1_000;
+const MAX_WAKEUPS_PER_UNIT = 100;
 
 export function shouldDeferUnitFailsafeTimeout(
   runtime: AutoUnitRuntimeRecord | null,
@@ -51,6 +54,17 @@ export function shouldDeferUnitFailsafeTimeout(
   return progressAgeMs >= 0 && progressAgeMs <= opts.freshProgressMs;
 }
 
+async function sleepForScheduledWakeup(s: AutoSession, delayMs: number): Promise<boolean> {
+  const deadline = Date.now() + Math.max(0, delayMs);
+  while (Date.now() < deadline) {
+    if (!s.active || s.paused) return false;
+    await new Promise<void>((resolve) =>
+      setTimeout(resolve, Math.min(WAKEUP_SLEEP_CHUNK_MS, deadline - Date.now())),
+    );
+  }
+  return s.active && !s.paused;
+}
+
 // Tracks the latest session-switch attempt so a late timeout settlement from an
 // older runUnit() call cannot clear the guard for a newer one.
 let sessionSwitchGeneration = 0;
@@ -226,56 +240,114 @@ export async function runUnit(
   let unitTimeoutHandle: ReturnType<typeof setTimeout> | undefined;
   let result: UnitResult;
   try {
+    const awaitAgentEndWithTimeout = (agentEndPromise: Promise<UnitResult>): Promise<UnitResult> => {
+      const timeoutResult = new Promise<UnitResult>((resolve) => {
+        const settleOrDefer = () => {
+          let runtime: AutoUnitRuntimeRecord | null;
+          try {
+            runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
+          } catch (error) {
+            debugLog("runUnit", {
+              phase: "unit-failsafe-runtime-read-failed",
+              unitType,
+              unitId,
+              error: error instanceof Error ? error.message : String(error),
+            });
+            resolve({
+              status: "cancelled",
+              errorContext: {
+                message: "Unit hard timeout — supervision may have failed; runtime progress could not be read",
+                category: "timeout",
+                isTransient: true,
+              },
+            });
+            return;
+          }
+          if (shouldDeferUnitFailsafeTimeout(runtime, {
+            nowMs: Date.now(),
+            currentUnitStartedAt: s.currentUnit?.startedAt,
+            freshProgressMs,
+          })) {
+            debugLog("runUnit", {
+              phase: "unit-failsafe-deferred",
+              unitType,
+              unitId,
+              runtimePhase: runtime?.phase,
+              lastProgressKind: runtime?.lastProgressKind,
+            });
+            unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_FAILSAFE_RECHECK_MS);
+            return;
+          }
+          resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
+        };
+        unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_HARD_TIMEOUT_MS);
+      });
+      return runWithTurnGeneration(capturedTurnGen, () =>
+        Promise.race([agentEndPromise, timeoutResult]),
+      );
+    };
+
     pi.sendMessage(
       { customType: "gsd-auto", content: prompt, display: s.verbose },
       { triggerTurn: true },
     );
 
     debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
-    const timeoutResult = new Promise<UnitResult>((resolve) => {
-      const settleOrDefer = () => {
-        let runtime: AutoUnitRuntimeRecord | null;
-        try {
-          runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
-        } catch (error) {
-          debugLog("runUnit", {
-            phase: "unit-failsafe-runtime-read-failed",
-            unitType,
-            unitId,
-            error: error instanceof Error ? error.message : String(error),
-          });
-          resolve({
-            status: "cancelled",
-            errorContext: {
-              message: "Unit hard timeout — supervision may have failed; runtime progress could not be read",
-              category: "timeout",
-              isTransient: true,
-            },
-          });
-          return;
-        }
-        if (shouldDeferUnitFailsafeTimeout(runtime, {
-          nowMs: Date.now(),
-          currentUnitStartedAt: s.currentUnit?.startedAt,
-          freshProgressMs,
-        })) {
-          debugLog("runUnit", {
-            phase: "unit-failsafe-deferred",
-            unitType,
-            unitId,
-            runtimePhase: runtime?.phase,
-            lastProgressKind: runtime?.lastProgressKind,
-          });
-          unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_FAILSAFE_RECHECK_MS);
-          return;
-        }
-        resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
-      };
-      unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_HARD_TIMEOUT_MS);
-    });
-    result = await runWithTurnGeneration(capturedTurnGen, () =>
-      Promise.race([unitPromise, timeoutResult]),
-    );
+    result = await awaitAgentEndWithTimeout(unitPromise);
+    if (unitTimeoutHandle) {
+      clearTimeout(unitTimeoutHandle);
+      unitTimeoutHandle = undefined;
+    }
+
+    let wakeupCount = 0;
+    while (result.status === "completed" && s.active && !s.paused) {
+      const wakeup = consumeAutoWakeup(s.basePath, unitType, unitId);
+      if (!wakeup) break;
+      wakeupCount += 1;
+      if (wakeupCount > MAX_WAKEUPS_PER_UNIT) {
+        result = {
+          status: "cancelled",
+          errorContext: {
+            message: `ScheduleWakeup limit exceeded for ${unitType} ${unitId}`,
+            category: "timeout",
+            isTransient: false,
+          },
+        };
+        break;
+      }
+      debugLog("runUnit", {
+        phase: "schedule-wakeup-wait",
+        unitType,
+        unitId,
+        delayMs: wakeup.delayMs,
+        reason: wakeup.reason,
+      });
+      const slept = await sleepForScheduledWakeup(s, wakeup.delayMs);
+      if (!slept) {
+        result = {
+          status: "cancelled",
+          errorContext: {
+            message: `ScheduleWakeup interrupted for ${unitType} ${unitId}`,
+            category: "aborted",
+            isTransient: true,
+          },
+        };
+        break;
+      }
+      const continuationPromise = new Promise<UnitResult>((resolve) => {
+        _setCurrentResolve(resolve);
+      });
+      pi.sendMessage(
+        { customType: "gsd-auto", content: wakeup.prompt, display: s.verbose },
+        { triggerTurn: true },
+      );
+      debugLog("runUnit", { phase: "schedule-wakeup-awaiting-agent-end", unitType, unitId });
+      result = await awaitAgentEndWithTimeout(continuationPromise);
+      if (unitTimeoutHandle) {
+        clearTimeout(unitTimeoutHandle);
+        unitTimeoutHandle = undefined;
+      }
+    }
   } finally {
     if (unitTimeoutHandle) clearTimeout(unitTimeoutHandle);
     ctx.ui.setWorkingMessage?.(undefined);

package/src/resources/extensions/gsd/auto/schedule-wakeup.ts

@@ -0,0 +1,40 @@
+// Project/App: gsd-pi
+// File Purpose: Auto-mode ScheduleWakeup state shared between the tool and runUnit.
+
+export interface ScheduledWakeup {
+  basePath: string;
+  unitType: string;
+  unitId: string;
+  delayMs: number;
+  prompt: string;
+  reason: string;
+  createdAt: number;
+}
+
+function wakeupKey(basePath: string, unitType: string, unitId: string): string {
+  return `${basePath}\0${unitType}\0${unitId}`;
+}
+
+const pendingWakeups = new Map<string, ScheduledWakeup>();
+
+export function scheduleAutoWakeup(wakeup: ScheduledWakeup): void {
+  pendingWakeups.set(
+    wakeupKey(wakeup.basePath, wakeup.unitType, wakeup.unitId),
+    wakeup,
+  );
+}
+
+export function consumeAutoWakeup(
+  basePath: string,
+  unitType: string,
+  unitId: string,
+): ScheduledWakeup | null {
+  const key = wakeupKey(basePath, unitType, unitId);
+  const wakeup = pendingWakeups.get(key) ?? null;
+  pendingWakeups.delete(key);
+  return wakeup;
+}
+
+export function _resetAutoWakeupsForTest(): void {
+  pendingWakeups.clear();
+}

package/src/resources/extensions/gsd/auto/session.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Mutable auto-mode session state container.
 /**
  * AutoSession — encapsulates all mutable auto-mode state into a single instance.

package/src/resources/extensions/gsd/auto/unit-runner-events.ts

@@ -1,4 +1,4 @@
-// GSD-2 + src/resources/extensions/gsd/auto/unit-runner-events.ts - Classifies agent lifecycle events before Unit settlement.
+// gsd-pi + src/resources/extensions/gsd/auto/unit-runner-events.ts - Classifies agent lifecycle events before Unit settlement.
 
 import type { AgentEndEvent } from "./types.js";
 

package/src/resources/extensions/gsd/auto/verification-retry-policy.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Central retry policy for auto-mode verification redispatches.
 
 import { createHash } from "node:crypto";

package/src/resources/extensions/gsd/auto/workflow-custom-engine-dispatch-outcome.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Applies custom-engine dispatch decisions to auto-mode loop side effects.
 
 import type { EngineDispatchDecision } from "./workflow-kernel.js";

package/src/resources/extensions/gsd/auto/workflow-custom-engine-iteration.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Custom-engine iteration-data adapter for auto-mode loop.
 
 import type { GSDState } from "../types.js";

package/src/resources/extensions/gsd/auto/workflow-custom-engine-reconcile-outcome.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Applies custom-engine reconcile outcomes to auto-mode loop side effects.
 
 import type { CustomEngineReconcileOutcome } from "./workflow-custom-engine-reconcile.js";

package/src/resources/extensions/gsd/auto/workflow-custom-engine-reconcile.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Custom-engine successful verification reconcile adapter for auto-mode loop.
 
 import type { EngineState, ReconcileResult } from "../engine-types.js";

package/src/resources/extensions/gsd/auto/workflow-custom-engine-retry.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Custom-engine verification retry adapter for auto-mode loop.
 
 import type { AutoSession } from "./session.js";

package/src/resources/extensions/gsd/auto/workflow-custom-engine-verify-outcome.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Applies custom-engine verification outcomes to auto-mode loop side effects.
 
 import type { CustomEngineVerifyRetryOutcome } from "./workflow-custom-engine-retry.js";

package/src/resources/extensions/gsd/auto/workflow-dispatch-claim.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
 
 import type { AutoSession } from "./session.js";

package/src/resources/extensions/gsd/auto/workflow-dispatch-ledger.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Best-effort dispatch ledger write helpers for auto-mode loop adapters.
 
 interface DispatchLedgerWriteDeps {

package/src/resources/extensions/gsd/auto/workflow-iteration-completion.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Successful auto-mode iteration cleanup helper.
 
 export interface WorkflowIterationRecoveryState {

package/src/resources/extensions/gsd/auto/workflow-journal-reporter.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Thin adapter for auto-mode workflow journal event emission.
 
 import type { JournalEntry, JournalEventType } from "../journal.js";

package/src/resources/extensions/gsd/auto/workflow-kernel.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Pure workflow-loop decisions for auto-mode before side-effect adapters run.
 
 export type WorkflowLoopAction =

package/src/resources/extensions/gsd/auto/workflow-memory-pressure.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Memory-pressure measurement adapter for auto-mode loop.
 
 import { createRequire } from "node:module";

package/src/resources/extensions/gsd/auto/workflow-phase-reporter.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Thin adapter for auto-mode UOK phase-result reporting.
 
 import type { TurnPhase, UokTurnObserver } from "../uok/contracts.js";

package/src/resources/extensions/gsd/auto/workflow-session-lock.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Session-lock validation adapter for auto-mode loop.
 
 import type { SessionLockStatus } from "../session-lock.js";

package/src/resources/extensions/gsd/auto/workflow-sidecar-iteration.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Sidecar iteration-data adapter for auto-mode loop.
 
 import type { GSDState } from "../types.js";

package/src/resources/extensions/gsd/auto/workflow-sidecar-queue.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Sidecar queue scheduling and dequeue adapter for auto-mode loop.
 
 import type { SidecarItem } from "./session.js";

package/src/resources/extensions/gsd/auto/workflow-turn-reporter.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Thin adapter for workflow turn observer reporting.
 
 import type {

package/src/resources/extensions/gsd/auto/workflow-unit-dispatch.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Unit dispatch contract adapter for auto-mode loop.
 
 import type { SidecarItem } from "./session.js";

package/src/resources/extensions/gsd/auto/workflow-worker-heartbeat.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Best-effort worker heartbeat adapter for auto-mode loop.
 
 export interface WorkerHeartbeatSession {

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Resolves expected auto-mode artifact paths across project and worktree projections.
 // GSD Auto-mode — Artifact Path Resolution
 //
@@ -154,8 +154,9 @@ export function resolveExpectedArtifactPath(
       // Gate evaluate writes to DB quality_gates table — verified via state derivation
       return null;
     case "reactive-execute":
-      // Reactive execute produces multiple task summaries — verified separately
-      return null;
+      // Reactive execute normally produces multiple task summaries. On terminal
+      // batch recovery, the engine writes a slice-level blocker sentinel.
+      return mid && sid ? resolveSliceArtifactPath(base, mid, sid, "REACTIVE-BLOCKER") : null;
     default:
       return null;
   }

package/src/resources/extensions/gsd/auto-budget.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Pure budget and context guard decisions for GSD auto-mode.
 /**
  * Budget alert level tracking and enforcement for auto-mode.

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -1,4 +1,4 @@
-// GSD-2 + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
+// gsd-pi + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
 
 /**
  * Auto-mode Dashboard — progress widget rendering, elapsed time formatting,

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 
 /**
@@ -1239,6 +1239,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
 
       const sid = state.activeSlice.id;
       const sTitle = state.activeSlice.title;
+      if (resolveSliceFile(basePath, mid, sid, "REACTIVE-BLOCKER")) return null;
       const maxParallel = reactiveConfig?.max_parallel ?? 2;
       const subagentModel = reactiveConfig?.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
       // Default-on safety threshold: only activate reactive dispatch when at

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-mode post-unit git, verification, projection, and hook processing.
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
@@ -43,6 +43,7 @@ import {
   writeBlockerPlaceholder,
   diagnoseExpectedArtifact,
   diagnoseWorktreeIntegrityFailure,
+  writeReactiveExecuteBlocker,
 } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
@@ -1804,6 +1805,32 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
             s.lastUnitAgentEndMessages,
           );
           if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
+            if (s.currentUnit.type === "reactive-execute") {
+              const recovery = writeReactiveExecuteBlocker(
+                s.currentUnit.id,
+                verificationBasePath,
+                failureDetails,
+              );
+              if (recovery) {
+                s.pendingVerificationRetry = null;
+                s.verificationRetryCount.delete(retryKey);
+                s.verificationRetryFailureHashes.delete(retryKey);
+                invalidateAllCaches();
+                debugLog("postUnit", {
+                  phase: "reactive-execute-blocker-recovery",
+                  unitType: s.currentUnit.type,
+                  unitId: s.currentUnit.id,
+                  blockerPath: recovery.blockerPath,
+                  completedTaskIds: recovery.completedTaskIds,
+                  skippedTaskIds: recovery.skippedTaskIds,
+                });
+                ctx.ui.notify(
+                  `${failureDetails} Wrote reactive blocker and advanced: ${recovery.completedTaskIds.length} complete, ${recovery.skippedTaskIds.length} skipped.`,
+                  "warning",
+                );
+                return "continue";
+              }
+            }
             s.exhaustedVerificationUnits.add(retryKey);
             debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
             ctx.ui.notify(

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Builds GSD auto-mode unit prompts and pre-dispatch checks.
 
 /**
@@ -670,7 +670,7 @@ export async function buildSliceSummaryExcerpt(
       lines.push(`**Key files:** ${files.join(", ")}${more}`);
     }
 
-    // Cap section bodies (coderabbit review on #4908): if any of these
+    // Cap section bodies (#4908): if any of these
     // narrative sections balloon, excerpt mode still inflates and
     // undermines the token-reduction goal. 800 chars (~200 tokens) is
     // enough to carry intent; the closer agent Reads the full file when