gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.96d4bb599

package/dist/resources/extensions/gsd/auto/detect-stuck.js

@@ -16,6 +16,7 @@ const ENOENT_PATH_RE = /ENOENT[^']*'([^']+)'/;
  *
  * Rule 1: Same error string twice in a row → stuck immediately.
  * Rule 2: Same unit key 3+ consecutive times → stuck (preserves prior behavior).
+ * Rule 2b: Same unit key appears 3+ times anywhere in the active window → stuck.
  * Rule 3: Oscillation A→B→A→B in last 4 entries → stuck.
  * Rule 4: Same ENOENT path in any 2 entries within the window → stuck (#3575).
  *         Missing files don't self-heal between retries — retrying wastes budget.
@@ -48,6 +49,14 @@ export function detectStuck(window) {
             };
         }
     }
+    // Rule 2b: Same unit key 3+ times anywhere in the active window
+    const countInWindow = window.filter((entry) => entry.key === last.key).length;
+    if (countInWindow >= 3) {
+        return {
+            stuck: true,
+            reason: `${last.key} derived ${countInWindow} times in last ${window.length} attempts without progress${suffix}`,
+        };
+    }
     // Rule 3: Oscillation (A→B→A→B in last 4)
     if (window.length >= 4) {
         const w = window.slice(-4);

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

@@ -17,6 +17,7 @@ import { logWarning } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { scheduleSidecarQueue } from "../uok/execution-graph.js";
+import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 // ── Stuck detection persistence (#3704) ──────────────────────────────────
@@ -78,17 +79,73 @@ function checkMemoryPressure() {
     const pct = heapMB / limitMB;
     return { pressured: pct > MEMORY_PRESSURE_THRESHOLD, heapMB, limitMB, pct };
 }
+function resolveDispatchNodeKind(unitType, sidecarItem) {
+    if (sidecarItem?.kind === "hook")
+        return "hook";
+    if (sidecarItem?.kind === "triage")
+        return "verification";
+    if (sidecarItem?.kind === "quick-task")
+        return "team-worker";
+    if (unitType.startsWith("hook/"))
+        return "hook";
+    if (unitType === "reactive-execute")
+        return "subagent";
+    if (unitType === "gate-evaluate"
+        || unitType === "validate-milestone"
+        || unitType === "run-uat"
+        || unitType === "complete-slice") {
+        return "verification";
+    }
+    if (unitType === "replan-slice" || unitType === "reassess-roadmap") {
+        return "reprocess";
+    }
+    return "unit";
+}
+async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem) {
+    if (dispatchContract === "legacy-direct") {
+        return runUnitPhase(ic, iterData, loopState, sidecarItem);
+    }
+    const scheduler = new ExecutionGraphScheduler();
+    let outcome = null;
+    const executeNode = async () => {
+        outcome = await runUnitPhase(ic, iterData, loopState, sidecarItem);
+    };
+    const kinds = [
+        "unit",
+        "hook",
+        "subagent",
+        "team-worker",
+        "verification",
+        "reprocess",
+    ];
+    for (const kind of kinds)
+        scheduler.registerHandler(kind, executeNode);
+    const nodeId = `dispatch:${ic.iteration}:${iterData.unitType}:${iterData.unitId}`;
+    await scheduler.run([
+        {
+            id: nodeId,
+            kind: resolveDispatchNodeKind(iterData.unitType, sidecarItem),
+            dependsOn: [],
+            metadata: {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            },
+        },
+    ], { parallel: false, maxWorkers: 1 });
+    return outcome ?? { action: "break", reason: "scheduler-dispatch-missing-result" };
+}
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
  * terminal condition is reached.
  *
  * This is the linear replacement for the recursive
- * dispatchNextUnit → handleAgentEnd → dispatchNextUnit chain.
+ * dispatchNextUnit → resolveAgentEnd → dispatchNextUnit chain.
  */
-export async function autoLoop(ctx, pi, s, deps) {
+export async function autoLoop(ctx, pi, s, deps, options) {
     debugLog("autoLoop", { phase: "enter" });
     let iteration = 0;
+    const dispatchContract = options?.dispatchContract ?? "legacy-direct";
     // Load persisted stuck state so counters survive session restarts (#3704)
     const persisted = loadStuckState(s.basePath);
     const loopState = {
@@ -273,7 +330,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     break;
                 }
                 // ── Unit execution (shared with dev path) ──
-                const unitPhaseResult = await runUnitPhase(ic, iterData, loopState);
+                const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState);
                 deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
@@ -410,7 +467,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     sidecarKind: sidecarItem.kind,
                 });
             }
