gsd-pi 2.79.0 → 2.80.0-dev.710c06e97

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

@@ -0,0 +1,263 @@
+// Project/App: GSD-2
+// File Purpose: Pure workflow-loop decisions for auto-mode before side-effect adapters run.
+export function decideWorkflowLoop(input) {
+    if (!input.active) {
+        return {
+            action: "stop",
+            reason: "inactive",
+            message: "Auto-mode is not active.",
+        };
+    }
+    if (input.iteration > input.maxIterations) {
+        return {
+            action: "stop",
+            reason: "max-iterations",
+            message: `Safety: loop exceeded ${input.maxIterations} iterations.`,
+        };
+    }
+    if (!input.hasCommandContext) {
+        return {
+            action: "stop",
+            reason: "missing-command-context",
+            message: "Auto-mode has no command context for dispatch.",
+        };
+    }
+    if (!input.sessionLockValid) {
+        return {
+            action: "stop",
+            reason: "session-lock-lost",
+            message: input.sessionLockReason
+                ? `Session lock lost: ${input.sessionLockReason}.`
+                : "Session lock lost.",
+        };
+    }
+    return { action: "continue" };
+}
+export function decideDispatchClaim(input) {
+    if (input.kind === "skip") {
+        return {
+            action: "skip",
+            reason: input.reason,
+        };
+    }
+    if (input.kind === "opened") {
+        return {
+            action: "run",
+            dispatchId: input.dispatchId,
+        };
+    }
+    return {
+        action: "run",
+        dispatchId: null,
+    };
+}
+export function decideEngineDispatch(input) {
+    if (input.action === "stop") {
+        return {
+            action: "stop",
+            reason: input.reason ?? "Engine stopped",
+        };
+    }
+    if (input.action === "skip") {
+        return { action: "skip" };
+    }
+    return { action: "dispatch" };
+}
+export function decideFinalizeResult(input) {
+    if (input.action === "break") {
+        const reason = input.reason ?? "unknown";
+        return {
+            action: "stop",
+            failureClass: reason === "git-closeout-failure" ? "git" : "closeout",
+            ledgerErrorSummary: `finalize-break:${reason}`,
+            turnError: "finalize-break",
+        };
+    }
+    if (input.action === "continue") {
+        return {
+            action: "retry",
+            ledgerErrorSummary: "finalize-retry",
+        };
+    }
+    return { action: "complete" };
+}
+export function decideEngineReconcile(input) {
+    if (input.outcome === "milestone-complete") {
+        return {
+            action: "complete-workflow",
+            stopReason: "Workflow complete",
+        };
+    }
+    if (input.outcome === "pause") {
+        return { action: "pause" };
+    }
+    if (input.outcome === "stop") {
+        return {
+            action: "stop",
+            reason: input.reason ?? "Engine stopped",
+        };
+    }
+    return { action: "continue" };
+}
+export function decideMemoryPressure(input) {
+    if (!input.pressured) {
+        return { action: "continue" };
+    }
+    const pct = Math.round(input.pct * 100);
+    return {
+        action: "stop",
+        warningMessage: `Memory pressure: ${input.heapMB}MB / ${input.limitMB}MB (${pct}%) — stopping auto-mode to prevent OOM kill`,
+        stopMessage: `Memory pressure: heap at ${input.heapMB}MB / ${input.limitMB}MB (${pct}%). ` +
+            `Stopping gracefully to prevent OOM kill after ${input.iteration} iterations. ` +
+            "Resume with /gsd auto to continue from where you left off.",
+        turnError: "memory-pressure",
+    };
+}
+export function decideMinRequestInterval(input) {
+    if (input.minIntervalMs <= 0 || input.lastRequestTimestamp <= 0) {
+        return { action: "continue" };
+    }
+    const elapsedMs = input.nowMs - input.lastRequestTimestamp;
+    if (elapsedMs >= input.minIntervalMs) {
+        return { action: "continue" };
+    }
+    return {
+        action: "wait",
+        waitMs: input.minIntervalMs - elapsedMs,
+    };
+}
+export function decideCooldownRecovery(input) {
+    if (input.consecutiveCooldowns > input.maxCooldownRetries) {
+        return {
+            action: "stop",
+            notifyMessage: `Auto-mode stopped: ${input.consecutiveCooldowns} consecutive credential cooldowns — ` +
+                "rate limit or quota may be persistently exhausted.",
+            stopMessage: `${input.consecutiveCooldowns} consecutive credential cooldowns exceeded retry budget`,
+        };
+    }
+    const waitMs = input.retryAfterMs !== undefined && input.retryAfterMs > 0 && input.retryAfterMs <= 60_000
+        ? input.retryAfterMs + 500
+        : input.fallbackWaitMs;
+    return {
+        action: "wait",
+        waitMs,
+        notifyMessage: `Credentials in cooldown (${input.consecutiveCooldowns}/${input.maxCooldownRetries}) — ` +
+            `waiting ${Math.round(waitMs / 1000)}s before retrying.`,
+    };
+}
+export function decideIterationErrorRecovery(input) {
+    if (input.consecutiveErrors >= 3) {
+        const errorHistory = input.recentErrorMessages
+            .map((message, index) => `  ${index + 1}. ${message}`)
+            .join("\n");
+        return {
+            action: "stop",
+            notifyMessage: `Auto-mode stopped: ${input.consecutiveErrors} consecutive iteration failures:\n${errorHistory}`,
+            stopMessage: `${input.consecutiveErrors} consecutive iteration failures`,
+            turnStatus: "failed",
+        };
+    }
+    if (input.consecutiveErrors === 2) {
+        return {
+            action: "invalidate-and-retry",
+            notifyMessage: `Iteration error (attempt ${input.consecutiveErrors}): ` +
+                `${input.currentErrorMessage}. Invalidating caches and retrying.`,
+            turnStatus: "retry",
+        };
+    }
+    return {
+        action: "retry",
+        notifyMessage: `Iteration error: ${input.currentErrorMessage}. Retrying.`,
+        turnStatus: "retry",
+    };
+}
+export function decideCustomEngineVerifyRetry(input) {
+    return input.attempts > input.maxRetries
+        ? { action: "recover" }
+        : { action: "retry" };
+}
+export function shouldUseCustomEnginePath(input) {
+    return input.activeEngineId != null
+        && input.activeEngineId !== "dev"
+        && !input.hasSidecarItem
+        && !input.engineBypass;
+}
+export function resolveUnitRequestTimestamp(input) {
+    const requestTimestamp = input.requestDispatchedAt ?? input.unitStartedAt;
+    return typeof requestTimestamp === "number" ? requestTimestamp : undefined;
+}
+export function decideCustomEngineRecovery(input) {
+    const exhaustedTurnError = "custom-engine-verify-retry-exhausted";
+    if (input.outcome === "pause") {
+        return {
+            action: "pause",
+            turnError: input.reason ?? exhaustedTurnError,
+        };
+    }
+    if (input.outcome === "skip") {
+        return {
+            action: "stop",
+            stopMessage: input.reason ??
+                `Custom workflow verification for ${input.unitId} requested skip after retry exhaustion, but the custom engine cannot reconcile skipped steps.`,
+            turnError: exhaustedTurnError,
+        };
+    }
+    const exhaustedReason = `Custom workflow verification for ${input.unitId} requested retry ${input.attempts} times without passing.`;
+    return {
+        action: "stop",
+        stopMessage: input.outcome === "stop" && input.reason ? input.reason : exhaustedReason,
+        turnError: exhaustedTurnError,
+    };
+}
+export function decideInfrastructureError(input) {
+    return {
+        notifyMessage: `Auto-mode stopped: infrastructure error ${input.code} — ${input.errorMessage}`,
+        stopMessage: `Infrastructure error (${input.code}): not recoverable by retry`,
+        turnStatus: "failed",
+        failureClass: "execution",
+    };
+}
+export function decideModelPolicyBlocked(input) {
+    return {
+        notifyMessage: `Auto-mode paused: model-policy denied dispatch for ${input.unitType}/${input.unitId}. ${input.errorMessage}`,
+        journalData: {
+            unitType: input.unitType,
+            unitId: input.unitId,
+            status: "blocked",
+            reason: "model-policy-dispatch-blocked",
+            reasons: input.reasons,
+        },
+        turnStatus: "paused",
+        failureClass: "manual-attention",
+    };
+}
+export function decideDispatchNodeKind(unitType, sidecarKind) {
+    if (sidecarKind === "hook")
+        return "hook";
+    if (sidecarKind === "triage")
+        return "verification";
+    if (sidecarKind === "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";
+}
+export function formatDispatchExceptionSummary(input) {
+    const message = input.error instanceof Error ? input.error.message : String(input.error);
+    return `exception:${message}`;
+}
+export function formatUnhandledDispatchErrorSummary(input) {
+    const message = input.error instanceof Error ? input.error.message : String(input.error);
+    return `unhandled-error:${message.slice(0, 200)}`;
+}

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

@@ -0,0 +1,36 @@
+// Project/App: GSD-2
+// File Purpose: Memory-pressure measurement adapter for auto-mode loop.
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const DEFAULT_MEMORY_PRESSURE_THRESHOLD = 0.85;
+const DEFAULT_HEAP_LIMIT_MB = 4096;
+function defaultHeapLimitBytes() {
+    const v8 = require("node:v8");
+    const limit = v8.getHeapStatistics?.().heap_size_limit;
+    if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) {
+        throw new Error("V8 heap limit unavailable");
+    }
+    return limit;
+}
+export function measureMemoryPressure(options) {
+    const threshold = options?.threshold ?? DEFAULT_MEMORY_PRESSURE_THRESHOLD;
+    const fallbackLimitMB = options?.fallbackLimitMB ?? DEFAULT_HEAP_LIMIT_MB;
+    const memoryUsage = options?.deps?.memoryUsage ?? (() => process.memoryUsage());
+    const heapLimitBytes = options?.deps?.heapLimitBytes ?? defaultHeapLimitBytes;
+    const mem = memoryUsage();
+    const heapMB = Math.round(mem.heapUsed / 1024 / 1024);
+    let limitMB = fallbackLimitMB;
+    try {
+        limitMB = Math.round(heapLimitBytes() / 1024 / 1024);
+    }
+    catch {
+        limitMB = fallbackLimitMB;
+    }
+    const pct = heapMB / limitMB;
+    return {
+        pressured: pct > threshold,
+        heapMB,
+        limitMB,
+        pct,
+    };
+}

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

