aiden-runtime 4.1.2 → 4.1.4

package/dist/cli/v4/aidenCLI.js

@@ -1449,6 +1449,12 @@ async function buildAgentRuntime(cliOpts, opts) {
         mcpClient,
         providerId,
         modelId,
+        // v4.1.3-prebump: forward the precedence-case label so the boot
+        // card can render a "where this choice came from" annotation.
+        // The case-3 (persisted-config) branch was confusing users who
+        // expected auto-pick to kick in — surfacing the source closes the
+        // information asymmetry.
+        bootSource,
         resumeSessionId,
         fallbackAdapter,
         personalityManager,
@@ -1475,6 +1481,10 @@ async function runInteractiveChat(cliOpts, opts) {
         config: runtime.config,
         initialProviderId: runtime.providerId,
         initialModelId: runtime.modelId,
+        // v4.1.3-prebump: pass through the precedence-case label so the
+        // boot card can render a dim source annotation under the version
+        // pill ("persisted from prior session" / "auto-picked" / …).
+        initialBootSource: runtime.bootSource,
         resumeSessionId: runtime.resumeSessionId,
         yoloMode: !!cliOpts.yolo,
         fallbackAdapter: runtime.fallbackAdapter,

package/dist/cli/v4/callbacks.js

@@ -82,6 +82,15 @@ class CliCallbacks {
                     }
                     this.beforeFirstToolHook = undefined;
                 }
+                // v4.1.4 reply-quality polish — Part 1.6. Pause activity
+                // indicator BEFORE the tool row writes so the indicator's line
+                // is clean when the row lands. Fires for every tool, not just
+                // the first. Defensive try/catch — a misbehaving hook must not
+                // block tool dispatch.
+                try {
+                    this.beforeToolHook?.();
+                }
+                catch { /* defensive */ }
                 const handle = this.display.toolRow(call.name, call.arguments);
                 this.toolRows.set(call.id, handle);
                 this.toolStartTimes.set(call.id, Date.now());
@@ -92,19 +101,61 @@ class CliCallbacks {
             const startedAt = this.toolStartTimes.get(call.id);
             this.toolRows.delete(call.id);
             this.toolStartTimes.delete(call.id);
-            if (!handle || startedAt === undefined)
+            if (!handle || startedAt === undefined) {
+                // Even if we lost the handle, the indicator may still need to
+                // be re-armed so the next gap shows activity. Tool-name-aware
+                // verb selection happens in the hook itself.
+                try {
+                    this.afterEachToolHook?.(call.name);
+                }
+                catch { /* defensive */ }
                 return;
+            }
             const ms = Date.now() - startedAt;
             const err = result?.error;
             if (typeof err === 'string' && err.includes('URL provenance gate')) {
                 handle.blocked();
                 return;
             }
+            // v4.1.4 reply-quality polish — Part 1.6. Helper used by ALL
+            // outcome branches below so the activity indicator gets re-armed
+            // for the gap that follows this tool (next tool, or final reply).
+            // Tool-name-aware verb selection happens in the hook (chatSession
+            // wires it through `verbForActivity`).
+            const fireAfter = () => {
+                try {
+                    this.afterEachToolHook?.(call.name);
+                }
+                catch { /* defensive */ }
+            };
+            if (typeof err === 'string' && err.includes('URL provenance gate')) {
+                handle.blocked();
+                fireAfter();
+                return;
+            }
             if (err) {
                 handle.fail(ms);
+                // v4.1.3-essentials: when the tool's failure payload includes a
+                // structured capability card (auth missing, platform unsupported),
+                // render the card immediately after the fail row. The card sits
+                // on its own multi-line block — the fail row is still useful as
+                // the action timeline anchor; the card adds the state assessment
+                // the user actually needs. No card → plain failure surface.
+                if (result?.capabilityCard) {
+                    this.display.capabilityCard(result.capabilityCard);
+                }
+                fireAfter();
+                return;
+            }
+            // v4.1.3-repl-polish: degraded outcome — tool completed but with a
+            // partial / best-effort result. Show in trail yellow instead of silent.
+            if (result?.degraded) {
+                handle.degraded(ms, result.degradedReason);
+                fireAfter();
                 return;
             }
             handle.ok(ms);
+            fireAfter();
         };
         /** ApprovalEngine.callbacks.promptUser */
         this.promptApproval = async (req) => {
@@ -171,23 +222,29 @@ Reply with ONE word: safe, caution, or dangerous.`;
                 return false;
             }
         };
-        /** PlannerGuard sink. Quiet in compact mode. */
+        /**
+         * PlannerGuard sink. v4.1.4 Phase 3b' (Q-Planner): moved to
+         * verbose-only. The default `normal` mode previously emitted
+         * `[planner] kept N tools (reason)` mid-execution, which collided
+         * visually with the activity indicator's single-line paint and
+         * with streamed deltas. Users running with the default verbose
+         * level should see a clean execution surface — planner-guard
+         * decisions are useful for debugging but noise during normal use.
+         *
+         * `verbose` mode keeps the full breakdown for debugging. `compact`
+         * stays silent (unchanged).
+         */
         this.onPlannerGuardDecision = (decision) => {
             if (this.verboseMode === 'compact')
                 return;
-            if (decision.reason === 'no_filter')
+            if (this.verboseMode !== 'verbose')
                 return;
-            if (this.verboseMode === 'verbose') {
-                const conf = decision.confidence !== undefined
-                    ? ` (conf ${decision.confidence.toFixed(2)})`
-                    : '';
-                this.display.dim(`[planner] ${decision.reason}${conf}: kept ${decision.selectedTools.length} / dropped ${decision.excludedTools.length}`);
+            if (decision.reason === 'no_filter')
                 return;
-            }
-            // normal
-            if (decision.excludedTools.length > 0) {
-                this.display.dim(`[planner] kept ${decision.selectedTools.length} tools (${decision.reason})`);
-            }
+            const conf = decision.confidence !== undefined
+                ? ` (conf ${decision.confidence.toFixed(2)})`
+                : '';
+            this.display.dim(`[planner] ${decision.reason}${conf}: kept ${decision.selectedTools.length} / dropped ${decision.excludedTools.length}`);
         };
         /**
          * Phase v4.1-skill-mining — post-turn cue when the miner has
@@ -265,6 +322,21 @@ Reply with ONE word: safe, caution, or dangerous.`;
         this.beforeFirstToolHook = fn;
         this.firstToolFiredThisTurn = false;
     }
+    /**
+     * v4.1.4 reply-quality polish — Part 1.6.
+     *
+     * Register paired hooks so chatSession can pause the activity
+     * indicator while a tool row writes, and resume it (with a fresh
+     * verb derived from the just-completed tool) in the gap before the
+     * next tool fires or the final reply arrives.
+     *
+     * Both fire for EVERY tool, not just the first. Either can be
+     * omitted independently. Cleared between turns by passing `undefined`.
+     */
+    setActivityIndicatorHooks(opts) {
+        this.beforeToolHook = opts.beforeTool;
+        this.afterEachToolHook = opts.afterEachTool;
+    }
 }
 exports.CliCallbacks = CliCallbacks;
 // Tier-3.1 (v4.1-tier3.1): replaced 🟢/🟡/🔴 emoji badges with