-            const unitPhaseResult = await runUnitPhase(ic, iterData, loopState, sidecarItem);
+            const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem);
             deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,
@@ -528,3 +585,9 @@ export async function autoLoop(ctx, pi, s, deps) {
     _clearCurrentResolve();
     debugLog("autoLoop", { phase: "exit", totalIterations: iteration });
 }
+export async function runUokKernelLoop(ctx, pi, s, deps) {
+    return autoLoop(ctx, pi, s, deps, { dispatchContract: "uok-scheduler" });
+}
+export async function runLegacyAutoLoop(ctx, pi, s, deps) {
+    return autoLoop(ctx, pi, s, deps, { dispatchContract: "legacy-direct" });
+}

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

@@ -33,7 +33,7 @@ import { UokGateRunner } from "../uok/gate-runner.js";
 import { resetEvidence } from "../safety/evidence-collector.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
-import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "../workflow-mcp.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, supportsStructuredQuestions, } from "../workflow-mcp.js";
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
@@ -136,6 +136,47 @@ async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorCon
         causedBy: { flowId: ic.flowId, seq: unitStartSeq },
     });
 }
+async function failClosedOnFinalizeTimeout(ic, iterData, loopState, stage, startedAt) {
+    const { ctx, pi, s, deps } = ic;
+    const now = Date.now();
+    const unitType = iterData.unitType;
+    const unitId = iterData.unitId;
+    const timeoutMs = stage === "pre" ? FINALIZE_PRE_TIMEOUT_MS : FINALIZE_POST_TIMEOUT_MS;
+    const progressKind = stage === "pre" ? "finalize-pre-timeout" : "finalize-post-timeout";
+    writeUnitRuntimeRecord(s.basePath, unitType, unitId, startedAt, {
+        phase: "finalize-timeout",
+        timeoutAt: now,
+        lastProgressAt: now,
+        lastProgressKind: progressKind,
+    });
+    deps.emitJournalEvent({
+        ts: new Date(now).toISOString(),
+        flowId: ic.flowId,
+        seq: ic.nextSeq(),
+        eventType: "unit-end",
+        data: {
+            unitType,
+            unitId,
+            status: "timed-out-finalize",
+            artifactVerified: false,
+            finalizeStage: stage,
+        },
+    });
+    loopState.consecutiveFinalizeTimeouts++;
+    debugLog("autoLoop", {
+        phase: progressKind,
+        iteration: ic.iteration,
+        unitType,
+        unitId,
+        consecutiveTimeouts: loopState.consecutiveFinalizeTimeouts,
+    });
+    ctx.ui.notify(`${stage === "pre" ? "postUnitPreVerification" : "postUnitPostVerification"} timed out after ${timeoutMs / 1000}s for ${unitType} ${unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — pausing auto-mode for recovery.`, "warning");
+    await deps.pauseAuto(ctx, pi);
+    s.currentUnit = null;
+    clearCurrentPhase();
+    drainLogs();
+    return { action: "break", reason: progressKind };
+}
 // ─── runPreDispatch ───────────────────────────────────────────────────────────
 /**
  * Phase 1: Pre-dispatch — resource guard, health gate, state derivation,
@@ -548,6 +589,15 @@ export async function runDispatch(ic, preData, loopState) {
     const { ctx, pi, s, deps, prefs } = ic;
     const { state, mid, midTitle } = preData;
     const STUCK_WINDOW_SIZE = 6;
+    const provider = ctx.model?.provider;
+    const authMode = provider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
+        ? ctx.modelRegistry.getProviderAuthMode(provider)
+        : undefined;
+    const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+    const structuredQuestionsAvailable = supportsStructuredQuestions(activeTools, {
+        authMode,
+        baseUrl: ctx.model?.baseUrl,
+    }) ? "true" : "false";
     debugLog("autoLoop", { phase: "dispatch-resolve", iteration: ic.iteration });
     const dispatchResult = await deps.resolveDispatch({
         basePath: s.basePath,
@@ -556,6 +606,7 @@ export async function runDispatch(ic, preData, loopState) {
         state,
         prefs,
         session: s,
+        structuredQuestionsAvailable,
     });
     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 } });
@@ -604,6 +655,18 @@ export async function runDispatch(ic, preData, loopState) {
                 loopState.stuckRecoveryAttempts++;
                 const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
                 if (artifactExists) {
+                    if (unitType === "complete-milestone") {
+                        const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
+                        const stuckParts = [
+                            `Detected ${unitType} ${unitId} output on disk, but the same unit is still being derived.`,
+                            "This usually means the milestone summary exists while the DB row still does not mark the milestone complete.",
+                        ];
+                        if (stuckDiag)
+                            stuckParts.push(`Expected: ${stuckDiag}`);
+                        ctx.ui.notify(stuckParts.join(" "), "warning");
+                        await deps.pauseAuto(ctx, pi);
+                        return { action: "break", reason: "complete-milestone-artifact-db-mismatch" };
+                    }
                     debugLog("autoLoop", {
                         phase: "stuck-recovery",
                         level: 1,
@@ -908,6 +971,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     // per-unit. Without this, the module-level _buffer accumulates across every
     // unit in the same Node process (see workflow-logger.ts module header).
     _resetLogs();
+    const dispatchKey = `${unitType}/${unitId}`;
+    s.unitDispatchCount.set(dispatchKey, (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1);
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
     s.lastGitActionFailure = null;
     s.lastGitActionStatus = null;
@@ -960,7 +1025,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         finalPrompt = `${capped}\n\n---\n\n${finalPrompt}`;
         s.pendingCrashRecovery = null;
     }
-    else if ((s.unitDispatchCount.get(`${unitType}/${unitId}`) ?? 0) > 1) {
+    else if ((s.unitDispatchCount.get(dispatchKey) ?? 0) > 1) {
         const diagnostic = deps.getDeepDiagnostic(s.basePath);
         if (diagnostic) {
             const cappedDiag = diagnostic.length > MAX_RECOVERY_CHARS
@@ -1214,7 +1279,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const artifactVerified = skipArtifactVerification ||
         verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
-        s.unitDispatchCount.delete(`${unitType}/${unitId}`);
+        s.unitDispatchCount.delete(dispatchKey);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
     // Write phase handoff anchor after successful research/planning completion
@@ -1299,28 +1364,7 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         : null;
     const preResultGuard = await withTimeout(deps.postUnitPreVerification(postUnitCtx, preVerificationOpts), FINALIZE_PRE_TIMEOUT_MS, "postUnitPreVerification");
     if (preResultGuard.timedOut) {
-        // Detach session from the timed-out unit so late async completions
-        // cannot mutate state for the next unit (#3757).
-        s.currentUnit = null;
-        clearCurrentPhase();
-        // Drop any logger entries from the timed-out unit so they don't bleed
-        // into the next iteration's drain.
-        drainLogs();
-        loopState.consecutiveFinalizeTimeouts++;
-        debugLog("autoLoop", {
-            phase: "pre-verification-timeout",
-            iteration: ic.iteration,
-            unitType: iterData.unitType,
-            unitId: iterData.unitId,
-            consecutiveTimeouts: loopState.consecutiveFinalizeTimeouts,
-        });
-        if (loopState.consecutiveFinalizeTimeouts >= MAX_FINALIZE_TIMEOUTS) {
-            ctx.ui.notify(`postUnitPreVerification timed out ${loopState.consecutiveFinalizeTimeouts} consecutive times — stopping auto-mode to prevent budget waste`, "error");
-            await deps.stopAuto(ctx, pi, `${loopState.consecutiveFinalizeTimeouts} consecutive finalize timeouts`);
-            return { action: "break", reason: "finalize-timeout-escalation" };
-        }
-        ctx.ui.notify(`postUnitPreVerification timed out after ${FINALIZE_PRE_TIMEOUT_MS / 1000}s for ${iterData.unitType} ${iterData.unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — continuing to next iteration`, "warning");
-        return { action: "next", data: undefined };
+        return failClosedOnFinalizeTimeout(ic, iterData, loopState, "pre", preUnitSnapshot?.startedAt ?? Date.now());
     }
     const preResult = preResultGuard.value;
     if (preResult === "dispatched") {
@@ -1381,28 +1425,7 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     // auto-loop is not permanently frozen (#2344).
     const postResultGuard = await withTimeout(deps.postUnitPostVerification(postUnitCtx), FINALIZE_POST_TIMEOUT_MS, "postUnitPostVerification");
     if (postResultGuard.timedOut) {
-        // Detach session from the timed-out unit so late async completions
-        // cannot mutate state for the next unit (#3757).
-        s.currentUnit = null;
-        clearCurrentPhase();
-        // Drop any logger entries from the timed-out unit so they don't bleed
-        // into the next iteration's drain.
-        drainLogs();
-        loopState.consecutiveFinalizeTimeouts++;
-        debugLog("autoLoop", {
-            phase: "post-verification-timeout",
-            iteration: ic.iteration,
-            unitType: iterData.unitType,
-            unitId: iterData.unitId,
-            consecutiveTimeouts: loopState.consecutiveFinalizeTimeouts,
-        });
-        if (loopState.consecutiveFinalizeTimeouts >= MAX_FINALIZE_TIMEOUTS) {
-            ctx.ui.notify(`postUnitPostVerification timed out ${loopState.consecutiveFinalizeTimeouts} consecutive times — stopping auto-mode to prevent budget waste`, "error");
-            await deps.stopAuto(ctx, pi, `${loopState.consecutiveFinalizeTimeouts} consecutive finalize timeouts`);
-            return { action: "break", reason: "finalize-timeout-escalation" };
-        }
-        ctx.ui.notify(`postUnitPostVerification timed out after ${FINALIZE_POST_TIMEOUT_MS / 1000}s for ${iterData.unitType} ${iterData.unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — continuing to next iteration`, "warning");
-        return { action: "next", data: undefined };
+        return failClosedOnFinalizeTimeout(ic, iterData, loopState, "post", preUnitSnapshot?.startedAt ?? Date.now());
     }
     const postResult = postResultGuard.value;
     if (postResult === "stopped") {

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

@@ -60,7 +60,7 @@ export function isSessionSwitchInFlight() {
 /**
  * Force-resolve the pending unit promise with { status: "cancelled" }.
  *
- * Used by pauseAuto, handleAgentEnd early-return, and supervision catch
+ * Used by pauseAuto and supervision catch
  * blocks to ensure the autoLoop is never stuck awaiting a promise that
  * will never resolve. Safe to call when no resolver is pending (no-op).
  */

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