@@ -0,0 +1,9 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for auto-mode UOK phase-result reporting.
+export function createWorkflowPhaseReporter(input) {
+    return {
+        report(phase, action, data) {
+            input.observer?.onPhaseResult(phase, action, data);
+        },
+    };
+}

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

@@ -0,0 +1,35 @@
+// Project/App: GSD-2
+// File Purpose: Session-lock validation adapter for auto-mode loop.
+import { decideWorkflowLoop, } from "./workflow-kernel.js";
+export function validateWorkflowSessionLock(input) {
+    const sessionLockBase = input.deps.lockBase();
+    if (!sessionLockBase)
+        return { action: "continue" };
+    const lockStatus = input.deps.validateSessionLock(sessionLockBase);
+    const detail = lockStatus.failureReason ?? "unknown";
+    const lockDecision = decideWorkflowLoop({
+        active: input.active,
+        iteration: input.iteration,
+        maxIterations: input.maxIterations,
+        hasCommandContext: true,
+        sessionLockValid: lockStatus.valid,
+        sessionLockReason: detail,
+    });
+    if (lockDecision.action !== "stop" || lockDecision.reason !== "session-lock-lost") {
+        return { action: "continue" };
+    }
+    input.deps.logInvalidSessionLock({
+        reason: detail,
+        existingPid: lockStatus.existingPid,
+        expectedPid: lockStatus.expectedPid,
+    });
+    input.deps.handleLostSessionLock(lockStatus);
+    input.deps.logSessionLockExit({
+        reason: lockDecision.reason,
+        detail,
+    });
+    return {
+        action: "stop",
+        reason: lockDecision.reason,
+    };
+}

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