package/dist/cli/v4/chatSession.js

@@ -59,6 +59,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BOOT_TRY_HINT = exports.ChatSession = void 0;
 exports.parseSessionBulletsResponse = parseSessionBulletsResponse;
 exports.renderCommandLabel = renderCommandLabel;
+exports.bootSourceLabel = bootSourceLabel;
 exports.detectOS = detectOS;
 exports.detectShell = detectShell;
 exports.formatStatusState = formatStatusState;
@@ -69,12 +70,21 @@ exports.formatTokens = formatTokens;
 exports.formatDuration = formatDuration;
 exports.renderMemoryConfirmations = renderMemoryConfirmations;
 const display_1 = require("./display");
+// v4.1.4 Part 1.6 — per-turn token progress bar. Fed by `onProgress`
+// events from the streaming adapter; hidden when the adapter doesn't
+// emit progress (honest degradation).
+const progressBar_1 = require("./display/progressBar");
 const uiBuild_1 = require("./uiBuild");
 const sessionSummaryGate_1 = require("./sessionSummaryGate");
 const aidenPrompt_1 = __importDefault(require("./aidenPrompt"));
 const historyStore_1 = require("./historyStore");
 const modelMetadata_1 = require("../../core/v4/modelMetadata");
+// v4.1.3-prebump: classify provider errors so the catch path can show
+// a tailored action hint (e.g. groq 413 → "switch to chatgpt-plus")
+// instead of the generic "/model or aiden doctor" line.
+const errors_1 = require("../../providers/v4/errors");
 const sessionDistiller_1 = require("../../core/v4/sessionDistiller");
