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

package/dist/resources/extensions/gsd/auto/phases.js

@@ -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.
@@ -53,6 +53,11 @@ import { getConsecutiveDispatchBlocker } from "../dispatch-guard.js";
 import { captureRootDirtySnapshot, detectRootWriteLeak, formatRootWriteLeakMessage, } from "../root-write-leak-guard.js";
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
+export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
+    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, b) {
@@ -619,6 +624,7 @@ export async function runPreDispatch(ic, loopState) {
     s.lastBaselineCharCount = undefined;
     // Pre-dispatch health gate
     try {
+        const expectedCurrentUnit = null;
         const healthGate = await deps.preDispatchHealthGate(s.basePath);
         if (healthGate.fixesApplied.length > 0) {
             ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
@@ -633,7 +639,7 @@ export async function runPreDispatch(ic, loopState) {
                 findings: healthGate.reason,
             });
             ctx.ui.notify(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" };
         }
@@ -1029,6 +1035,12 @@ export async function runPreDispatch(ic, loopState) {
     return { action: "next", data: { state, mid, midTitle } };
 }
 // ─── runDispatch ──────────────────────────────────────────────────────────────
+function isUnhandledPhaseWarning(dispatchResult) {
+    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.
@@ -1052,7 +1064,7 @@ export async function runDispatch(ic, preData, loopState) {
             baseUrl: ctx.model?.baseUrl,
         }) ? "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,
@@ -1064,6 +1076,30 @@ export async function runDispatch(ic, preData, loopState) {
         sessionProvider: ctx.model?.provider,
         modelRegistry: ctx.modelRegistry,
     });
+    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,
+        });
+    }
     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 } });
         // Warning-level stops are recoverable human checkpoints (e.g. UAT verdict
@@ -1724,7 +1760,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         lastProgressAt: unitStartedAt,
         progressCount: 0,
         lastProgressKind: "dispatch",
-        recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
+        recoveryAttempts: resolveDispatchRecoveryAttempts(s.unitRecoveryCount, unitType, unitId),
     });
     // Progress widget + preconditions — deferred to after model selection so the
     // widget's first render tick shows the correct model (#2899).

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -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.
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
 import { _clearCurrentResolve, _consumePendingSwitchCancellation, _markSessionSwitchAbortGraceWindow, _setCurrentResolve, _setSessionSwitchInFlight, } from "./resolve.js";
 import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
