gsd-pi 2.75.0 → 2.76.0

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,9 @@ export async function runDispatch(ic, preData, loopState) {
         state,
         prefs,
         session: s,
+        structuredQuestionsAvailable,
+        sessionContextWindow: ctx.model?.contextWindow,
+        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 } });
@@ -604,6 +657,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 +973,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 +1027,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 +1281,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 +1366,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 +1427,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

@@ -9,6 +9,7 @@ import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
+import { nativeIsRepo } from "./native-git-bridge.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -45,6 +46,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 +67,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 +94,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}`;
@@ -253,6 +257,10 @@ let cachedLastCommit = null;
 let lastCommitFetchedAt = 0;
 function refreshLastCommit(basePath) {
     try {
+        if (!nativeIsRepo(basePath)) {
+            cachedLastCommit = null;
+            return;
+        }
         const raw = execFileSync("git", ["log", "-1", "--format=%cr|%s"], {
             cwd: basePath,
             encoding: "utf-8",
@@ -266,12 +274,15 @@ function refreshLastCommit(basePath) {
                 message: raw.slice(sep + 1),
             };
         }
-        lastCommitFetchedAt = Date.now();
     }
     catch (err) {
         // Non-fatal — just skip last commit display
+        cachedLastCommit = null;
         logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    finally {
+        lastCommitFetchedAt = Date.now();
+    }
 }
 function getLastCommit(basePath) {
     // Refresh at most every 15 seconds
@@ -280,6 +291,19 @@ function getLastCommit(basePath) {
     }
     return cachedLastCommit;
 }
+export function _resetLastCommitCacheForTests() {
+    cachedLastCommit = null;
+    lastCommitFetchedAt = 0;
+}
+export function _refreshLastCommitForTests(basePath) {
+    refreshLastCommit(basePath);
+}
+export function _getLastCommitForTests(basePath) {
+    return getLastCommit(basePath);
+}
+export function _getLastCommitFetchedAtForTests() {
+    return lastCommitFetchedAt;
+}
 // ─── Footer Factory ───────────────────────────────────────────────────────────
 /**
  * Footer factory used by auto-mode.
@@ -753,13 +777,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-direct-dispatch.js

@@ -68,7 +68,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "plan-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
+                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base, undefined, {
+                    sessionContextWindow: ctx.model?.contextWindow,
+                    modelRegistry: ctx.modelRegistry,
+                });
             }
             else {
                 unitType = "plan-milestone";
@@ -93,7 +96,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "execute-task";
             unitId = `${mid}/${sid}/${tid}`;
-            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
+            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+                sessionContextWindow: ctx.model?.contextWindow,
+                modelRegistry: ctx.modelRegistry,
+            });
             break;
         }
         case "complete":