@@ -0,0 +1,24 @@
+// Project/App: GSD-2
+// File Purpose: Sidecar iteration-data adapter for auto-mode loop.
+export async function buildSidecarIterationData(input) {
+    const sidecarState = await input.deriveState(input.canonicalProjectRoot);
+    input.logPostDerive({
+        site: "sidecar",
+        basePath: input.basePath,
+        canonicalProjectRoot: input.canonicalProjectRoot,
+        derivedPhase: sidecarState.phase,
+        activeUnit: sidecarState.activeTask?.id ?? sidecarState.activeSlice?.id ?? sidecarState.activeMilestone?.id,
+    });
+    return {
+        unitType: input.sidecarItem.unitType,
+        unitId: input.sidecarItem.unitId,
+        prompt: input.sidecarItem.prompt,
+        finalPrompt: input.sidecarItem.prompt,
+        pauseAfterUatDispatch: false,
+        state: sidecarState,
+        mid: sidecarState.activeMilestone?.id,
+        midTitle: sidecarState.activeMilestone?.title,
+        isRetry: false,
+        previousTier: undefined,
+    };
+}

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

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Sidecar queue scheduling and dequeue adapter for auto-mode loop.
+export async function dequeueSidecarItem(input) {
+    if (input.queue.length === 0)
+        return undefined;
+    if (input.executionGraphEnabled && input.queue.length > 1) {
+        try {
+            const scheduledQueue = await input.scheduleQueue(input.queue);
+            input.queue.splice(0, input.queue.length, ...scheduledQueue);
+        }
+        catch (err) {
+            input.warnSchedulingFailure(err instanceof Error ? err.message : String(err));
+        }
+    }
+    const sidecarItem = input.queue.shift();
+    if (!sidecarItem)
+        return undefined;
+    const payload = {
+        kind: sidecarItem.kind,
+        unitType: sidecarItem.unitType,
+        unitId: sidecarItem.unitId,
+    };
+    input.logDequeue(payload);
+    input.emitDequeue(payload);
+    return sidecarItem;
+}

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