@@ -62,7 +62,16 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (s.currentUnitModel && typeof pi.setModel === "function") {
         const restored = await pi.setModel(s.currentUnitModel, { persist: false });
         if (!restored) {
-            ctx.ui.notify(`Failed to restore ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation. Using session default.`, "warning");
+            const message = `Failed to restore configured model ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation`;
+            ctx.ui.notify(`${message}. Cancelling unit before dispatch.`, "warning");
+            return {
+                status: "cancelled",
+                errorContext: {
+                    message,
+                    category: "session-failed",
+                    isTransient: false,
+                },
+            };
         }
     }
     // ── Create the agent_end promise (per-unit one-shot) ──

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

@@ -107,6 +107,9 @@ export class AutoSession {
     checkpointSha = null;
     // ── Signal handler ───────────────────────────────────────────────────────
     sigtermHandler = null;
+    // ── Remote command polling ───────────────────────────────────────────────
+    /** Cleanup function returned by startCommandPolling(); null when not running. */
+    commandPollingCleanup = null;
     // ── Loop promise state ──────────────────────────────────────────────────
     // Per-unit resolve function and session-switch guard live at module level
     // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -200,6 +203,8 @@ export class AutoSession {
         this.checkpointSha = null;
         // Signal handler
         this.sigtermHandler = null;
+        // Remote command polling — cleanup must be called before reset (auto.ts stopAuto)
+        this.commandPollingCleanup = null;
         // Loop promise state lives in auto-loop.ts module scope
     }
     toJSON() {

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

@@ -29,6 +29,16 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             return dir ? join(dir, buildMilestoneFileName(mid, "ROADMAP")) : null;
         }
         case "research-slice": {
+            // #4414: Sentinel unitId "{mid}/parallel-research" fans out across
+            // multiple slices. Resolve to a milestone-level placeholder path so
+            // blocker escalation has somewhere to write. Verification for this
+            // sentinel is handled directly in verifyExpectedArtifact.
+            if (sid === "parallel-research") {
+                const mdir = resolveMilestonePath(base, mid);
+                return mdir
+                    ? join(mdir, buildMilestoneFileName(mid, "PARALLEL-BLOCKER"))
+                    : null;
+            }
             const dir = resolveSlicePath(base, mid, sid);
             return dir ? join(dir, buildSliceFileName(sid, "RESEARCH")) : null;
         }