+const sessionEndCard_1 = require("./display/sessionEndCard");
 const version_1 = require("../../core/version");
 const distillationStore_1 = require("../../core/v4/distillationStore");
 const promotionCandidates_1 = require("../../core/v4/promotionCandidates");
@@ -154,7 +164,15 @@ const STATUS_BAR_WIDTH = 10;
  * Above this we abandon the LLM half (still write a deterministic-
  * only distillation so the session isn't lost) and exit honestly.
  */
-const SUMMARY_TIMEOUT_MS_DEFAULT = 4000;
+/**
+ * v4.1.3-essentials distillation-fix: bumped 4000 → 12000ms in
+ * lockstep with `sessionDistiller.DEFAULT_TIMEOUT_MS`. Same
+ * rationale — chatgpt-plus Codex cold-start latency for 800-token
+ * summaries regularly exceeds 4s, killing the distillation +
+ * promotion-prompt path. Env override `AIDEN_SUMMARY_TIMEOUT_MS`
+ * still respected.
+ */
+const SUMMARY_TIMEOUT_MS_DEFAULT = 12000;
 function resolveSummaryTimeoutMs() {
     const raw = process.env.AIDEN_SUMMARY_TIMEOUT_MS;
     if (!raw)
@@ -162,6 +180,35 @@ function resolveSummaryTimeoutMs() {
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : SUMMARY_TIMEOUT_MS_DEFAULT;
 }
+/**
+ * v4.1.3-prebump: map a providerBootSelector precedence-case label to
+ * a human-readable hint rendered under the boot card's status pills.
+ *
+ * Returns `null` for the explicit-selection cases (`cli-flag`, with-or-
+ * without -partial) where the source isn't surprising. Annotates the
+ * persisted-config / auto-priority / hardcoded-fallback paths so users
+ * understand "why this provider, why now".
+ *
+ * Pure helper — exported for unit testing.
+ */
+function bootSourceLabel(source) {
+    switch (source) {
+        case 'persisted-config':
+            return '(persisted from prior session — /model to change)';
+        case 'config-partial':
+            return '(partial config + auto-resolved companion)';
+        case 'auto-priority':
+            return '(auto-picked — first authed provider)';
+        case 'hardcoded-fallback':
+            return '(no authed providers — using legacy default)';
+        case 'cli-flag':
+        case 'cli-flag-partial':
+            // Explicit CLI override — user knows why; no annotation.
+            return null;
+        default:
+            return null;
+    }
+}
 class ChatSession {
     constructor(opts) {
         this.opts = opts;
@@ -208,6 +255,13 @@ class ChatSession {
          * populated alongside it after a verified write.
          */
         this.lastDistillation = null;
+        /**
+         * Absolute path the most recent distillation JSON was written to.
+         * Captured at write-time and surfaced in the session-end card so the
+         * user has a concrete artifact to inspect or feed to recall_session.
+         * Null when the write failed or no distillation has been produced.
+         */
+        this.lastDistillationPath = null;
         this.currentProviderId = opts.initialProviderId;
         this.currentModelId = opts.initialModelId;
         this.modelMetadata = opts.modelMetadata ?? new modelMetadata_1.ModelMetadata();
@@ -298,6 +352,14 @@ class ChatSession {
                 catch (err) {
                     this.opts.display.warn(`Session summary skipped on ${sig}: ${err.message}`);
                 }
+                // v4.1.3-repl-polish: render session-end card before farewell when
+                // a distillation was written this session. Pass the on-disk path
+                // so the card surfaces the artifact location to the user.
+                if (this.lastDistillation) {
+                    for (const line of (0, sessionEndCard_1.renderSessionEndCard)(this.lastDistillation, (t, k) => this.opts.display.applyColors(t, k), this.lastDistillationPath)) {
+                        this.opts.display.write(line + '\n');
+                    }
+                }
                 this.opts.display.dim('Goodbye.');
                 process.exit(0);
             };
@@ -356,9 +418,22 @@ class ChatSession {
         // Tier-3-essentials: hard-clear the screen on terminal resize so
         // dropdown re-renders + previous prompt frames don't ghost into
         // the new viewport. No-op on non-TTY / MCP serve mode.
+        //
+        // v4.1.4 reply-quality polish: also drop the per-chunk stream row
+        // counter so a mid-stream resize doesn't try to erase rows that
+        // the hard-clear already removed. See `resetStreamFrameForResize`
+        // in display.ts for the rationale.
         const restoreResizeGuard = this.opts.promptApi
             ? () => { }
-            : (0, resizeGuard_1.installResizeGuard)();
+            : (0, resizeGuard_1.installResizeGuard)({
+                onCleared: () => {
+                    try {
+                        this.opts.display
+                            .resetStreamFrameForResize?.();
+                    }
+                    catch { /* defensive — never break the resize listener */ }
+                },
+            });
         try {
             while (iter < max) {
                 iter += 1;
@@ -430,6 +505,12 @@ class ChatSession {
                         // is resumed in the same process (not today's behavior),
                         // otherwise they're skipped — documented in commit.
                         await this.maybeRunPromotion(promptApi);
+                        // v4.1.3-repl-polish: session-end card before farewell.
+                        if (this.lastDistillation) {
+                            for (const line of (0, sessionEndCard_1.renderSessionEndCard)(this.lastDistillation, (t, k) => this.opts.display.applyColors(t, k), this.lastDistillationPath)) {
+                                this.opts.display.write(line + '\n');
+                            }
+                        }
                         break;
                     }
                     if (result.clearHistory)
@@ -555,6 +636,15 @@ class ChatSession {
                 toolTrace: this.sessionToolTrace,
                 auxiliaryClient: this.opts.auxiliaryClient,
                 timeoutMs,
+                // v4.1.3-essentials distillation-fix: route the new
+                // diagnostic signal to a dim line so the user can see WHICH
+                // of the three failure classes fired (timeout / call-fail /
+                // unparseable JSON). Before this hook, all three converged
+                // on a silent `partial:true` and the downstream "no bullets"
+                // warning didn't distinguish them.
+                onDiagnostic: (msg) => {
+                    this.opts.display.dim(`[distill] ${msg}`);
+                },
             });
         }
         catch (err) {
@@ -569,6 +659,7 @@ class ChatSession {
             const dir = node_path_1.default.join(this.opts.paths.root, 'distillations');
             try {
                 const file = await (0, distillationStore_1.writeDistillation)(dir, dist);
+                this.lastDistillationPath = file;
                 this.opts.display.dim(`Session distillation${dist.partial ? ' (partial)' : ''} saved to ${file}`);
             }
             catch (err) {
@@ -811,40 +902,105 @@ class ChatSession {
         const baseHistory = newHistory.length > 0
             ? [...this.history, ...newHistory, userMsg]
             : [...this.history, userMsg];
-        // Phase 16c: streaming gated on display.streaming config (default off).
-        // Defensive: tests sometimes pass partial config stubs without the
-        // ConfigManager API; treat that as "streaming disabled".
+        // Phase 16c: streaming gated on display.streaming config.
+        // v4.1.4 Part 1.6: PRODUCTION DEFAULT FLIPPED FROM FALSE TO TRUE.
+        // Streaming delivers the activity indicator, tool-row live tick,
+        // and token progress bar that the user feedback ("after prompt i
+        // just see output") was specifically asking for. Users who
+        // explicitly set `display.streaming: false` in config still opt
+        // out; the change affects only the default for users who never
+        // touched the flag.
+        //
+        // Test-stub fallback (no ConfigManager) stays at `false` so
+        // existing tests that depended on the non-streaming code path
+        // don't have to be rewritten in this slice — they exercise the
+        // batch-call path that production users on Ollama / non-streaming
+        // adapters still hit naturally.
         const streamingEnabled = typeof this.opts.config?.getValue === 'function'
-            ? this.opts.config.getValue('display.streaming', false) === true
+            ? this.opts.config.getValue('display.streaming', true) === true
             : false;
-        // Phase 26.2.6 — random thinking phrase per turn, already wrapped
-        // in brand orange by Display.thinkingPhrase().
-        const spinner = this.opts.display.startSpinner(this.opts.display.thinkingPhrase());
-        let spinnerStopped = false;
+        // v4.1.4 reply-quality polish — Part 1.6. Activity indicator
+        // replaces the prior single-shot spinner. Pause/resume hooks make
+        // the indicator cooperate with tool rows: it pauses before each
+        // tool row writes and resumes (with a tool-aware verb) in the
+        // gap that follows, so the user always sees activity feedback
+        // during model-thinking time — not just the pre-first-token gap.
+        //
+        // Initial verb is "thinking" (pre-tools phase). After each tool
+        // completes, `verbForActivity(toolName, 'post-tool')` picks a
+        // category-aware verb (reading / searching / analyzing / drafting).
+        // When the first stream delta arrives OR the final agentTurn is
+        // about to write, the indicator stops permanently.
+        const indicator = this.opts.display.activityIndicator('thinking');
+        let indicatorStopped = false;
         let streamingActive = false;
-        const stopSpinnerOnce = () => {
-            if (spinnerStopped)
+        const stopIndicatorOnce = () => {
+            if (indicatorStopped)
                 return;
-            spinnerStopped = true;
-            spinner.stop();
+            indicatorStopped = true;
+            indicator.stop();
+            // Clear the per-turn pause/resume hooks so they don't fire
+            // against a stopped indicator on a subsequent turn. The next
+            // turn re-registers fresh hooks.
+            try {
+                this.opts.callbacks.setActivityIndicatorHooks?.({});
+            }
+            catch { /* defensive */ }
         };
-        // Phase 23.5: stop the "thinking…" spinner the moment the first
-        // tool row prints. The event rows are the user-facing indicator
-        // from that point on; a spinner painting `\r` over the same line
-        // would corrupt our row-overwrite when the row mutates to its
-        // final bracket state.
-        this.opts.callbacks.setBeforeFirstToolHook?.(stopSpinnerOnce);
+        // Phase 23.5 carried forward: stop the indicator the moment the
+        // first tool row prints — the row itself is the activity surface
+        // during a tool. Part 1.6 then resumes via `afterEachTool` so the
+        // post-tool gap has its own indicator paint.
+        this.opts.callbacks.setBeforeFirstToolHook?.(stopIndicatorOnce);
+        // Part 1.6: pause/resume hooks around every tool row. The
+        // `beforeTool` hook fires before EACH tool row writes (not just
+        // the first), so multi-tool sequences also keep the indicator
+        // off the tool-row line. `afterEachTool` resumes with a verb
+        // chosen from the just-completed tool's category — best guess
+        // for "what the model is doing next". `lastToolName` is captured
+        // for tests / observability; the verb decision happens inline.
+        this.opts.callbacks.setActivityIndicatorHooks?.({
+            beforeTool: () => {
+                if (indicatorStopped)
+                    return;
+                indicator.pause();
+                // v4.1.4 Part 1.6: hide the progress bar while the tool row
+                // owns the screen. The bar paints below the indicator, so
+                // it'd otherwise sit between the tool row and any subsequent
+                // stream output — visual clutter for tool-heavy turns. The
+                // bar is per-turn, not per-stream-segment; once hidden it
+                // stays hidden until the next turn's bar is created.
+                progressBar?.hide();
+            },
+            afterEachTool: (toolName) => {
+                if (indicatorStopped)
+                    return;
+                indicator.resume((0, display_1.verbForActivity)(toolName, 'post-tool'));
+            },
+        });
+        // v4.1.4 Part 1.6: per-turn progress bar. Created lazily on the
+        // first `onProgress` event from the streaming adapter so the bar
+        // line doesn't paint until there's something to show. Adapters
+        // that don't emit progress (Ollama, most OpenAI-compat) never
+        // trigger creation — honest degradation, no fake estimates.
+        let progressBar = null;
         try {
             const result = await this.opts.agent.runConversation(baseHistory, {
                 stream: streamingEnabled,
                 onFirstDelta: streamingEnabled
                     ? () => {
-                        stopSpinnerOnce();
+                        stopIndicatorOnce();
                         streamingActive = true;
                     }
                     : undefined,
                 onDelta: streamingEnabled
                     ? (text) => {
+                        // v4.1.4 Part 1.6: bar lives ABOVE streamed text. Hide
+                        // it before each delta writes so the stream output
+                        // doesn't land on the bar's line. The bar repaints on
+                        // the next `onProgress` event (which Anthropic emits
+                        // frequently enough that the bar stays usefully visible).
+                        progressBar?.hide();
                         this.opts.display.streamPartial(text);
                     }
                     : undefined,
@@ -853,8 +1009,30 @@ class ChatSession {
                         this.opts.display.streamToolIndicator(call.name);
                     }
                     : undefined,
+                onProgress: streamingEnabled
+                    ? (outputTokens, maxTokens) => {
+                        if (indicatorStopped === false)
+                            return;
+                        // Lazy-create on first event. The indicator must already
+                        // be stopped (first delta arrived) so the bar paints on
+                        // its own line below where the indicator was. If the
+                        // indicator is still up, skip — the bar would land on
+                        // the indicator line and get clobbered by the next tick.
+                        if (!progressBar) {
+                            progressBar = (0, progressBar_1.createProgressBar)(process.stdout, 
+                            // Display exposes its skin via getter on the
+                            // implementation; cast to any to avoid widening
+                            // the public Display surface for one-shot use.
+                            this.opts.display.skin);
+                        }
+                        progressBar.update(outputTokens, maxTokens);
+                    }
+                    : undefined,
             });
-            stopSpinnerOnce();
+            stopIndicatorOnce();
+            // Hide the progress bar before any post-stream content
+            // (statusFooter, the next prompt) lands on its line.
+            progressBar?.hide();
             if (streamingActive)
                 this.opts.display.streamComplete();
             this.history = result.messages;
@@ -892,11 +1070,50 @@ class ChatSession {
             this.renderStatusLine();
         }
         catch (err) {
-            stopSpinnerOnce();
+            stopIndicatorOnce();
+            // v4.1.4 Part 1.6: error path must also hide the progress bar
+            // so it doesn't leak across the boundary into the error chrome
+            // or the next prompt.
+            progressBar?.hide();
             if (streamingActive)
                 this.opts.display.streamComplete();
             const msg = err?.message ?? String(err);
-            this.opts.display.printError(msg, 'Run `/model` to switch providers or `aiden doctor` to diagnose.');
+            // v4.1.3-prebump: classify the error so the suggestion below
+            // points at the actual fix instead of the generic "/model or
+            // doctor" line. 413 / 429 / auth get tailored hints; everything
+            // else keeps the legacy fallback. Use the live providerId so
+            // the user sees WHICH provider blew up (matters when fallback
+            // adapters rotate slots mid-turn).
+            const cls = (0, errors_1.classifyProviderError)(err);
+            const tailored = (0, errors_1.suggestForErrorClass)(cls, this.currentProviderId);
+            // v4.1.3-essentials: on `auth` class errors we have enough state
+            // (which provider, what to run) to render a capability card —
+            // structured "what auth's missing, what you can still do, how to
+            // fix" is more useful than the bare message + one-line hint.
+            // Other classes keep the printError single-line surface; their
+            // hints are already specific.
+            if (cls === 'auth') {
+                const p = this.currentProviderId;
+                this.opts.display.printError(msg);
+                this.opts.display.capabilityCard({
+                    title: `${p} authentication required`,
+                    canStill: [
+                        'Continue chatting if a non-auth provider is configured (run `/model`)',
+                        'Run `/auth status` to see which providers are signed in',
+                        'Run `aiden doctor --providers` for a fuller liveness probe',
+                    ],
+                    cannotReliably: [
+                        `Call ${p} until credentials are refreshed`,
+                        'Trust any cached responses that depended on this provider',
+                    ],
+                    fix: `Run \`/auth login ${p}\` if it's an OAuth provider, or set the ` +
+                        `relevant API key env var. Then retry — no need to restart Aiden.`,
+                });
+            }
+            else {
+                this.opts.display.printError(msg, tailored
+                    ?? 'Run `/model` to switch providers or `aiden doctor` to diagnose.');
+            }
             this.setStatusState({ kind: 'ready' });
             this.lastTurnElapsedMs = Date.now() - turnStartedAt;
         }
@@ -979,6 +1196,15 @@ class ChatSession {
             providerOk: !this.opts.unconfigured,
             version: version_1.VERSION,
         }) + '\n');
+        // v4.1.3-prebump: dim source annotation under the pills row so the
+        // user can see WHY this provider/model was chosen — closes the
+        // information gap that made Case 3 (persisted-config) look like a
+        // bug ("why is it still on groq when I auth'd chatgpt-plus?"). One
+        // line, dim, only when the source is informative.
+        const sourceLabel = bootSourceLabel(this.opts.initialBootSource);
+        if (sourceLabel) {
+            display.write(`  ${display.muted(sourceLabel)}\n`);
+        }
         // Tier-3.1b: rule + environment/capabilities block + rule + scroll
         // + bottom prompt hint. Skipped at <70 cols to keep the narrow
         // boot card from wrapping into noise.

package/dist/cli/v4/commands/doctor.js

@@ -32,35 +32,31 @@ exports.doctor = {
         }
         ctx.display.info('Running diagnostic checks...');
         const report = await (0, doctor_1.runDoctor)({ paths: ctx.paths });
-        // Phase 22 Task 5A: orange-bordered rounded box; rows + summary
-        // assembled by renderHealthBox so the slash command stays a thin
-        // adapter and the same renderer can be reused by `aiden doctor`
-        // CLI in a future polish pass.
-        ctx.display.write((0, doctor_1.renderHealthBox)(report, ctx.display) + '\n');
-        // Phase 23.1: surface session-scoped skill-enforcement counters.
-        // Lives only on the live agent (process-scoped, no persistence) so
-        // `aiden doctor` CLI subcommand correctly omits this — the
-        // counters would always be zero there.
+        // v4.1.3-essentials doctor-polish: pull in-process subsystem
+        // health + skill-outcome data into the same report so they
+        // render as additional grouped sections inside the health box,
+        // not as disconnected blocks below it. `subsystemHealthResults`
+        // / `skillOutcomeResults` return empty arrays when their
+        // sources are unavailable so the grouped-renderer simply drops
+        // those sections.
         if (ctx.agent) {
-            const m = ctx.agent.getSkillEnforcementMetrics();
-            ctx.display.write(
-            // Phase 23.4b: surface the Stage-0 intent pre-arm counter so
-            // smoke runs can confirm the regex fired on bug-Y queries.
-            `[skill-enforcement] armed=${m.armed} pre-armed=${m.preArmed} recovered=${m.recovered} failed=${m.failed} (session)\n`);
-            // Phase 23.4a: same shape, different concern — URL provenance
-            // gate counters. blocked = open_url calls rejected for unknown
-            // YouTube ids; recovered = corrective retry produced a real
-            // youtube_search; failed = retry cap exceeded and the turn
-            // ended with an honest-failure message.
-            const u = ctx.agent.getUrlProvenanceMetrics();
-            ctx.display.write(`[url-provenance]    blocked=${u.blocked} recovered=${u.recovered} failed=${u.failed} (session)\n`);
-            // Phase 23.4a-fix2: empty-response counters. detected =
-            // Codex backend completed a turn with no content and no tool
-            // calls; retried = corrective system message injected (cap
-            // 1/turn); recovered = retry yielded a non-empty reply.
-            const e = ctx.agent.getEmptyResponseMetrics();
-            ctx.display.write(`[empty-response]    detected=${e.detected} retried=${e.retried} recovered=${e.recovered} (session)\n`);
+            const a = ctx.agent;
+            report.results.push(...(0, doctor_1.subsystemHealthResults)(a.subsystemHealthRegistry));
+            report.results.push(...(0, doctor_1.skillOutcomeResults)(a.skillOutcomeTracker));
+            // v4.1.3-essentials doctor-polish: session-scoped counters
+            // (skill enforcement / URL provenance / empty response) now
+            // fold into the same report so they render as a "Session
+            // counters" group INSIDE the box instead of as orphan
+            // `display.write` lines below it. Previous code emitted them
+            // as 3 separate `[bracket-prefix] key=N ...` lines after
+            // renderHealthBox closed — visually disconnected.
+            report.results.push(...(0, doctor_1.sessionCounterResults)(ctx.agent));
         }
+        // v4.1.3-essentials doctor-polish: renderHealthBox now groups
+        // results by section header with a top summary. Same renderer
+        // is used by `aiden doctor` CLI path so both surfaces stay in
+        // visual sync (Path-A unification).
+        ctx.display.write((0, doctor_1.renderHealthBox)(report, ctx.display) + '\n');
         return {};
     },
 };