@semalt-ai/code 1.19.0 → 1.20.1

package/lib/commands/chat-turn.js

@@ -10,7 +10,11 @@
 // session ctx — those callbacks use only the per-tool fields, never session state.
 
 const { resolveMaxIterations } = require('../config');
-const { createWebActivityTracker } = require('../ui/web-activity');
+const { createWebActivityTracker, serializeWebOp } = require('../ui/web-activity');
+const { createFileActivityTracker } = require('../ui/file-activity');
+const { buildToolOperation, serializeOperation } = require('../ui/tool-operation');
+const { renderOperation } = require('../ui/render-operation');
+const { normalizeCmdForDisplay } = require('../ui/format');
 
 function createTurnHandler(ctx, slashHandlers) {
   // The session ctx — the per-tool callbacks below intentionally shadow `ctx`
@@ -19,7 +23,7 @@ function createTurnHandler(ctx, slashHandlers) {
   const sessionCtx = ctx;
   const {
     inputField, statusBar, chatHistory, getConfig, approxTokens, resolveCommand,
-    runAgentLoop, opts, TAG_REGISTRY, formatToolLine, writerModule,
+    runAgentLoop, opts, TAG_REGISTRY, writerModule,
     collapseListMsg, handlePendingSelection, showPendingStep, activateNavCapture, finalizeListMsg,
     createChatIfNeeded, saveTurnToDashboard, saveSession,
   } = ctx;
@@ -134,6 +138,30 @@ function createTurnHandler(ctx, slashHandlers) {
     // think block (Qwen3-style: plain text followed by </think>, no opening tag).
     let implicitThinkPhase = !opts.showThink;
     let implicitThinkBuffer = '';
+    // Live-narration safety signals for the NATIVE rail only (XML rail ignores
+    // all three and keeps the buffered-until-boundary behavior unchanged):
+    //   • nativeRail            — set from onStreamStart's first arg; true only
+    //                             when this stream is on the native tool-call rail.
+    //   • reasoningSeen         — signal (a): a delta.reasoning_content arrived this
+    //                             iteration, proving the model uses the structured
+    //                             reasoning channel → subsequent content is narration.
+    //   • inlineReasoningFalse  — signal (b): the active profile asserts
+    //                             inline_reasoning:false → never inlines reasoning.
+    // When nativeRail AND (reasoningSeen OR inlineReasoningFalse), onToken may
+    // eager-open the implicit-think gate and stream narration live (see below).
+    let nativeRail = false;
+    let reasoningSeen = false;
+    let inlineReasoningFalse = false;
+    // Orphan closing reasoning tag, emitted VERBATIM by the StreamParser: a lone
+    // </think> (or </reasoning>/</reflection>/</plan>) has no matching open tag, so
+    // the parser's closing form `/think` is not a TAG_REGISTRY key (the registry
+    // keys are the bare names) and it streams the literal `</tag>` through onToken
+    // (agent.js StreamParser: `if (!entry) this.onToken('<' + tagRaw + '>')`).
+    // MiniMax-style models emit reasoning via BOTH reasoning_content AND an inline
+    // </think> terminator in content; that stray tag must never reach the terminal.
+    // Persisted history is already clean (cleanAssistantContent strips it), so this
+    // guard is live-stream-only. Match exactly the raw-emitted closing shapes.
+    const ORPHAN_CLOSE_TAG_RE = /^<\/(think|reasoning|reflection|plan)>$/i;
 
     // Web-activity collapse (Task W.3): in the default (non-debug) view, a run of
     // consecutive web ops (web_search → http_get) renders as ONE process-summary
@@ -141,6 +169,14 @@ function createTurnHandler(ctx, slashHandlers) {
     // is bypassed and web ops render the normal per-op way (full detail).
     const webTracker = createWebActivityTracker({ writerModule });
 
+    // File-activity collapse (parallel instance of the web tracker): in the
+    // default (non-debug) view, a run of consecutive same-type pure file reads
+    // (read_file / list_dir) collapses into ONE process-summary line instead of a
+    // per-op line each — unless the run is only 1–2 ops, which still commit as
+    // individual lines (decided at flush). read and list group SEPARATELY. Fresh
+    // per turn. In --debug the tracker is bypassed (full per-op detail).
+    const fileTracker = createFileActivityTracker({ writerModule });
+
     const callbacks = {
       onThinking: () => statusBar.update('thinking', 'Thinking...'),
       onRequestSent: () => {
@@ -148,14 +184,56 @@ function createTurnHandler(ctx, slashHandlers) {
         // Reset think-phase detection for each new agent iteration.
         implicitThinkPhase = !opts.showThink;
         implicitThinkBuffer = '';
+        // Reset the live-narration safety signals alongside the gate — each API
+        // call re-establishes the rail and re-observes the reasoning channel.
+        nativeRail = false;
+        reasoningSeen = false;
+        inlineReasoningFalse = false;
       },
-      onStreamStart: () => {
+      onStreamStart: (isNativeRail, inlineReasoning) => {
+        // Capture the rail + inline-reasoning assertion threaded from agent.js
+        // (signal b). Recorded BEFORE the first content token so onToken's
+        // eager-open check below sees them on the very first token.
+        nativeRail = !!isNativeRail;
+        inlineReasoningFalse = inlineReasoning === false;
         // If showThink is on, switch to streaming immediately.
         // Otherwise keep "Thinking…" until </think> is resolved.
         if (opts.showThink) statusBar.update('streaming', 'Streaming response');
       },
+      onReasoningStart: () => {
+        // Signal (a): the model emitted reasoning_content this iteration, so the
+        // structured reasoning channel is in use. Fires before any delta.content
+        // token, so the eager-open in onToken sees it for the first token.
+        reasoningSeen = true;
+      },
       onTagOpen: (tag, attrs) => {
         const entry = TAG_REGISTRY[tag];
+        // Positive-evidence early exit from the implicit-think gate (live narration).
+        // The gate buffers leading bare text because a Qwen3-style model emits implicit
+        // reasoning as bare text terminated by an orphan </think> — and that reasoning
+        // is indistinguishable from ordinary narration until the boundary arrives. So
+        // for a plain bare-text preamble we STAY buffered until </think> (handled in
+        // onToken); flipping early there could stream hidden reasoning = a leak.
+        // But two tag openings are positive PROOF the bare text is NOT implicit
+        // reasoning, so we can open the gate and start streaming live immediately:
+        //   • a <think>/<reasoning>/<reflection>/<plan> tag (display:'think_bubble')
+        //     means THIS model delimits reasoning with explicit tags; that inner
+        //     content is consumed by the StreamParser and never reaches onToken (and is
+        //     suppressed by handleTag when !showThink), so any bare text outside the
+        //     tag is narration — safe to stream.
+        //   • a <final_answer> (type:'final') streams its inner content THROUGH onToken
+        //     (streamInner in the parser), so the gate must open or the answer is
+        //     swallowed by the buffer.
+        // We deliberately do NOT exit on a tool tag: bare-reasoning-then-tool with no
+        // </think> is possible (malformed implicit-think), so opening there could leak.
+        // Any buffered leading text is DISCARDED here (treated as reasoning), never
+        // flushed — preserving implicit-think suppression.
+        if (!opts.showThink && implicitThinkPhase &&
+            (entry?.display === 'think_bubble' || entry?.type === 'final')) {
+          implicitThinkPhase = false;
+          implicitThinkBuffer = '';
+          statusBar.update('streaming', 'Streaming response');
+        }
         if (entry?.type === 'tool') {
           const actionLabel = entry.label || tag;
           const detail = attrs.path || attrs.url || attrs.key || attrs.src || '';
@@ -176,13 +254,36 @@ function createTurnHandler(ctx, slashHandlers) {
         statusBar.update('streaming', 'Streaming response');
       },
       onPermissionAsk: (tag, input) => {
+        // Flush any open file/web activity group BEFORE the permission picker
+        // opens. The permission gate fires ahead of onToolStart (agent.js — the
+        // "ask before onToolStart" comment), so the non-groupable flush that
+        // onToolStart normally performs (below) is sequenced AFTER the modal and
+        // can't fire while it's open — leaving an open group stranded LIVE in the
+        // writer's activity region beside the prompt for the modal's whole life.
+        // Flush here so the group commits to scrollback ABOVE the prompt instead.
+        // This is safe to do unconditionally: groupable tools (read_file/list_dir)
+        // are read-only with a NULL permission descriptor, so onPermissionAsk
+        // NEVER fires for them — by the time we get here the prompting tool is by
+        // definition non-groupable, exactly the case onToolStart already flushes.
+        // flush() is idempotent (isOpen()/groupId===null guard), so the later
+        // onToolStart flush, the turn-end finally flush, or the deny path all
+        // become no-ops — no double commit. Covers the deny case too: a denied
+        // tool's group is committed here rather than stranded until the finally.
+        if (webTracker.isOpen()) webTracker.flush();
+        if (fileTracker.isOpen()) fileTracker.flush();
         // Status-bar update fires while the permission picker is open so
         // the user can see what's pending in the side label, not just
         // inside the modal. Mirrors the labels onToolStart uses post-grant
         // — the next streaming/idle state will overwrite this when the
         // picker closes (whether granted or denied).
         const actionLabel = TAG_REGISTRY[tag]?.label || tag;
-        const short = input && input.length > 40 ? input.slice(0, 40) + '…' : (input || '');
+        // Flatten embedded newlines/tabs (e.g. heredoc commands) BEFORE the
+        // slice so the status label is a single physical row. A raw slice of
+        // multi-line input rides a \n into the status string → the live region
+        // mis-counts rows (1 logical line spanning 2+ physical rows) and leaks
+        // stale rules/spinners into scrollback. See Phase 4 fix-A.
+        const flat = normalizeCmdForDisplay(input);
+        const short = flat.length > 40 ? flat.slice(0, 40) + '…' : flat;
         const isDownload = tag === 'download' || tag === 'http_get';
         if (isDownload) {
           statusBar.update('waiting_download', `Waiting for download: ${short}`);
@@ -191,24 +292,42 @@ function createTurnHandler(ctx, slashHandlers) {
         }
       },
       onToolStart: (tag, input, ctx) => {
+        // Phase 7b boundary — commit the PREVIOUS op's held detail band to
+        // scrollback BEFORE this op's running line (or web group) is installed,
+        // so the committed preview lands above the new activity row. Mirrors the
+        // web tracker's "flush previous, then start new" sequencing. No-op when
+        // nothing is deferred. Runs before the web branch too, so a non-web
+        // preview followed by a web op still commits in chronological order.
+        chatHistory.commitDeferredDetail();
         const actionLabel = TAG_REGISTRY[tag]?.label || tag;
-        const short = input && input.length > 40 ? input.slice(0, 40) + '…' : (input || '');
+        // Flatten before slicing — see onPermissionAsk above (Phase 4 fix-A).
+        const flat = normalizeCmdForDisplay(input);
+        const short = flat.length > 40 ? flat.slice(0, 40) + '…' : flat;
         const isDownload = tag === 'download' || tag === 'http_get';
         if (isDownload) {
           statusBar.update('waiting_download', `Waiting for download: ${short}`);
         } else {
           statusBar.update('tool', `${actionLabel}: ${short}`);
         }
-        // Web-activity collapse (Task W.3): in the default view, fold this web op
-        // into the running process-summary line instead of its own activity row.
-        // --debug keeps the per-op line (fall through to the normal path below).
-        if (!sessionCtx.debugMode && webTracker.isWeb(tag)) {
+        // Web- and file-activity collapse: in the default view, fold this op into
+        // its running process-summary line instead of its own activity row.
+        // --debug bypasses both trackers (full per-op detail). Switching group
+        // type — or starting a non-grouped tool — closes the OTHER open group
+        // first, so its committed summary lands ABOVE this op in scrollback. (A
+        // read↔list key change within the file group is handled inside
+        // fileTracker.start.)
+        const webOp = !sessionCtx.debugMode && webTracker.isWeb(tag);
+        const fileOp = !sessionCtx.debugMode && fileTracker.isGroupable(tag);
+        if (!webOp && webTracker.isOpen()) webTracker.flush();
+        if (!fileOp && fileTracker.isOpen()) fileTracker.flush();
+        if (webOp) {
           webTracker.start(tag, input);
           return;
         }
-        // A non-web tool (or debug mode) closes any open web group first, so its
-        // committed summary lands ABOVE this tool's line in scrollback.
-        if (webTracker.isOpen()) webTracker.flush();
+        if (fileOp) {
+          fileTracker.start(tag, input);
+          return;
+        }
         // Register the invocation with the writer's activity region.
         // The render function is re-invoked by the writer on every
         // redraw so the pending line's elapsed time stays current with
@@ -223,23 +342,21 @@ function createTurnHandler(ctx, slashHandlers) {
         // name check with a category flag (e.g. blocking: true on the
         // tool spec) if more blocking tools appear.
         if (ctx && ctx.id) {
+          // Output Refactor (Phase 1): the interactive core tool line is now
+          // produced via a ToolOperation descriptor → the pure renderOperation,
+          // instead of an inline formatToolLine call. Byte-for-byte identical —
+          // this is a re-routing, not a re-styling.
           if (tag === 'ask_user') {
-            const staticLine = formatToolLine({
-              status: 'pending',
-              tag,
-              arg: input,
-              attrs: ctx.attrs,
-              noDuration: true,
-            });
+            const staticLine = renderOperation(
+              buildToolOperation({ id: ctx.id, tag, arg: input, attrs: ctx.attrs, status: 'pending', noDuration: true }),
+              { mode: 'ansi', phase: 'pending' },
+            );
             writerModule.startActivity(ctx.id, () => staticLine);
           } else {
-            writerModule.startActivity(ctx.id, (elapsedMs) => formatToolLine({
-              status: 'pending',
-              tag,
-              arg: input,
-              attrs: ctx.attrs,
-              durationMs: elapsedMs,
-            }));
+            writerModule.startActivity(ctx.id, (elapsedMs) => renderOperation(
+              buildToolOperation({ id: ctx.id, tag, arg: input, attrs: ctx.attrs, status: 'pending', durationMs: elapsedMs }),
+              { mode: 'ansi', phase: 'pending' },
+            ));
           }
         }
       },
@@ -250,21 +367,55 @@ function createTurnHandler(ctx, slashHandlers) {
         // failure (a 403/406 or timeout shows as "blocked"); the detailed error
         // body stays hidden in the collapsed view (visible under --debug).
         if (!sessionCtx.debugMode && webTracker.isWeb(tag)) {
+          // Live display unchanged — the tracker still owns the collapsed web
+          // summary region. Phase 6c-i: instead of returning `undefined` (which
+          // persisted a `null` slot → web vanished into the legacy whole-blob
+          // summary on replay), hand back a dedicated web-op core so the agent
+          // loop's `displayCore || null` push stores it on BOTH rails (native
+          // {role:'tool'} `_display`; XML `_display[]` slot). Nothing in the live
+          // render path reads this return value, so the live region is untouched;
+          // every replay reader treats the web-core as fallback (chat-history /
+          // chat-session) so the screen stays byte-identical until 6c-ii.
           webTracker.end(tag, result, durationMs, ctx);
           if (hasError) statusBar.update('streaming', 'Streaming response');
-          return;
+          return serializeWebOp(ctx, tag, durationMs);
         }
         const isBlocking = tag === 'ask_user';
-        const finalLine = formatToolLine({
-          status: hasError ? 'failure' : 'success',
+        // Output Refactor (Phase 1): build ONE descriptor for this finished call
+        // and render both the committed result line and (below) its diff detail
+        // from it — the single source of truth, replacing the inline
+        // formatToolLine + buildExecutionDiff pair. Byte-for-byte identical.
+        const operation = buildToolOperation({
+          id: ctx ? ctx.id : null,
           tag,
           arg: ctx && ctx.attrs ? (ctx.attrs.command || ctx.attrs.path || ctx.attrs.url || ctx.attrs.src || ctx.attrs.key || ctx.attrs.name || ctx.attrs.pattern) : '',
           attrs: ctx ? ctx.attrs : null,
+          status: hasError ? 'error' : 'ok',
           durationMs,
           meta: ctx ? ctx.meta : null,
           error: ctx ? ctx.error : null,
+          diff: ctx ? ctx.diff : null,
+          // Phase 5: hand the model-facing result to the descriptor so it can
+          // derive an output-preview detail (shell/MCP/subagent). Chrome only —
+          // the model already received the full result via boundToolOutput.
+          output: typeof result === 'string' ? result : null,
           noDuration: isBlocking,
         });
+        // File-activity collapse: a SUCCESSFUL read_file/list_dir folds into the
+        // running file-group aggregate instead of committing its own line — the
+        // group's single summary (or, for a 1–2 op run, the individual lines)
+        // commits at flush. The op core is STILL persisted here (serializeOperation
+        // below) so replay re-groups it. An ERRORED file op does NOT join the
+        // group: it falls through to flush the success-group first (so its summary
+        // lands ABOVE), then renders the error standalone + error body.
+        if (!sessionCtx.debugMode && !hasError && fileTracker.isGroupable(tag)) {
+          fileTracker.end(operation);
+          return serializeOperation(operation);
+        }
+        // A non-grouped tool end (or an errored file op) closes any open file
+        // group first, so its committed summary lands ABOVE this line.
+        if (fileTracker.isOpen()) fileTracker.flush();
+        const finalLine = renderOperation(operation, { mode: 'ansi', phase: 'result' });
         if (ctx && ctx.id) {
           writerModule.endActivity(ctx.id, finalLine);
         } else {
@@ -273,6 +424,37 @@ function createTurnHandler(ctx, slashHandlers) {
           // to a direct scrollback line so the tool still leaves a trace.
           writerModule.scrollback(finalLine);
         }
+        // Execution-time file-edit diff. This is the SINGLE site the full diff of
+        // a successful mutating edit renders — decoupled from the permission modal,
+        // so an auto-approved edit shows its diff exactly like a manual one, and
+        // every entry mode (fresh / --resume / /history / /chats) renders it the
+        // same way. Loaded history replays through displayLoadedMessages (summaries
+        // only), never onToolEnd, so past turns carry no diff payload and are not
+        // replayed. Capped at config.diff_max_lines (head+tail for a large edit).
+        if (!hasError && operation.detail && operation.detail.kind === 'diff') {
+          const diffStr = renderOperation(operation, {
+            mode: 'ansi',
+            phase: 'detail',
+            maxLines: (getConfig() || {}).diff_max_lines,
+          });
+          if (diffStr) writerModule.scrollback(diffStr);
+        }
+        // Phase 5/7b: collapsed output preview for shell/MCP/subagent successes.
+        // DEFERRED into the writer's redrawable detail band (not committed to
+        // scrollback yet) — the held slot commits once at the next boundary
+        // (next-op start / assistant answer / turn end). The preview is static
+        // (first N lines + `… M more lines`, no expand affordance). Model-facing
+        // context is untouched (the full output already reached the model). The
+        // result line above and any diff still commit immediately.
+        if (!hasError && operation.detail && operation.detail.kind === 'output') {
+          chatHistory.deferToolOutput({
+            role: 'tool',
+            tag,
+            content: '',
+            output: operation.detail.payload.body,
+            previewLines: (getConfig() || {}).shell_preview_lines || 5,
+          });
+        }
         if (hasError) {
           // Preserve the expandable error body as a follow-up tool
           // bubble. Empty content suppresses its header so the scrollback
@@ -283,46 +465,123 @@ function createTurnHandler(ctx, slashHandlers) {
           }
           statusBar.update('streaming', 'Streaming response');
         }
+        // Phase 6a — hand the SAME descriptor back to the agent loop (serialized)
+        // so the native rail can persist it as a `_display` sibling on the tool
+        // result message; replay then rebuilds it for full-fidelity rendering.
+        // Display chrome only — never touches the model-facing `content`. The
+        // web-activity path above returns its own web-op core (Phase 6c-i) which
+        // every replay reader routes to the legacy fallback, so web ops still
+        // render via the summary on replay (aggregation lands in 6c-ii).
+        return serializeOperation(operation);
       },
       onToken: (token) => {
         if (!opts.showThink && implicitThinkPhase) {
-          // Check if this token is the closing think tag (Qwen3-style implicit think).
-          if (/^<\/(think|reasoning|reflection)>$/i.test(token.trim())) {
-            // Thinking phase is over — discard buffered reasoning, start streaming.
+          // NATIVE-RAIL eager-open (live token-by-token narration). Gated on a
+          // safety signal so reasoning is NEVER leaked: open the gate eagerly
+          // ONLY when this stream is on the native rail AND the model has proven
+          // (a) it uses the structured reasoning channel this iteration
+          // (reasoningSeen) OR (b) it asserts inline_reasoning:false. In either
+          // case the leading content is narration, so we open the gate, drop the
+          // (empty) buffer, and fall through to stream THIS token live. The XML
+          // rail and the no-signal native case skip this branch entirely and keep
+          // the buffered-until-boundary fallback below (no behavior change, no
+          // leak). Mirror the think_bubble/orphan-</think> exits' status update.
+          if (nativeRail && (reasoningSeen || inlineReasoningFalse)) {
             implicitThinkPhase = false;
             implicitThinkBuffer = '';
             statusBar.update('streaming', 'Streaming response');
+            // fall through — stream this and all subsequent tokens live. The
+            // orphan-close-tag filter below still runs so a stray </think> that
+            // MiniMax inlines alongside reasoning_content never reaches the
+            // terminal (regression from 938f583's eager-open, which skipped the
+            // else-branch's drop guard for this and every subsequent token).
+          } else {
+            // Check if this token is the closing think tag (Qwen3-style implicit think).
+            if (ORPHAN_CLOSE_TAG_RE.test(token.trim())) {
+              // Thinking phase is over — discard buffered reasoning, start streaming.
+              implicitThinkPhase = false;
+              implicitThinkBuffer = '';
+              statusBar.update('streaming', 'Streaming response');
+              return;
+            }
+            // Buffer the token; keep the thinking animation visible.
+            implicitThinkBuffer += token;
             return;
           }
-          // Buffer the token; keep the thinking animation visible.
-          implicitThinkBuffer += token;
-          return;
+        }
+        // Drop any orphan closing reasoning tag on every token, regardless of which
+        // branch opened the gate (eager-open or showThink). The StreamParser emits
+        // these verbatim, so once the gate is open they would otherwise stream live.
+        if (ORPHAN_CLOSE_TAG_RE.test(token.trim())) return;
+        // Ordering fix (Option b) — flush any open file/web activity group BEFORE
+        // the FIRST content-bearing narration token commits to scrollback. Streamed
+        // narration commits INCREMENTALLY: streamToken() emits the "▸ AI-agent"
+        // header and each complete line to immutable scrollback (chat-history.js)
+        // BEFORE onAssistantMessage/finalizeLastMessage ever fires. So flushing only
+        // at onAssistantMessage is too LATE for the streamed path — the narration
+        // lines are already above a still-open group, which then commits BELOW the
+        // conclusion it's based on (the "list ×3 below 'directory almost empty'"
+        // bug). Flushing here, at streaming-start, guarantees the group's summary
+        // commits ABOVE the first visible narration line.
+        //
+        // Gate strictly: only when the stream has NOT yet started (so we flush once,
+        // before the header) AND this token carries non-whitespace content — pure
+        // whitespace streaming artifacts in a silent read,read,read run must NOT
+        // flush, so such runs still collapse to one "explored ×N". flush() is
+        // idempotent (groupId===null guard), so the later onAssistantMessage,
+        // onToolStart, onPermissionAsk, and turn-end finally flushes all no-op —
+        // exactly one commit.
+        if (token && token.trim() && !chatHistory.isStreaming?.()) {
+          if (webTracker.isOpen()) webTracker.flush();
+          if (fileTracker.isOpen()) fileTracker.flush();
         }
         chatHistory.streamToken(token);
         statusBar.onToken();
       },
-      onAssistantMessage: (cleanContent) => {
-        // If </think> was never seen, the model had no implicit think block —
-        // flush whatever was buffered as normal streaming content.
+      onAssistantMessage: (cleanContent, meta) => {
+        // If </think> was never seen, the model had no implicit think block — its
+        // leading text was ordinary narration. Drop the raw buffered tokens: the
+        // cleaned, canonical narration arrives as `cleanContent` and is rendered by
+        // finalizeLastMessage below (as a pre-tool bubble when nothing streamed live),
+        // so re-emitting the raw buffer would double it.
         if (implicitThinkPhase && implicitThinkBuffer) {
           implicitThinkPhase = false;
           implicitThinkBuffer = '';
         }
-        // Web-activity ordering (W.3 regression fix): commit any still-open web
-        // group BEFORE the answer is finalized, so the collapsed "✓ web · …"
-        // summary lands ABOVE the answer in scrollback (pre-W.3 ordering).
+        // Terminal-iteration signal. agent.js now passes `{ terminal }` explicitly
+        // (true only on the final, no-tool-call answer). Fall back to the legacy
+        // "content is non-empty" proxy when the flag is absent (older callers / the
+        // web-ordering unit tests drive these callbacks directly with one arg).
+        const terminal = meta && typeof meta.terminal === 'boolean'
+          ? meta.terminal
+          : !!(cleanContent && cleanContent.trim());
+        // Ordering fix (Option b) — commit any still-open file/web activity group
+        // BEFORE the answer is finalized, so the collapsed summary lands ABOVE the
+        // narration in scrollback (correct chronological ordering: a conclusion has
+        // the group it's based on committed above it).
         //
-        // Guard on non-empty content: that is exactly the "terminal response"
-        // signal. Intermediate web-tool iterations pass cleanContent === ''
-        // (suppressed because they carried tool calls — agent.js), so they do
-        // NOT flush — the group stays open and the multi-step search→fetch
-        // activity stays collapsed into a single line (the W.3 guarantee).
-        // The final-answer iteration passes non-empty content → flush once.
-        // Empty/interrupted turns (no non-empty message ever arrives) fall back
-        // to the turn-end `finally` flush, which is now the safety net.
-        if (cleanContent && cleanContent.trim() && webTracker.isOpen()) {
+        // Flush on the TERMINAL signal (the final no-tool answer) OR on any
+        // CONTENT-BEARING intermediate narration. This is the deliberate Option-(b)
+        // tradeoff: an intermediate narration that carries visible content now
+        // flushes the open group, so a "chatty" multi-read run FRAGMENTS into
+        // correctly-ordered sub-groups (each "explored ×N" above its narration)
+        // rather than collapsing across a conclusion that was based on it. A SILENT
+        // multi-read run (empty/whitespace-only interim narration — pure streaming
+        // artifacts) does NOT flush, so it still collapses fully to one summary.
+        //
+        // For the STREAMED path the open group is already committed above by the
+        // onToken streaming-start flush; this is the backstop for the non-streaming
+        // / finalize-only path (and the direct-callback unit tests). flush() is
+        // idempotent, so when both fire only one commit results. Empty/interrupted
+        // turns (no terminal message, no content) fall back to the turn-end
+        // `finally` flush, which is the safety net.
+        const contentful = !!(cleanContent && cleanContent.trim());
+        if ((terminal || contentful) && webTracker.isOpen()) {
           webTracker.flush();
         }
+        if ((terminal || contentful) && fileTracker.isOpen()) {
+          fileTracker.flush();
+        }
         chatHistory.finalizeLastMessage(cleanContent);
       },
       onMetricsUpdate: (data) => statusBar.updateMetrics(data),
@@ -330,8 +589,8 @@ function createTurnHandler(ctx, slashHandlers) {
         statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
       },
       onDebug: (block) => {
-        // Render in-history as a tool-style bubble so ctrl+O expand works and
-        // the RAW RESPONSE text survives TUI redraws (stderr would be clobbered).
+        // Render in-history as a tool-style bubble so the RAW RESPONSE text
+        // survives TUI redraws (stderr would be clobbered).
         chatHistory.addMessage({ role: 'tool', tag: 'debug', content: 'DEBUG', output: block });
       },
       onError: (err) => {
@@ -430,9 +689,17 @@ function createTurnHandler(ctx, slashHandlers) {
       statusBar.update('error', err.message || 'Agent error');
       chatHistory.addMessage({ role: 'system', content: err.message || 'Agent error', isError: true });
     } finally {
+      // Phase 7b boundary — commit any trailing op's held detail band before the
+      // turn unwinds (the turn may have ended right after a tool with no
+      // following message). No-op when nothing is deferred; ordered before the
+      // web flush (the two are mutually exclusive in practice).
+      try { chatHistory.commitDeferredDetail(); } catch { /* never block turn teardown */ }
       // Commit any still-open web-activity summary (the turn may have ended right
       // after a web op, or been interrupted mid-group) before the turn unwinds.
       try { webTracker.flush(); } catch { /* never block turn teardown */ }
+      // Commit any still-open file-activity group (turn ended right after a read
+      // run, or was interrupted mid-group) before the turn unwinds.
+      try { fileTracker.flush(); } catch { /* never block turn teardown */ }
       inputField.removeListener('abort', _onAbort);
     }
 

package/lib/commands/chat.js

@@ -86,13 +86,11 @@ function createChatCommand(deps) {
       onRemoveMessage:   (id)      => chatHistory.removeById(id),
       // Modal-region API: setModal replaces the modal live band above the
       // status region; clearModal drops it. Arrow-key redraws go through
-      // setModal only — no scrollback churn. When the picker resolves we
-      // clear the modal and push a single summary line to scrollback.
+      // setModal only — no scrollback churn. When the picker resolves we just
+      // clear the modal — the execution result line is the sole post-approval
+      // confirmation, so no summary line is pushed to scrollback (Phase 2 D1).
       onShowModal: (lines) => writer.setModal(lines),
-      onCloseModal: (summary) => {
-        writer.clearModal();
-        if (summary) chatHistory.addMessage({ role: 'system', content: summary });
-      },
+      onCloseModal: () => { writer.clearModal(); },
       onCaptureNavigation: (handler) => {
         inputField.captureNavigation(handler);
         return () => inputField.releaseNavigation();
@@ -100,8 +98,6 @@ function createChatCommand(deps) {
       captureSelect: (menu) => inputField.captureSelect(menu),
     });
 
-    inputField.on('expand', () => chatHistory.toggleLastExpand());
-
     const cwd = process.cwd();
     let currentModel = opts.model || getConfig().default_model;
     let resolvedTokenLimit = await resolveTokenLimit(currentModel);
@@ -331,6 +327,14 @@ function createChatCommand(deps) {
 
 
     statusBar.update('idle');
+    // Re-sync the clock to the input field's actual idle state. update('idle')
+    // unconditionally restarts the clock (the not-paused ⇒ clock-running
+    // invariant), but if an await above (resume / MCP connectAll) yielded the
+    // event loop, the one-shot _goIdle already fired and no active→idle
+    // transition will re-fire pause(). Converge both paths: if the field is
+    // already idle, pause the clock so the viewport can scroll. On a no-await
+    // start the field is not yet idle here, so this is a no-op.
+    if (inputField.isIdle()) statusBar.pause();
 
     // Slash-command handlers (lib/commands/chat-slash.js), keyed by the canonical
     // registry name. The parity check below guarantees registry ↔ handler stay

package/lib/config.js

@@ -206,6 +206,16 @@ function normalizeConfig(cfg = {}) {
           // native_tools defaults to true; only explicit false/0/"false"/"0" opts out.
           const nt = entry.native_tools;
           normalized.native_tools = !(nt === false || nt === 0 || nt === '0' || nt === 'false');
+          // inline_reasoning (live-narration safety signal): an OPTIONAL explicit
+          // boolean assertion about whether this model inlines its reasoning into
+          // delta.content (Qwen3-style bare text + orphan </think>). Left unset by
+          // default → assume it MIGHT inline (safe default: keep buffering until a
+          // boundary). Only an explicit `false` asserts "never inlines" → the agent
+          // loop may stream narration live from token 1 on the native rail. Only an
+          // explicit boolean is persisted; any other value is dropped (stays unset).
+          if (typeof entry.inline_reasoning === 'boolean') {
+            normalized.inline_reasoning = entry.inline_reasoning;
+          }
           // Multimodal image input (Task 5.4). `vision` (only when an explicit
           // boolean) marks the profile vision-capable or text-only; a text-only
           // profile makes an image attach fail LOUD rather than silently drop.
@@ -418,6 +428,22 @@ function isNativeToolsActive(model) {
   return !(profile && profile.native_tools === false);
 }
 
+// Resolves the active profile's `inline_reasoning` assertion (live-narration
+// safety signal b). Returns the explicit boolean if the profile sets one, else
+// `undefined` ("unknown — assume it might inline reasoning"). Mirrors the
+// profile lookup used by isNativeToolsActive. The agent loop treats only an
+// explicit `false` as the safe-to-stream-live signal.
+function getInlineReasoning(model) {
+  const cfg = loadConfig();
+  if (!Array.isArray(cfg.models)) return undefined;
+  const profile = cfg.models.find(
+    (p) => p && p.api_base === cfg.api_base && p.model === model
+  );
+  return profile && typeof profile.inline_reasoning === 'boolean'
+    ? profile.inline_reasoning
+    : undefined;
+}
+
 const REDACTED_KEYS = new Set(['api_key', 'auth_token']);
 
 function configShow(systemPromptOverride = null) {
@@ -457,6 +483,7 @@ module.exports = {
   configSet,
   configShow,
   isNativeToolsActive,
+  getInlineReasoning,
   loadConfig,
   loadUserConfig,
   normalizeConfig,