@@ -0,0 +1,36 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for workflow turn observer reporting.
+export function createWorkflowTurnReporter(input) {
+    let finished = false;
+    const now = input.now ?? (() => new Date().toISOString());
+    return {
+        start() {
+            input.observer?.onTurnStart({
+                traceId: input.traceId,
+                turnId: input.turnId,
+                iteration: input.iteration,
+                basePath: input.basePath,
+                startedAt: input.startedAt,
+            });
+        },
+        finish(finishInput) {
+            if (finished)
+                return;
+            finished = true;
+            input.observer?.onTurnResult({
+                traceId: input.traceId,
+                turnId: input.turnId,
+                iteration: input.iteration,
+                unitType: finishInput.unitType,
+                unitId: finishInput.unitId,
+                status: finishInput.status,
+                failureClass: finishInput.failureClass ?? "none",
+                phaseResults: [],
+                error: finishInput.error,
+                startedAt: input.startedAt,
+                finishedAt: now(),
+            });
+            input.clearCurrentTurn();
+        },
+    };
+}

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

@@ -0,0 +1,44 @@
+// Project/App: GSD-2
+// File Purpose: Unit dispatch contract adapter for auto-mode loop.
+import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
+import { runUnitPhase } from "./phases.js";
+import { decideDispatchNodeKind } from "./workflow-kernel.js";
+export async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem, deps) {
+    if (dispatchContract === "legacy-direct") {
+        return deps.runUnitPhase(ic, iterData, loopState, sidecarItem);
+    }
+    const scheduler = deps.createScheduler();
+    let outcome = null;
+    const executeNode = async () => {
+        outcome = await deps.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: decideDispatchNodeKind(iterData.unitType, sidecarItem?.kind),
+            dependsOn: [],
+            metadata: {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            },
+        },
+    ], { parallel: false, maxWorkers: 1 });
+    return outcome ?? { action: "break", reason: "scheduler-dispatch-missing-result" };
+}
+export function createExecutionGraphUnitDispatchDeps() {
+    return {
+        runUnitPhase: async (...args) => runUnitPhase(...args),
+        createScheduler: () => new ExecutionGraphScheduler(),
+    };
+}

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

