aiden-runtime 4.1.3 → 4.1.5

package/dist/cli/v4/aidenCLI.js

@@ -1057,6 +1057,34 @@ async function buildAgentRuntime(cliOpts, opts) {
                 // diagnostics must not break the loop
             }
         },
+        // v4.1.5 Issue K — phase lifecycle hooks for the activity indicator
+        // verb mutation. Each fires at a specific point in runConversation:
+        //   - onMemoryRefreshStart: before memory I/O begins
+        //   - onPromptBuilt: after system prompt assembly
+        //   - onProviderRequestStart: just before the HTTP request opens
+        // chatSession registers handlers that call `indicator.setVerb()` so
+        // the user sees the model's actual workflow phase during the gap.
+        // All three are forwarded through `callbacks` so chatSession owns
+        // the indicator handle (created per-turn). Defensive try/catch on
+        // each — a misbehaving display sink never blocks the agent loop.
+        onMemoryRefreshStart: () => {
+            try {
+                callbacks.onMemoryRefreshStart?.();
+            }
+            catch { /* defensive */ }
+        },
+        onPromptBuilt: (info) => {
+            try {
+                callbacks.onPromptBuilt?.(info);
+            }
+            catch { /* defensive */ }
+        },
+        onProviderRequestStart: (id) => {
+            try {
+                callbacks.onProviderRequestStart?.(id);
+            }
+            catch { /* defensive */ }
+        },
         // Phase 23.4b — feed the agent's Stage-0 intent pre-arm with the
         // skill's `required_tools` from its SKILL.md frontmatter.  Returns
         // null when the skill is unknown / unloaded / empty so the agent

package/dist/cli/v4/callbacks.js

@@ -63,6 +63,29 @@ class CliCallbacks {
         this.toolRows = new Map();
         this.toolStartTimes = new Map();
         this.firstToolFiredThisTurn = false;
+        // v4.1.5 Issue K — `firePhaseVerb` is the public entry point for the
+        // AidenCLI bridge. AidenAgent fires `onMemoryRefreshStart` etc.,
+        // aidenCLI's adapter calls into one of these `onPhase…` shims, each
+        // mapping a lifecycle event to a verb string. Defensive try/catch so
+        // a misbehaving display sink can't unwind the agent loop.
+        this.onMemoryRefreshStart = () => {
+            try {
+                this.phaseVerbHook?.('refreshing memory');
+            }
+            catch { /* defensive */ }
+        };
+        this.onPromptBuilt = (_info) => {
+            try {
+                this.phaseVerbHook?.('preparing prompt');
+            }
+            catch { /* defensive */ }
+        };
+        this.onProviderRequestStart = (_providerId) => {
+            try {
+                this.phaseVerbHook?.('calling provider');
+            }
+            catch { /* defensive */ }
+        };
         /**
          * Phase 23.5 — bound to AidenAgent.onToolCall. Emits one event row
          * per tool call: prints `[running]` on `before`, mutates the bracket
@@ -82,6 +105,23 @@ 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 */ }
+                // v4.1.5+ Path A — fire the loop-trace sink BEFORE row writes.
+                // Captures every tool's call.id + name (including hidden ones
+                // suppressed from the visible trail) so the trace covers the
+                // full agent loop, not just user-visible work.
+                try {
+                    this.toolTraceBeforeHook?.(call.id, call.name);
+                }
+                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,12 +132,57 @@ 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 */ }
+                // v4.1.5+ Path A — loop-trace sink fires even when handle was
+                // lost (rare; happens if before/after pairing slipped) so the
+                // trace never under-counts tool calls.
+                try {
+                    this.toolTraceAfterHook?.(call.id, call.name, call.arguments);
+                }
+                catch { /* defensive */ }
                 return;