@@ -36,6 +46,11 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             const dir = resolveSlicePath(base, mid, sid);
             return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
         }
+        case "refine-slice": {
+            // ADR-011: refine-slice expands a sketch and writes the same PLAN.md as plan-slice.
+            const dir = resolveSlicePath(base, mid, sid);
+            return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
+        }
         case "reassess-roadmap": {
             const dir = resolveSlicePath(base, mid, sid);
             return dir ? join(dir, buildSliceFileName(sid, "ASSESSMENT")) : null;
@@ -90,9 +105,14 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
         case "plan-milestone":
             return `${relMilestoneFile(base, mid, "ROADMAP")} (milestone roadmap)`;
         case "research-slice":
+            if (sid === "parallel-research") {
+                return `${relMilestoneFile(base, mid, "PARALLEL-BLOCKER")} (parallel slice research sentinel)`;
+            }
             return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
         case "plan-slice":
             return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
+        case "refine-slice":
+            return `${relSliceFile(base, mid, sid, "PLAN")} (refined slice plan from sketch)`;
         case "execute-task": {
             return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
         }

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

@@ -45,6 +45,7 @@ export function unitVerb(unitType) {
         case "research-slice": return "researching";
         case "plan-milestone":
         case "plan-slice": return "planning";
+        case "refine-slice": return "refining";
         case "execute-task": return "executing";
         case "complete-slice": return "completing";
         case "replan-slice": return "replanning";
@@ -65,6 +66,7 @@ export function unitPhaseLabel(unitType) {
         case "research-slice": return "RESEARCH";
         case "plan-milestone": return "PLAN";
         case "plan-slice": return "PLAN";
+        case "refine-slice": return "REFINE";
         case "execute-task": return "EXECUTE";
         case "complete-slice": return "COMPLETE";
         case "replan-slice": return "REPLAN";
@@ -91,6 +93,7 @@ function peekNext(unitType, state) {
         case "plan-milestone": return "plan or execute first slice";
         case "research-slice": return `plan ${sid}`;
         case "plan-slice": return "execute first task";
+        case "refine-slice": return "execute first task";
         case "execute-task": return `continue ${sid}`;
         case "complete-slice": return "reassess roadmap";
         case "replan-slice": return `re-execute ${sid}`;
@@ -753,13 +756,18 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     }
                     if (cumulativeCost)
                         sp.push(theme.fg("warning", `$${cumulativeCost.toFixed(2)}`));
-                    const cxDisplay = `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
-                    if (cxPctVal > 90)
-                        sp.push(theme.fg("error", cxDisplay));
-                    else if (cxPctVal > 70)
-                        sp.push(theme.fg("warning", cxDisplay));
-                    else
-                        sp.push(cxDisplay);
+                    const CX_BAR_WIDTH = 8;
+                    const cxBarFilled = Math.min(CX_BAR_WIDTH, Math.max(0, Math.round((cxPctVal / 100) * CX_BAR_WIDTH)));
+                    const cxBarColor = cxPctVal > 90 ? "error" : cxPctVal > 70 ? "warning" : "success";
+                    const cxBar = theme.fg(cxBarColor, "━".repeat(cxBarFilled)) +
+                        theme.fg("dim", "─".repeat(CX_BAR_WIDTH - cxBarFilled));
+                    const cxPctText = `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
+                    const cxColorized = cxPctVal > 90
+                        ? theme.fg("error", cxPctText)
+                        : cxPctVal > 70
+                            ? theme.fg("warning", cxPctText)
+                            : cxPctText;
+                    sp.push(`${cxBar} ${cxColorized}`);
                     const statsLine = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
                         .join(theme.fg("dim", "  "));
                     if (statsLine) {

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

@@ -9,7 +9,8 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, updateMilestoneStatus } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -17,7 +18,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
-import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
@@ -111,6 +112,26 @@ export function isVerificationNotApplicable(value) {
 }
 // ─── Rules ────────────────────────────────────────────────────────────────
 export const DISPATCH_RULES = [
+    {
+        // ADR-011 Phase 2: pause-for-escalation must evaluate FIRST so phase-
+        // agnostic rules (rewrite-docs gate, UAT checks, reassess) cannot bypass
+        // the user's pending decision. Only fires for continueWithDefault=false
+        // escalations (those set escalation_pending=1); awaiting-review artifacts
+        // never enter the 'escalating-task' phase.
+        name: "escalating-task → pause-for-escalation",
+        match: async ({ state, mid }) => {
+            if (state.phase !== "escalating-task")
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            return {
+                action: "stop",
+                reason: state.nextAction ||
+                    `${mid}: task escalation awaits user resolution. Run /gsd escalate list to see pending items.`,
+                level: "info",
+            };
+        },
+    },
     {
         name: "rewrite-docs (override gate)",
         match: async ({ mid, midTitle, state, basePath, session }) => {
@@ -238,20 +259,20 @@ export const DISPATCH_RULES = [
     },
     {
         name: "needs-discussion → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
             if (state.phase !== "needs-discussion")
                 return null;
             return {
                 action: "dispatch",
                 unitType: "discuss-milestone",
                 unitId: mid,
-                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath),
+                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable),
             };
         },
     },
     {
         name: "pre-planning (no context) → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
             const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
@@ -262,7 +283,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "discuss-milestone",
                 unitId: mid,
-                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath),
+                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable),
             };
         },
     },