@@ -0,0 +1,15 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort worker heartbeat adapter for auto-mode loop.
+export function maintainWorkerHeartbeat(session, deps) {
+    if (!session.workerId)
+        return;
+    try {
+        deps.heartbeatAutoWorker(session.workerId);
+        if (session.currentMilestoneId && session.milestoneLeaseToken) {
+            deps.refreshMilestoneLease(session.workerId, session.currentMilestoneId, session.milestoneLeaseToken);
+        }
+    }
+    catch (err) {
+        deps.logHeartbeatFailure(err);
+    }
+}

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

@@ -128,9 +128,9 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             }
             return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
         case "plan-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
+            return `${relSliceFile(base, mid, sid, "PLAN")} plus tasks/T##-PLAN.md files (slice plan and task plans)`;
         case "refine-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} (refined slice plan from sketch)`;
+            return `${relSliceFile(base, mid, sid, "PLAN")} plus tasks/T##-PLAN.md files (refined slice plan and task plans)`;
         case "execute-task": {
             return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
         }

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

@@ -1,10 +1,4 @@
-/**
- * Auto-mode Dashboard — progress widget rendering, elapsed time formatting,
- * unit description helpers, and slice progress caching.
- *
- * Pure functions that accept specific parameters — no module-level globals
- * or AutoContext dependency. State accessors are passed as callbacks.
- */
+// GSD-2 + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
@@ -25,6 +19,7 @@ import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-sess
 import { logWarning } from "./workflow-logger.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { homedir } from "node:os";
+import { readUnitRuntimeRecord } from "./unit-runtime.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -165,6 +160,30 @@ export function formatWidgetTokens(count) {
         return `${(count / 1000000).toFixed(1)}M`;
     return `${Math.round(count / 1000000)}M`;
 }
+export function formatRuntimeHealthSignal(record, now = Date.now()) {
+    if (!record)
+        return null;
+    const idleMs = Math.max(0, now - record.lastProgressAt);
+    const idleMinutes = Math.floor(idleMs / 60_000);
+    if ((record.recoveryAttempts ?? 0) > 0 || record.phase === "recovered" || record.lastProgressKind.includes("recovery")) {
+        return {
+            level: "yellow",
+            summary: "Recovering",
+            detail: `retry ${record.recoveryAttempts ?? 1} after ${record.lastRecoveryReason ?? "idle"} stall`,
+        };
+    }
+    if (record.progressCount === 0 && idleMs >= 60_000) {
+        return {
+            level: "yellow",
+            summary: "Waiting on provider",
+            detail: `no output for ${idleMinutes}m`,
+        };
+    }
+    return null;
+}
+export function shouldRenderRoadmapProgress(progress) {
+    return !!progress && progress.total > 0;
+}
 // ─── ETA Estimation ──────────────────────────────────────────────────────────
 /**
  * Estimate remaining time based on average unit duration from the metrics ledger.
@@ -461,6 +480,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         ? { id: uatTargetSliceId, title: state.activeSlice?.title ?? "" }
         : state.activeSlice;
     const task = state.activeTask;
+    if (mid) {
+        updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+    }
     // Cache git branch at widget creation time (not per render)
     let cachedBranch = null;
     try {
@@ -496,6 +518,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         let cachedLines;
         let cachedWidth;
         let cachedRtkLabel;
+        let cachedRuntimeRecord = null;
         const refreshRtkLabel = () => {
             try {
                 const sessionId = ctx.sessionManager.getSessionId();
@@ -507,7 +530,16 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 cachedRtkLabel = null;
             }
         };
+        const refreshRuntimeRecord = () => {
+            try {
+                cachedRuntimeRecord = readUnitRuntimeRecord(accessors.getBasePath(), unitType, unitId);
+            }
+            catch {
+                cachedRuntimeRecord = null;
+            }
+        };
         refreshRtkLabel();
+        refreshRuntimeRecord();
         const pulseTimer = setInterval(() => {
             pulseBright = !pulseBright;
             cachedLines = undefined;
@@ -523,6 +555,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
                 }
                 refreshRtkLabel();
+                refreshRuntimeRecord();
                 cachedLines = undefined;
             }
             catch (err) { /* non-fatal */