+            }
             const ms = Date.now() - startedAt;
             const err = result?.error;
             if (typeof err === 'string' && err.includes('URL provenance gate')) {
                 handle.blocked();
+                // v4.1.5+ Path A — blocked path still needs the trace sink so
+                // the URL-provenance failure mode shows up in loop diagnostics.
+                try {
+                    this.toolTraceAfterHook?.(call.id, call.name, call.arguments);
+                }
+                catch { /* defensive */ }
+                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 */ }
+                // v4.1.5+ Path A — also fire the loop-trace `after` sink so the
+                // tracer can compute duration + capture args (hidden-from-trail
+                // tools still flow through here, by design — the trace must see
+                // them to detect lookup_tool_schema / skill_view loops).
+                try {
+                    this.toolTraceAfterHook?.(call.id, call.name, call.arguments);
+                }
+                catch { /* defensive */ }
+            };
+            if (typeof err === 'string' && err.includes('URL provenance gate')) {
+                handle.blocked();
+                fireAfter();
                 return;
             }
             if (err) {
@@ -111,15 +196,18 @@ class CliCallbacks {
                 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) => {
@@ -186,23 +274,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
@@ -280,6 +374,47 @@ 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;
+    }
+    /**
+     * v4.1.5 Issue K — set/clear the phase-verb sink. chatSession
+     * registers a closure that captures the per-turn indicator handle
+     * and forwards calls to `indicator.setVerb(verb)`. Cleared between
+     * turns by passing `undefined`. Optional — non-indicator callers
+     * (test harnesses with stub displays) get no-op behaviour.
+     */
+    setPhaseVerbHook(fn) {
+        this.phaseVerbHook = fn;
+    }
+    /**
+     * v4.1.5+ Path A — register a per-turn tool-trace sink for the
+     * loop-trace logger. `before` fires with the call's id+name BEFORE
+     * the row writes; `after` fires post-execution with the same id +
+     * the call's args (for skill-name extraction in trace context).
+     * Cleared between turns by passing `undefined`.
+     *
+     * Separate from `setActivityIndicatorHooks` because the activity
+     * hook is name-only and fires for visible-trail purposes; this
+     * one captures FULL call data including hidden tools (which the
+     * trail suppresses via TRAIL_HIDE_TOOLS but the trace must see).
+     */
+    setToolTraceHook(opts) {
+        this.toolTraceBeforeHook = opts.before;
+        this.toolTraceAfterHook = opts.after;
+    }
 }
 exports.CliCallbacks = CliCallbacks;
 // Tier-3.1 (v4.1-tier3.1): replaced 🟢/🟡/🔴 emoji badges with

package/dist/cli/v4/chatSession.js

@@ -69,7 +69,16 @@ exports.renderProgressBar = renderProgressBar;
 exports.formatTokens = formatTokens;
 exports.formatDuration = formatDuration;
 exports.renderMemoryConfirmations = renderMemoryConfirmations;
+// v4.1.5+ Path A: env-var-gated loop trace logger. Captures tool-call
+// sequence + system prompt + memory hashes when a turn shows loop
+// symptoms (10+ calls OR 5+ consecutive same-name). Default off via
+// `AIDEN_DEBUG_LOOP=1` env-var. Zero overhead when disabled.
+const loopTrace_1 = require("../../core/v4/loopTrace");
 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"));
