@semalt-ai/code 1.8.5 → 1.20.0

package/lib/commands/chat-turn.js

@@ -0,0 +1,669 @@
+'use strict';
+
+// The chat input/turn handler (cmdChat's inputField.onSubmit), extracted in
+// Task 1.5. Handles picker text-fallback navigation, slash-command dispatch, and
+// running a normal message through the agent loop with the full TUI callback
+// wiring. Mutable session fields go through ctx; session/picker/sync helpers and
+// stable collaborators are read from ctx (where cmdChat assigned them). Bodies
+// are unchanged. NOTE: the onToolStart/onToolEnd callbacks take a local `ctx`
+// parameter (the per-tool invocation context) that intentionally shadows the
+// session ctx — those callbacks use only the per-tool fields, never session state.
+
+const { resolveMaxIterations } = require('../config');
+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`
+  // with the per-invocation context, so capture the session here for the few
+  // session-level reads they need (the live --debug flag).
+  const sessionCtx = ctx;
+  const {
+    inputField, statusBar, chatHistory, getConfig, approxTokens, resolveCommand,
+    runAgentLoop, opts, TAG_REGISTRY, writerModule,
+    collapseListMsg, handlePendingSelection, showPendingStep, activateNavCapture, finalizeListMsg,
+    createChatIfNeeded, saveTurnToDashboard, saveSession,
+  } = ctx;
+
+  // Running session token totals for the cost indicator (Task 2.6). Each turn's
+  // Metrics is per-turn, so we accumulate here for a session cost in the bar.
+  const sessionUsage = { prompt_tokens: 0, completion_tokens: 0 };
+
+  return async (text) => {
+    // Handle pending selection (text fallback for non-TTY; TTY uses captureNavigation)
+    if (ctx.pendingAction) {
+      inputField.releaseNavigation();
+      const t = text.trim().toLowerCase();
+      const { items, displayItems: di, stepIdx, type } = ctx.pendingAction;
+      const activeItems = di || items;
+      if (t === 's' || t === 'select' || t === 'y' || t === 'yes') {
+        collapseListMsg(type, activeItems[stepIdx]);
+        statusBar.update('idle');
+        await handlePendingSelection(stepIdx);
+        inputField.setDisabled(false);
+        return;
+      } else if (t === 'n' || t === 'next') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: (stepIdx + 1) % items.length };
+        showPendingStep();
+        activateNavCapture();
+        return;
+      } else if (t === 'p' || t === 'prev') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: (stepIdx - 1 + items.length) % items.length };
+        showPendingStep();
+        activateNavCapture();
+        return;
+      } else if (t === 'c' || t === 'cancel') {
+        finalizeListMsg();
+        chatHistory.addMessage({ role: 'system', content: 'Cancelled.' });
+        ctx.pendingAction = null;
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+        return;
+      } else {
+        // Not a nav key: close nav silently and let the message go to AI
+        finalizeListMsg();
+        ctx.pendingAction = null;
+        statusBar.update('idle');
+        // fall through to AI processing below
+      }
+    }
+
+    // Slash-command dispatch via the registry (replaces the former if-chain).
+    // resolveCommand maps the raw text to a canonical command + its argument;
+    // null means "not a command" → fall through to the agent below.
+    const resolved = resolveCommand(text);
+    if (resolved) {
+      if (resolved.spec && resolved.spec.custom) {
+        // Custom (Markdown) command: render its template and let it fall through
+        // to the agent path below as the user prompt. It is submitted as text,
+        // never executed as code.
+        const { renderTemplate } = require('./custom');
+        text = renderTemplate(resolved.spec.template, resolved.arg);
+        if (!text.trim()) {
+          chatHistory.addMessage({ role: 'system', content: `✗ Custom command ${resolved.name} produced an empty prompt.`, isError: true });
+          return;
+        }
+      } else if (resolved.spec && resolved.spec.skill) {
+        // Skill invocation (Task 3.5): the system prompt carried only the skill's
+        // metadata. Loading the body HERE — on invocation — is the progressive
+        // disclosure: the instructions enter context only now. The body is read
+        // from SKILL.md, rendered (so $ARGUMENTS/$1 work if the author used them),
+        // and submitted to the agent as a user prompt, never executed as code.
+        const { loadSkillBody } = require('../skills');
+        const { renderTemplate } = require('./custom');
+        let body;
+        try { body = loadSkillBody(resolved.spec); } catch { body = ''; }
+        if (!body || !body.trim()) {
+          chatHistory.addMessage({ role: 'system', content: `✗ Skill ${resolved.name} has no loadable body.`, isError: true });
+          return;
+        }
+        const rendered = renderTemplate(body, resolved.arg);
+        // Skills may carry assets/scripts alongside SKILL.md — tell the agent where.
+        text = rendered + (resolved.spec.dir ? `\n\n(Skill assets directory: ${resolved.spec.dir})` : '');
+      } else {
+        await slashHandlers[resolved.name](resolved.arg, text);
+        return;
+      }
+    }
+
+
+    // Block unauthenticated users from running the agent
+    if (!getConfig().auth_token) {
+      chatHistory.addMessage({ role: 'system', content: '✗ Not logged in. Run /login first.', isError: true });
+      return;
+    }
+
+    // Normal message → run agent
+    inputField.setDisabled(true);
+    chatHistory.addMessage({ role: 'user', content: text });
+    statusBar.update('thinking', 'Thinking...');
+    // Bump the context-size indicator with this user message's approximate
+    // token count. It'll be overwritten with the exact prompt_tokens from
+    // the API response when the first turn completes — this just keeps the
+    // indicator reactive in the gap before that.
+    statusBar.addPendingTokens(approxTokens(text));
+    await createChatIfNeeded(text);
+    // Multimodal image input (Task 5.4): consume any images staged by /image and
+    // attach them to this user turn, then clear the staging buffer.
+    const stagedImages = (ctx.pendingImages && ctx.pendingImages.length) ? ctx.pendingImages : null;
+    ctx.pendingImages = [];
+    const userMessage = { role: 'user', content: text };
+    if (stagedImages) userMessage.images = stagedImages;
+    ctx.messages.push(userMessage);
+
+    // Per-turn state: buffer tokens until we know if the model is in an implicit
+    // 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
+    // line instead of a per-op line each. Fresh per turn. In --debug the tracker
+    // 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: () => {
+        statusBar.update('thinking', 'Thinking...');
+        // 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: (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 || '';
+          const isDownload = tag === 'download' || tag === 'http_get';
+          const barState = isDownload ? 'waiting_download' : 'tool';
+          const label = isDownload
+            ? `Waiting for download${detail ? ': ' + detail : ''}`
+            : `${actionLabel}${detail ? ': ' + detail : ''}`;
+          statusBar.update(barState, label);
+          if (!opts.showThink) chatHistory.clearStreamingContent();
+        }
+        if (entry?.display === 'think_bubble') {
+          statusBar.update('thinking', 'Reasoning...');
+        }
+      },
+      onThinkEnd: (content) => {
+        chatHistory.addMessage({ role: 'think', content });
+        statusBar.update('streaming', 'Streaming response');
+      },
+      onPermissionAsk: (tag, input) => {
+        // 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;
+        // 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}`);
+        } else {
+          statusBar.update('tool', `${actionLabel}: ${short}`);
+        }
+      },
+      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;
+        // 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- 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;
+        }
+        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
+        // the ticker cadence without an explicit refresh timer.
+        //
+        // ask_user is the only currently-blocking tool — it pauses the
+        // agent until the user responds via the modal. A ticking
+        // elapsed-time meter on a paused tool is misleading ("13s"
+        // suggests work is happening), and the per-tick redraw
+        // interacts badly with the open modal (see TECHNICAL_DEBT.md).
+        // Render once with no duration meta and freeze. Replace this
+        // 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 = 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) => renderOperation(
+              buildToolOperation({ id: ctx.id, tag, arg: input, attrs: ctx.attrs, status: 'pending', durationMs: elapsedMs }),
+              { mode: 'ansi', phase: 'pending' },
+            ));
+          }
+        }
+      },
+      onToolEnd: (tag, result, durationMs, ctx) => {
+        const hasError = !!(ctx && ctx.error);
+        // Web-activity collapse (Task W.3): record this web op into the running
+        // summary instead of committing a per-op line. The summary reflects the
+        // 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 serializeWebOp(ctx, tag, durationMs);
+        }
+        const isBlocking = tag === 'ask_user';
+        // 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 {
+          // No invocation id means the agent-loop wasn't upgraded to pass
+          // structured context (shouldn't happen in practice). Fall back
+          // 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
+          // line above (written by endActivity) isn't duplicated.
+          const body = typeof result === 'string' && result.trim() ? result : null;
+          if (body) {
+            chatHistory.addMessage({ role: 'tool', tag, content: '', output: body, isError: true });
+          }
+          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) {
+          // 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;
+          }
+        }
+        // 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;
+        chatHistory.streamToken(token);
+        statusBar.onToken();
+      },
+      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 = '';
+        }
+        // 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());
+        // 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).
+        //
+        // Guard on the TERMINAL signal (no tool calls this iteration). Intermediate
+        // web-tool iterations are non-terminal — they keep the group open so a
+        // multi-step search→fetch still collapses into a single line (the W.3
+        // guarantee). Pre-live-narration this used "cleanContent is empty" as the
+        // proxy for intermediate; now intermediate iterations carry narration too,
+        // so we rely on the explicit `terminal` flag instead — otherwise an
+        // intermediate narration would flush the group early and split the line.
+        // Empty/interrupted turns (no terminal message ever arrives) fall back to
+        // the turn-end `finally` flush, which is the safety net.
+        if (terminal && webTracker.isOpen()) {
+          webTracker.flush();
+        }
+        // Same terminal-gating for the file group: only the explicit terminal
+        // signal flushes, so intermediate-iteration narration does NOT split a
+        // multi-iteration read run — it still collapses to one summary.
+        if (terminal && fileTracker.isOpen()) {
+          fileTracker.flush();
+        }
+        chatHistory.finalizeLastMessage(cleanContent);
+      },
+      onMetricsUpdate: (data) => statusBar.updateMetrics(data),
+      onRetry: (attempt, max) => {
+        statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
+      },
+      onDebug: (block) => {
+        // 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) => {
+        if (err && err.isWarning) {
+          chatHistory.addMessage({ role: 'system', content: err.message || String(err) });
+        } else {
+          const msg = (err && err.message) || String(err);
+          statusBar.update('error', msg);
+          chatHistory.addMessage({ role: 'system', content: `✗ ${msg}`, isError: true });
+        }
+      },
+      onPlanWithhold: (tag, arg) => {
+        chatHistory.addMessage({ role: 'system', content: `⏸ Planned (withheld): ${tag}${arg ? ' ' + arg : ''}` });
+      },
+    };
+
+    let _agentAborted = false;
+    const _onAbort = () => {
+      if (!_agentAborted) {
+        _agentAborted = true;
+        chatHistory.addMessage({ role: 'system', content: '⏹ Interrupted.' });
+      }
+    };
+    inputField.on('abort', _onAbort);
+
+    // Refresh in case a prior turn's 400 overflow persisted a learned
+    // context_length to config after this chat started.
+    if (ctx.resolvedTokenLimit == null) {
+      const cfg = getConfig();
+      if (Number.isInteger(cfg.context_length) && cfg.context_length > 0) {
+        ctx.resolvedTokenLimit = cfg.context_length;
+      }
+    }
+
+    // Auto-compaction near the context limit (Task 2.7): summarize older turns
+    // before the request so they survive as a summary rather than being dropped
+    // by api.js trimToTokenBudget. Best-effort; never blocks the turn.
+    try {
+      const { shouldAutoCompact, selectForCompaction, summarizationRequest, buildCompactedMessages, approxTokens: approxTok } = require('../compact');
+      const lim = ctx.resolvedTokenLimit;
+      const used = approxTok(ctx.messages, approxTokens);
+      if (shouldAutoCompact(used, lim, ctx.messages.length)) {
+        const sel = selectForCompaction(ctx.messages, { keepRecent: 6 });
+        if (sel.head.length) {
+          // PreCompact hook (Task 3.4): fire before summarizing. Best-effort.
+          try {
+            await require('../hooks').createHookRunner({ getConfig })
+              .run('PreCompact', { reason: 'auto', messageCount: ctx.messages.length });
+          } catch { /* hook failures never block compaction */ }
+          const summary = await ctx.chatSync(summarizationRequest(sel.head), { model: ctx.currentModel });
+          if (summary && summary.trim()) {
+            ctx.messages = buildCompactedMessages(sel, summary);
+            const after = approxTok(ctx.messages, approxTokens);
+            chatHistory.addMessage({ role: 'system', content: `✓ Auto-compacted near context limit: ~${used} → ~${after} tokens.` });
+          }
+        }
+      }
+    } catch { /* auto-compaction is best-effort */ }
+
+    try {
+      const agentResult = await runAgentLoop(ctx.messages, ctx.currentModel, resolveMaxIterations(getConfig().max_iterations), ctx.resolvedTokenLimit, {
+        showThink: opts.showThink || false,
+        debug: ctx.debugMode,
+        callbacks,
+        systemPrompt: ctx.resolvedSystemPrompt,
+        systemPromptMode: getConfig().system_prompt_mode || 'system_role',
+        getAbortFlag: () => _agentAborted,
+        getPlanMode: () => ctx.planMode,
+        noVerify: !!opts.noVerify,
+      });
+      ctx.messages = agentResult.messages;
+      ctx.sessionMetrics = agentResult.metrics;
+
+      // Cost indicator (Task 2.6): accumulate this turn's usage and render the
+      // session cost. Unknown model price → "unknown", never a fake $0.
+      try {
+        const cfg = getConfig();
+        if (cfg.show_cost && agentResult.metrics && Array.isArray(agentResult.metrics.turns)) {
+          for (const t of agentResult.metrics.turns) {
+            sessionUsage.prompt_tokens += t.promptTokens || 0;
+            sessionUsage.completion_tokens += t.completionTokens || 0;
+          }
+          const { priceForModel, computeCost, formatCost } = require('../pricing');
+          const cost = computeCost(sessionUsage, priceForModel(ctx.currentModel, cfg.pricing));
+          if (typeof statusBar.setCost === 'function') statusBar.setCost(formatCost(cost));
+        }
+      } catch { /* cost display is best-effort */ }
+
+      if (ctx.planMode && agentResult.withheldActions && agentResult.withheldActions.length) {
+        chatHistory.addMessage({
+          role: 'system',
+          content: `Plan ready — ${agentResult.withheldActions.length} action(s) withheld. Run /plan to approve and execute, or /clear to discard.`,
+        });
+      }
+    } catch (err) {
+      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);
+    }
+
+    statusBar.update('idle');
+    inputField.setDisabled(false);
+    await saveTurnToDashboard();
+    saveSession();
+  };
+}
+
+module.exports = { createTurnHandler };