@@ -334,6 +355,12 @@ export const DISPATCH_RULES = [
             // Only dispatch parallel if 2+ slices are ready
             if (researchReadySlices.length < 2)
                 return null;
+            // #4414: If a previous parallel-research attempt escalated to a blocker
+            // placeholder, skip this rule and fall through to per-slice research
+            // (or other rules) rather than re-dispatching the same failing unit.
+            const parallelBlocker = resolveMilestoneFile(basePath, mid, "PARALLEL-BLOCKER");
+            if (parallelBlocker)
+                return null;
             return {
                 action: "dispatch",
                 unitType: "research-slice",
@@ -370,6 +397,58 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        // ADR-011: sketch-then-refine. When `refining` phase fires, expand the
+        // sketch into a full plan using the prior slice's SUMMARY and the current
+        // codebase. If the user flipped `progressive_planning` off mid-milestone
+        // while a slice is still `is_sketch=1`, fall through to a standard
+        // plan-slice so the loop doesn't dead-end.
+        //
+        // Note on the flag-OFF downgrade: plan-slice does not explicitly clear
+        // `is_sketch`. After it writes PLAN.md, the auto-heal in state.ts's
+        // `deriveStateFromDb` (via `autoHealSketchFlags`) flips the flag on the
+        // next iteration. That implicit coupling is the sole mechanism that
+        // reconciles `is_sketch=1` on the plan-slice path — do not remove the
+        // auto-heal without either adding an explicit `setSliceSketchFlag(..., false)`
+        // call here or doing so inside the plan-slice tool handler.
+        name: "refining → refine-slice",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "refining")
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            const progressiveOn = prefs?.phases?.progressive_planning === true;
+            if (!progressiveOn) {
+                // Graceful downgrade: treat the sketch as a normal slice needing a plan,
+                // but forward the stored sketch_scope as a SOFT hint so the scope
+                // signal isn't silently lost. The planner may expand beyond it.
+                let softScopeHint = "";
+                try {
+                    const { isDbAvailable, getSlice } = await import("./gsd-db.js");
+                    if (isDbAvailable()) {
+                        softScopeHint = getSlice(mid, sid)?.sketch_scope ?? "";
+                    }
+                }
+                catch {
+                    softScopeHint = "";
+                }
+                return {
+                    action: "dispatch",
+                    unitType: "plan-slice",
+                    unitId: `${mid}/${sid}`,
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, softScopeHint ? { softScopeHint } : undefined),
+                };
+            }
+            return {
+                action: "dispatch",
+                unitType: "refine-slice",
+                unitId: `${mid}/${sid}`,
+                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+            };
+        },
+    },
     {
         name: "planning → plan-slice",
         match: async ({ state, mid, midTitle, basePath }) => {
@@ -600,6 +679,33 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "completing-milestone")
                 return null;
+            // Defense-in-depth (#4324): skip dispatch if the DB already marks
+            // this milestone as complete. Prevents re-enqueue when the legacy
+            // filesystem state-derivation path runs (e.g. transient DB
+            // unavailability) and produces a stale completing-milestone phase.
+            if (isDbAvailable()) {
+                const milestone = getMilestone(mid);
+                if (milestone && isClosedStatus(milestone.status)) {
+                    return { action: "skip" };
+                }
+            }
+            // Reconciliation guard (#4324): when the SUMMARY file already exists
+            // on disk but the DB says the milestone is not complete, the DB is
+            // out of sync (e.g. journal reset, partial merge, crash recovery).
+            // Reconcile the DB status directly instead of re-dispatching the
+            // tool, which would overwrite the richer on-disk SUMMARY with a
+            // thinner regenerated version — causing silent data loss.
+            const existingSummary = resolveMilestoneFile(basePath, mid, "SUMMARY");
+            if (existingSummary && isDbAvailable()) {
+                try {
+                    updateMilestoneStatus(mid, "complete", new Date().toISOString());
+                    logWarning("dispatch", `Milestone ${mid} has SUMMARY on disk but DB status was not complete — reconciled DB to complete (#4324)`);
+                }
+                catch (err) {
+                    logWarning("dispatch", `Failed to reconcile milestone ${mid} status: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                return { action: "skip" };
+            }
             // Safety guard (#2675): block completion when VALIDATION verdict is
             // needs-remediation. The state machine treats needs-remediation as
             // terminal (to prevent validate-milestone loops per #832), but