@@ -414,9 +423,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;
@@ -885,40 +907,226 @@ 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)
+        // v4.1.5 Issue O — track whether this turn had any tool calls so
+        // we can emit a single muted rule between the tool trail and the
+        // reply header. Set true when the first tool's `before` phase
+        // fires (via the existing beforeFirstToolHook plumbing). Emitted
+        // once per turn — `separatorEmitted` gates idempotency against
+        // both streaming and non-streaming paths reaching the same hook.
+        //
+        // v4.1.5 Phase 1d (Q-OBV-b) — multi-tool separator regression:
+        // the prior v4.1.5 Phase 1c emission point was the streaming
+        // `onFirstDelta` callback, but that fires PER provider call
+        // (the agent resets `firstDeltaFired` each callProvider
+        // invocation), and on multi-tool turns where the model emits
+        // no preamble in early iterations + no preamble in the final
+        // reply iteration either, the relative ordering of "first
+        // delta" vs "first tool" could leave the flag/idempotency
+        // gate in an unexpected state. Definitive fix: tie emission
+        // to the FIRST STREAM BYTE LANDING ON SCREEN, which only
+        // happens once per turn regardless of how many provider
+        // iterations occurred. `firstStreamByteSeen` is the new gate;
+        // separator fires from inside `onDelta` BEFORE `streamPartial`
+        // writes the agent header.
+        let turnHadTools = false;
+        let separatorEmitted = false;
+        let firstStreamByteSeen = false;
+        // v4.1.5+ Path A: per-turn loop tracer (env-var gated, default off).
+        // Captures tool-call sequence + assembled system prompt + memory
+        // hashes + recent skills when a turn trips loop thresholds. The
+        // `onLoopWarning` callback surfaces a one-line dim hint to the
+        // user when consecutive-same-tool count crosses 8 — gives them a
+        // chance to Ctrl+C before the agent burns more budget.
+        const loopTracer = new loopTrace_1.LoopTracer({
+            paths: this.opts.paths,
+            providerId: this.currentProviderId,
+            modelId: this.currentModelId,
+            onLoopWarning: (line) => {
+                try {
+                    this.opts.display.dim(line);
+                }
+                catch { /* defensive */ }
+            },
+        });
+        if (loopTracer.isEnabled()) {
+            loopTracer.setHistory(baseHistory);
+        }
+        const emitToolReplySeparator = () => {
+            if (separatorEmitted || !turnHadTools)
+                return;
+            separatorEmitted = true;
+            // Same chrome pattern as the existing pre-turn rule (line ~1100)
+            // and the post-reply rule (line ~1297): two-space indent + the
+            // body-width muted rule + newline. The 2-space indent is the
+            // legacy convention used by adjacent rules; the v4.1.5 frame
+            // gutter (3) is consciously NOT applied here so all three rules
+            // in a turn share one left edge.
+            this.opts.display.write(`  ${this.opts.display.rule()}\n`);
+        };
+        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 */ }
+            // v4.1.5 Issue K — also clear the phase-verb sink so lifecycle
+            // events fired during async cleanup don't try to update a
+            // stopped indicator.
+            try {
+                this.opts.callbacks.setPhaseVerbHook?.(undefined);
+            }
+            catch { /* defensive */ }
+            // v4.1.5+ Path A — clear the loop-trace sink so subsequent
+            // turns don't fire into a stale tracer. Note: this clears the
+            // HOOK, not the tracer's accumulated state — finalize() still
+            // runs at end-of-try below to write the snapshot if thresholds
+            // tripped.
+            try {
+                this.opts.callbacks.setToolTraceHook?.({});
+            }
+            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);
+        // v4.1.5 Issue K — wire the per-turn phase-verb sink. Each
+        // AidenAgent lifecycle event (memory refresh start, prompt built,
+        // provider request start) flows through CliCallbacks and lands
+        // here as a verb string ("refreshing memory" / "preparing prompt"
+        // / "calling provider"). The closure captures the per-turn
+        // indicator handle so verb mutations stay scoped to this turn.
+        this.opts.callbacks.setPhaseVerbHook?.((verb) => {
+            if (indicatorStopped)
+                return;
+            indicator.setVerb(verb);
+        });
+        // v4.1.5+ Path A — wire the loop-trace sink. Fires for EVERY tool
+        // call (including hidden ones) so the trace captures the full
+        // agent loop. Defensive — when AIDEN_DEBUG_LOOP is unset, the
+        // tracer's `startTool`/`endTool` short-circuit immediately.
+        this.opts.callbacks.setToolTraceHook?.({
+            before: (id, name) => loopTracer.startTool(id, name),
+            after: (id, name, args) => loopTracer.endTool(id, name, args),
+        });
+        // 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.
+        //
+        // v4.1.5 Issue O — also flip `turnHadTools = true` so the
+        // separator emits before the reply header. Single hook captures
+        // "any tool ran this turn" cleanly (it only fires for the FIRST
+        // tool of the turn — subsequent tools don't re-trigger).
+        this.opts.callbacks.setBeforeFirstToolHook?.(() => {
+            turnHadTools = true;
+            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;
+                        // v4.1.5 Phase 1d (Q-OBV-b) — separator emission MOVED
+                        // out of onFirstDelta because that callback fires per
+                        // provider-call iteration (firstDeltaFired resets each
+                        // callProvider invocation). The separator-emit now
+                        // lives in onDelta below, gated by `firstStreamByteSeen`
+                        // which only flips once per turn.
                     }
                     : undefined,
                 onDelta: streamingEnabled
                     ? (text) => {
+                        // v4.1.5 Phase 1d (Q-OBV-b) — definitive separator
+                        // emission point. This is the FIRST text byte landing
+                        // on screen this turn. Fires the muted rule BEFORE
+                        // streamPartial writes the `┃ Aiden` header so the
+                        // visual order is:
+                        //   ┊ tool rows...
+                        //   ────────────  ← separator
+                        //   ┃ Aiden
+                        //   {text}
+                        // Idempotent via `firstStreamByteSeen` + the
+                        // `separatorEmitted` flag inside emitToolReplySeparator.
+                        // No-op when no tool fired (turnHadTools=false).
+                        if (!firstStreamByteSeen) {
+                            firstStreamByteSeen = true;
+                            emitToolReplySeparator();
+                        }
+                        // 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,
@@ -927,8 +1135,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;
@@ -951,6 +1181,11 @@ class ChatSession {
             // When streaming was active and emitted the final content already,
             // skip the markdown re-render — we'd otherwise duplicate text.
             if (result.finalContent && !streamingActive) {
+                // v4.1.5 Issue O — non-streaming reply path. Emit the muted
+                // rule between the tool trail and the agent header before
+                // the one-shot reply lands. Idempotent + tool-gated by
+                // `emitToolReplySeparator`.
+                emitToolReplySeparator();
                 this.opts.display.write(this.opts.display.agentTurn(result.finalContent));
             }
             if (this.sessionId) {
@@ -964,9 +1199,25 @@ class ChatSession {
             // post-turn status footer.
             this.opts.display.write(`  ${this.opts.display.rule()}\n`);
             this.renderStatusLine();
+            // v4.1.5+ Path A — finalize the loop trace. No-op if the env
+            // var is unset OR if the turn didn't trip any threshold. When
+            // it DOES emit, the snapshot path goes to a dim status line so
+            // the user (and any teammate they're sharing the log with)
+            // knows where to grab the diagnostic file.
+            try {
+                const snapPath = await loopTracer.finalize();
+                if (snapPath) {
+                    this.opts.display.dim(`[loop-trace] wrote ${snapPath}`);
+                }
+            }
+            catch { /* defensive */ }
         }
         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);
@@ -1008,6 +1259,16 @@ class ChatSession {
             }
             this.setStatusState({ kind: 'ready' });
             this.lastTurnElapsedMs = Date.now() - turnStartedAt;
+            // v4.1.5+ Path A — finalize the loop trace on the error path
+            // too. Loop patterns that ended in an error are exactly the
+            // ones most worth capturing for diagnosis.
+            try {
+                const snapPath = await loopTracer.finalize();
+                if (snapPath) {
+                    this.opts.display.dim(`[loop-trace] wrote ${snapPath}`);
+                }
+            }
+            catch { /* defensive */ }
         }
     }
     // ── Startup card (Phase 26.2.4: neofetch-style sectioned) ──────────