@@ -552,13 +585,16 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const modeTag = accessors.isStepMode() ? "NEXT" : "AUTO";
                 // Health indicator in header
                 const score = computeProgressScore();
-                const healthColor = score.level === "green" ? "success"
-                    : score.level === "yellow" ? "warning"
+                const runtimeSignal = formatRuntimeHealthSignal(cachedRuntimeRecord);
+                const healthLevel = runtimeSignal?.level ?? score.level;
+                const healthSummary = runtimeSignal?.summary ?? score.summary;
+                const healthColor = healthLevel === "green" ? "success"
+                    : healthLevel === "yellow" ? "warning"
                         : "error";
-                const healthIcon = score.level === "green" ? GLYPH.statusActive
-                    : score.level === "yellow" ? "!"
+                const healthIcon = healthLevel === "green" ? GLYPH.statusActive
+                    : healthLevel === "yellow" ? "!"
                         : "x";
-                const healthStr = `  ${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, score.summary)}`;
+                const healthStr = `  ${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, healthSummary)}`;
                 const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}${healthStr}`;
                 // ETA in header right, after elapsed
                 const eta = estimateTimeRemaining();
@@ -570,7 +606,10 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     : "";
                 lines.push(rightAlign(headerLeft, headerRight, width));
                 // Show health signal details when degraded (yellow/red)
-                if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
+                if (runtimeSignal?.detail && widgetMode !== "min") {
+                    lines.push(`${pad}  ${theme.fg("dim", runtimeSignal.detail)}`);
+                }
+                else if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
                     // Show up to 3 most relevant signals in compact form
                     const topSignals = score.signals
                         .filter(s => s.kind === "negative")
@@ -642,7 +681,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     lines.push(rightAlign(actionLeft, theme.fg("dim", phaseLabel), width));
                     // Progress bar
                     const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
-                    if (roadmapSlices) {
+                    if (shouldRenderRoadmapProgress(roadmapSlices)) {
                         const { done, total, activeSliceTasks } = roadmapSlices;
                         const barWidth = Math.max(6, Math.min(18, Math.floor(width * 0.25)));
                         const pct = total > 0 ? done / total : 0;
@@ -703,7 +742,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     ? Math.floor(width * (width >= 100 ? 0.45 : 0.50))
                     : width;
                 const leftLines = [];
-                if (roadmapSlices) {
+                if (shouldRenderRoadmapProgress(roadmapSlices)) {
                     const { done, total, activeSliceTasks } = roadmapSlices;
                     const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
                     const pct = total > 0 ? done / total : 0;

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

@@ -559,6 +559,8 @@ export const DISPATCH_RULES = [
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
                 return null; // fall through to next rule
+            if (prefs?.planning_depth === "deep")
+                return null;
             // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
             // pre-verify deep planning's user-facing milestone approval gate.
             if (shouldBypassMilestoneDepthGateInAuto(prefs)) {