@@ -6,8 +6,11 @@ import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord } 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, opts) {
     if (!runtime)
         return false;
@@ -30,6 +33,15 @@ export function shouldDeferUnitFailsafeTimeout(runtime, opts) {
         return true;
     return progressAgeMs >= 0 && progressAgeMs <= opts.freshProgressMs;
 }
+async function sleepForScheduledWakeup(s, delayMs) {
+    const deadline = Date.now() + Math.max(0, delayMs);
+    while (Date.now() < deadline) {
+        if (!s.active || s.paused)
+            return false;
+        await new Promise((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;
@@ -174,51 +186,105 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     let unitTimeoutHandle;
     let result;
     try {
+        const awaitAgentEndWithTimeout = (agentEndPromise) => {
+            const timeoutResult = new Promise((resolve) => {
+                const settleOrDefer = () => {
+                    let runtime;
+                    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((resolve) => {
-            const settleOrDefer = () => {
-                let runtime;
-                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((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)

package/dist/resources/extensions/gsd/auto/schedule-wakeup.js

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

package/dist/resources/extensions/gsd/auto/session.js

@@ -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/dist/resources/extensions/gsd/auto/unit-runner-events.js

@@ -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.
 export function isInternalSessionTransitionAbortEvent(event) {
     return event.abortOrigin === "session-transition";
 }

package/dist/resources/extensions/gsd/auto/verification-retry-policy.js

@@ -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";
 export const VERIFICATION_RETRY_BASE_DELAY_MS = 2_000;

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-dispatch-outcome.js

@@ -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.
 export async function handleCustomEngineDispatchOutcome(input) {
     if (input.decision.action === "stop") {

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-iteration.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Custom-engine iteration-data adapter for auto-mode loop.
 export async function buildCustomEngineIterationData(input) {
     const gsdState = await input.deriveState(input.canonicalProjectRoot);

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-reconcile-outcome.js

@@ -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.
 export async function handleCustomEngineReconcileOutcome(input) {
     const details = {

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-reconcile.js

@@ -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 { decideEngineReconcile, } from "./workflow-kernel.js";
 export async function handleCustomEngineReconcile(input) {

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-retry.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Custom-engine verification retry adapter for auto-mode loop.
 import { decideCustomEngineRecovery, decideCustomEngineVerifyRetry, } from "./workflow-kernel.js";
 export async function handleCustomEngineVerifyRetry(input) {

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-verify-outcome.js

@@ -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.
 export async function handleCustomEngineVerifyPause(input) {
     await input.deps.pauseAuto();

package/dist/resources/extensions/gsd/auto/workflow-dispatch-claim.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
 const VIRTUAL_MILESTONE_IDS = new Set(["PROJECT"]);
 /**

package/dist/resources/extensions/gsd/auto/workflow-dispatch-ledger.js

@@ -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.
 export function settleDispatchFailed(dispatchId, errorSummary, deps) {
     if (dispatchId === null)

package/dist/resources/extensions/gsd/auto/workflow-iteration-completion.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Successful auto-mode iteration cleanup helper.
 export function completeWorkflowIteration(state, deps) {
     state.consecutiveErrors = 0;

package/dist/resources/extensions/gsd/auto/workflow-journal-reporter.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Thin adapter for auto-mode workflow journal event emission.
 export function createWorkflowJournalReporter(input) {
     const now = input.now ?? (() => new Date().toISOString());

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -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 function decideWorkflowLoop(input) {
     if (!input.active) {

package/dist/resources/extensions/gsd/auto/workflow-memory-pressure.js

@@ -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";
 const require = createRequire(import.meta.url);

package/dist/resources/extensions/gsd/auto/workflow-phase-reporter.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Thin adapter for auto-mode UOK phase-result reporting.
 export function createWorkflowPhaseReporter(input) {
     return {

package/dist/resources/extensions/gsd/auto/workflow-session-lock.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Session-lock validation adapter for auto-mode loop.
 import { decideWorkflowLoop, } from "./workflow-kernel.js";
 export function validateWorkflowSessionLock(input) {

package/dist/resources/extensions/gsd/auto/workflow-sidecar-iteration.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Sidecar iteration-data adapter for auto-mode loop.
 export async function buildSidecarIterationData(input) {
     const sidecarState = await input.deriveState(input.canonicalProjectRoot);

package/dist/resources/extensions/gsd/auto/workflow-sidecar-queue.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Sidecar queue scheduling and dequeue adapter for auto-mode loop.
 export async function dequeueSidecarItem(input) {
     if (input.queue.length === 0)

package/dist/resources/extensions/gsd/auto/workflow-turn-reporter.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Thin adapter for workflow turn observer reporting.
 export function createWorkflowTurnReporter(input) {
     let finished = false;

package/dist/resources/extensions/gsd/auto/workflow-unit-dispatch.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Unit dispatch contract adapter for auto-mode loop.
 import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
 import { runUnitPhase } from "./phases.js";

package/dist/resources/extensions/gsd/auto/workflow-worker-heartbeat.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Best-effort worker heartbeat adapter for auto-mode loop.
 export function maintainWorkerHeartbeat(session, deps) {
     if (!session.workerId)

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -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
 //
@@ -124,8 +124,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             // 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/dist/resources/extensions/gsd/auto-budget.js

@@ -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/dist/resources/extensions/gsd/auto-dashboard.js

@@ -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.
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, insertAssessment, setSliceSketchFlag, transaction, getAssessment } from "./gsd-db.js";
@@ -1043,6 +1043,8 @@ export const DISPATCH_RULES = [
                 return null;
             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/dist/resources/extensions/gsd/auto-post-unit.js

@@ -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,
@@ -23,7 +23,7 @@ import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { runTurnGitAction, } from "./git-service.js";
-import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, writeReactiveExecuteBlocker, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
@@ -1540,6 +1540,25 @@ export async function postUnitPreVerification(pctx, opts) {
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     const failureDetails = describeArtifactVerificationFailure(s.currentUnit.type, s.currentUnit.id, verificationBasePath, 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(`${failureDetails} Pausing auto-mode after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries.`, "error");

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Builds GSD auto-mode unit prompts and pre-dispatch checks.
 /**
  * Auto-mode Prompt Builders — construct dispatch prompts for each unit type.
@@ -584,7 +584,7 @@ export async function buildSliceSummaryExcerpt(absPath, relPath, sid) {
             const more = s.frontmatter.key_files.length > files.length ? ` (+${s.frontmatter.key_files.length - files.length} more)` : "";
             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