gsd-pi 2.75.0 → 2.76.0-dev.4100bd590

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,
@@ -758,16 +823,44 @@ export async function runGuards(ic, mid) {
         if (threshold) {
             s.lastBudgetAlertLevel =
                 newBudgetAlertLevel;
-            if (threshold.pct === 100 && budgetEnforcementAction !== "none") {
+            // Emit Layer 2 budget_threshold event (post-plan hook recommendation).
+            // Extensions / Layer 0 shell hooks may return an action override.
+            let hookAction;
+            try {
+                const { emitBudgetThreshold } = await import("../hook-emitter.js");
+                const hookResult = await emitBudgetThreshold({
+                    fraction: budgetPct,
+                    spent: totalCost,
+                    limit: budgetCeiling,
+                });
+                if (hookResult?.action)
+                    hookAction = hookResult.action;
+            }
+            catch (hookErr) {
+                logWarning("engine", `budget_threshold hook emission failed: ${hookErr.message}`);
+            }
+            // Apply hook override to enforcement action. "continue" → "none" (no enforcement),
+            // "pause" and "downgrade" map to the matching enforcement path below.
+            let effectiveAction = budgetEnforcementAction;
+            if (hookAction === "continue") {
+                effectiveAction = "none";
+            }
+            else if (hookAction === "pause") {
+                effectiveAction = "pause";
+            }
+            else if (hookAction === "downgrade") {
+                effectiveAction = "warn";
+            }
+            if (threshold.pct === 100 && effectiveAction !== "none") {
                 // 100% — special enforcement logic (halt/pause/warn)
                 const msg = `Budget ceiling ${deps.formatCost(budgetCeiling)} reached (spent ${deps.formatCost(totalCost)}).`;
-                if (budgetEnforcementAction === "halt") {
+                if (effectiveAction === "halt") {
                     deps.sendDesktopNotification("GSD", msg, "error", "budget", basename(s.originalBasePath || s.basePath));
                     await deps.stopAuto(ctx, pi, "Budget ceiling reached");
                     debugLog("autoLoop", { phase: "exit", reason: "budget-halt" });
                     return { action: "break", reason: "budget-halt" };
                 }
-                if (budgetEnforcementAction === "pause") {
+                if (effectiveAction === "pause") {
                     ctx.ui.notify(`${msg} Pausing auto-mode — /gsd auto to override and continue.`, "warning");
                     deps.sendDesktopNotification("GSD", msg, "warning", "budget", basename(s.originalBasePath || s.basePath));
                     deps.logCmuxEvent(prefs, msg, "warning");
@@ -908,6 +1001,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 +1055,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
@@ -1106,20 +1201,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
     }
     if (unitResult.status === "cancelled") {
+        const errorCategory = unitResult.errorContext?.category;
         // Provider-error pause: pauseAuto already handled cleanup and scheduled
         // recovery. Don't hard-stop — just break out of the loop (#2762).
-        if (unitResult.errorContext?.category === "provider") {
+        if (errorCategory === "provider") {
             await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-            debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
+            debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext?.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
         // Timeout category covers two distinct scenarios:
         //   1. Session creation timeout (120s) — transient, auto-resume with backoff
         //   2. Unit hard timeout (30min+) — stuck agent, pause for manual review
+        // Transient session-failed covers recoverable newSession failures and should
+        // pause instead of hard-stopping.
         // Structural errors (TypeError, is not a function) are NOT transient
         // and must hard-stop to avoid infinite retry loops.
         if (unitResult.errorContext?.isTransient &&
-            unitResult.errorContext?.category === "timeout") {
+            errorCategory === "timeout") {
             const isSessionCreationTimeout = unitResult.errorContext.message?.includes("Session creation timed out");
             if (isSessionCreationTimeout) {
                 consecutiveSessionTimeouts += 1;
@@ -1162,6 +1260,15 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             return { action: "break", reason: "unit-hard-timeout" };
         }
+        if (unitResult.errorContext?.isTransient &&
+            errorCategory === "session-failed") {
+            ctx.ui.notify(`Session creation failed transiently for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Pausing auto-mode (recoverable).`, "warning");
+            debugLog("autoLoop", { phase: "session-start-transient-pause", unitType, unitId, category: errorCategory });
+            await deps.pauseAuto(ctx, pi);
+            await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
+            return { action: "break", reason: "session-timeout" };
+        }
         // All other cancelled states (structural errors, non-transient failures): hard stop
         if (s.currentUnit) {
             await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
@@ -1214,7 +1321,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 +1406,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 +1467,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":