@semalt-ai/code 1.8.3 → 1.8.5

package/lib/commands.js

@@ -3,11 +3,72 @@
 const fs = require('fs');
 
 const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS, TAG_REGISTRY } = require('./constants');
-const { configShow } = require('./config');
+const { configShow, isNativeToolsActive } = require('./config');
 const { getSystemPrompt } = require('./prompts');
 const { SessionStorage } = require('./storage');
 const { getSkippedOps, setUIActive } = require('./tools');
 const { AUDIT_LOG } = require('./audit');
+const { formatToolLine } = require('./ui/format');
+const writerModule = require('./ui/writer');
+const writer = writerModule;
+const msgs = require('./ui/messages');
+const dbg = require('./debug');
+
+// Drop assistant.tool_calls and role:tool messages whose ids don't pair up.
+// A loaded chat may contain role:tool with empty/missing tool_call_id (legacy
+// rows, dropped fields in transit) or assistant.tool_calls without a matching
+// tool response (truncated turn). Either side without its partner produces a
+// 400 from strict providers like MiniMax — the validator in api.js will throw
+// — so we strip both sides of the orphan pair before sending.
+function cleanOrphanedToolMessages(msgs) {
+  const calledIds = new Set();
+  const respondedIds = new Set();
+  for (const m of msgs) {
+    if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
+      for (const tc of m.tool_calls) {
+        if (tc && tc.id) calledIds.add(tc.id);
+      }
+    } else if (m.role === 'tool' && m.tool_call_id) {
+      respondedIds.add(m.tool_call_id);
+    }
+  }
+  const paired = new Set();
+  for (const id of calledIds) if (respondedIds.has(id)) paired.add(id);
+
+  let droppedTool = 0;
+  let droppedAssistantCalls = 0;
+  let droppedAssistantMsgs = 0;
+  const out = [];
+  for (const m of msgs) {
+    if (m.role === 'tool') {
+      if (!m.tool_call_id || !paired.has(m.tool_call_id)) { droppedTool++; continue; }
+      out.push(m);
+    } else if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
+      const kept = m.tool_calls.filter((tc) => tc && tc.id && paired.has(tc.id));
+      droppedAssistantCalls += m.tool_calls.length - kept.length;
+      const hasContent = typeof m.content === 'string' && m.content.trim().length > 0;
+      if (kept.length === 0 && !hasContent) { droppedAssistantMsgs++; continue; }
+      const next = { ...m };
+      if (kept.length > 0) next.tool_calls = kept;
+      else delete next.tool_calls;
+      out.push(next);
+    } else {
+      out.push(m);
+    }
+  }
+  return { messages: out, droppedTool, droppedAssistantCalls, droppedAssistantMsgs };
+}
+
+function reconstructLoadedMessage(m) {
+  const msg = { role: m.role, content: m.content };
+  if (m.tool_call_id !== undefined && m.tool_call_id !== null && m.tool_call_id !== '') {
+    msg.tool_call_id = m.tool_call_id;
+  }
+  if (Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+    msg.tool_calls = m.tool_calls;
+  }
+  return msg;
+}
 
 function formatTimeAgo(ts) {
   const diffMs = Date.now() - ts;
@@ -41,9 +102,8 @@ function createCommands({
     FG_TEAL,
     FG_YELLOW,
     RST,
-    StatusBar,
+    approxTokens,
     getCols,
-    hr,
     boxLine,
     interactiveSelect,
     createUI,
@@ -100,29 +160,54 @@ function createCommands({
     return null;
   }
 
-  function printBanner() {
-    const w = Math.min(getCols() - 4, 60);
-    console.log();
-    console.log(`  ${FG_DARK}╭${'─'.repeat(w + 1)}╮${RST}`);
-    console.log(boxLine('', w));
-    console.log(boxLine(`${FG_TEAL}${BOLD}◆ Semalt.AI${RST}`, w));
-    console.log(boxLine(`${FG_GRAY}Self-hosted AI coding assistant${RST}`, w));
-    console.log(boxLine('', w));
-    console.log(`  ${FG_DARK}╰${'─'.repeat(w + 1)}╯${RST}`);
-    console.log();
+  // Pick the first dashboard model when the user is authenticated but has
+  // not selected one yet. Persists credentials to config and returns
+  // { name, modelId } on success; null otherwise (not logged in, already
+  // selected, empty list, or API error).
+  async function ensureDefaultModel() {
+    const config = getConfig();
+    if (!config.auth_token) return null;
+    if (config.default_model && config.dashboard_model_id) return null;
+    let response;
+    try { response = await dashboardListModels(); } catch { return null; }
+    const models = Array.isArray(response && response.models) ? response.models : [];
+    if (!models.length) return null;
+    const first = models[0];
+    let credResp;
+    try { credResp = await dashboardGetModelForCli(first.id); } catch { return null; }
+    const model = credResp && credResp.model ? credResp.model : null;
+    if (!model) return null;
+    const contextLength = (Number.isInteger(model.context_length) && model.context_length > 0 ? model.context_length : null)
+      || (Number.isInteger(model.max_tokens) && model.max_tokens > 0 ? model.max_tokens : null);
+    const updated = { ...config, api_base: model.base_url, api_key: model.api_key, default_model: model.model_id, dashboard_model_id: model.id };
+    if (contextLength !== null) updated.context_length = contextLength;
+    setConfig(updated);
+    return { name: model.name, modelId: model.model_id };
   }
 
   async function cmdChat(opts) {
+    await ensureDefaultModel();
+
+    // Build the three end-of-session artifacts that teardown emits as
+    // scrollback. Returning them as a plain object lets both exit paths
+    // (/exit submit and Ctrl+C onInterrupt) route through writer.teardown,
+    // which is the only place that can append them below the erased live
+    // region in a single atomic write.
+    function buildExitArtifacts() {
+      return {
+        summary: sessionMetrics ? sessionMetrics.summary() : '',
+        resumeHint: currentChatId !== null
+          ? `  ${FG_DARK}Resume this chat: ${FG_CYAN}semalt-code --resume ${currentChatId}${RST}`
+          : '',
+        goodbye: `  ${FG_GRAY}Goodbye!${RST}`,
+      };
+    }
+
     const { chatHistory, statusBar, inputField, layout, destroy, redrawFixed } = createUI({
       showThink: opts.showThink || false,
       onInterrupt: (destroyFn) => {
         saveSession();
-        destroyFn();
-        if (sessionMetrics) console.log('\n' + sessionMetrics.summary());
-        if (currentChatId !== null) {
-          console.log(`  ${FG_DARK}Resume this chat: ${FG_CYAN}semalt-code --resume ${currentChatId}${RST}`);
-        }
-        console.log(`\n  ${FG_GRAY}Goodbye!${RST}\n`);
+        destroyFn(buildExitArtifacts());
         process.exit(0);
       },
     });
@@ -157,12 +242,20 @@ function createCommands({
     let currentModel = opts.model || getConfig().default_model;
     let resolvedTokenLimit = await resolveTokenLimit(currentModel);
     statusBar.setModel(currentModel);
+    // Seed the context indicator with the profile's limit up-front so it
+    // renders "0 / 200,000 tok (0%)" before the first API response, instead
+    // of appearing out of thin air once a turn completes.
+    statusBar.setContextLimit(resolvedTokenLimit);
     let sessionMetrics = null;
     // system prompt is prepended fresh on every API call in agent.js — never stored in history
     let messages = [];
     let currentChatId = null;
     let savedUpTo = 0;
-    let debugMode = !!opts.debug;
+    // The agent loop's per-iteration `formatDebugBlock` runs whenever any
+    // debug mode is active. In simple mode the block is rendered as a TUI
+    // chat bubble (cb.onDebug → addMessage). In file mode emitDebug routes
+    // the block to the debug file instead, keeping the TUI clean.
+    let debugMode = dbg.isActive();
 
     // Resolve system prompt override from --system-prompt file if provided
     let resolvedSystemPrompt = null;
@@ -252,7 +345,15 @@ function createCommands({
       if (currentChatId === null) return;
       const newMessages = messages.slice(savedUpTo).filter((m) => m.role !== 'system');
       if (!newMessages.length) return;
-      try { await dashboardSaveMessages(currentChatId, newMessages); savedUpTo = messages.length; } catch {}
+      try {
+        const resp = await dashboardSaveMessages(currentChatId, newMessages);
+        savedUpTo = messages.length;
+        if (resp && typeof resp.skipped_count === 'number' && resp.skipped_count > 0) {
+          msgs.sysWarn(`history save: ${resp.skipped_count} message(s) skipped by server`);
+        }
+      } catch (err) {
+        msgs.sysWarn(`history save failed: ${err && err.message ? err.message : String(err)}`);
+      }
     }
 
     function displayLoadedMessages(loadedMessages) {
@@ -263,7 +364,7 @@ function createCommands({
         const ts = m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date());
 
         if (m.role === 'tool') {
-          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: 'tool result', output: raw, ts });
+          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: raw, ts });
           continue;
         }
 
@@ -272,7 +373,7 @@ function createCommands({
             .replace(/^Tool execution results[^\n]*\n+/, '')
             .replace(/\n+Continue with the task\.[\s\S]*$/, '')
             .trim();
-          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: 'tool result', output: body || raw, ts });
+          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: body || raw, ts });
           continue;
         }
 
@@ -281,6 +382,34 @@ function createCommands({
       }
     }
 
+    // After loading a saved chat (via --resume, /history, or /chats), the
+    // status bar has no API-reported prompt_tokens to display until the next
+    // turn completes — the indicator would sit at 0 until the user sends a
+    // follow-up. Seed it with a client-side estimate of the loaded messages
+    // using the same approxTokens estimator the live `addPendingTokens` path
+    // uses, then push it through `updateMetrics({contextTokens})` — the same
+    // setter agent.js wires up via cb.onMetricsUpdate. The next real turn
+    // overwrites this with the API's authoritative prompt_tokens.
+    function seedContextFromMessages() {
+      let total = 0;
+      for (const m of messages) {
+        if (typeof m.content === 'string') total += approxTokens(m.content);
+      }
+      statusBar.updateMetrics({ contextTokens: total });
+    }
+
+    function emitCleanupWarning(cleanup) {
+      if (cleanup.droppedTool === 0 && cleanup.droppedAssistantCalls === 0 && cleanup.droppedAssistantMsgs === 0) return;
+      const parts = [];
+      if (cleanup.droppedTool > 0) parts.push(`${cleanup.droppedTool} orphaned tool result(s)`);
+      if (cleanup.droppedAssistantCalls > 0) parts.push(`${cleanup.droppedAssistantCalls} dangling tool_call(s)`);
+      if (cleanup.droppedAssistantMsgs > 0) parts.push(`${cleanup.droppedAssistantMsgs} empty assistant message(s)`);
+      chatHistory.addMessage({
+        role: 'system',
+        content: `⚠ Loaded chat had ${parts.join(', ')}, cleaned up. The chat may be missing some context.`,
+      });
+    }
+
     // --resume: load previous chat
     if (opts.resume) {
       const resumeId = parseInt(opts.resume, 10);
@@ -288,22 +417,28 @@ function createCommands({
         try {
           const chatData = await dashboardGetChat(resumeId);
           const loaded = chatData && chatData.messages ? chatData.messages : [];
-          for (const m of loaded) messages.push({ role: m.role, content: m.content });
+          for (const m of loaded) messages.push(reconstructLoadedMessage(m));
+          const cleanup = cleanOrphanedToolMessages(messages);
+          messages = cleanup.messages;
           currentChatId = resumeId;
           savedUpTo = messages.length;
           const title = chatData.chat && chatData.chat.title ? chatData.chat.title : `#${resumeId}`;
           displayLoadedMessages(loaded);
           chatHistory.addMessage({ role: 'system', content: `✓ Resumed: ${title} (${loaded.length} messages)` });
+          emitCleanupWarning(cleanup);
+          seedContextFromMessages();
         } catch (error) {
           chatHistory.addMessage({ role: 'system', content: `✗ Could not resume chat: ${error.message}`, isError: true });
         }
       }
     }
 
-    // Pending selection state (for in-chat /history, /models, /chats)
+    // Pending selection state (for in-chat /history, /models, /chats).
+    // The picker renders into the writer's modal region — same band as the
+    // permission picker — so navigation redraws in place and only the final
+    // selection (or cancellation) leaves a line in scrollback.
     let pendingAction = null;
     const PAGE_SIZE = 5;
-    let listMsg = null;
 
     function getNavSearchText(type, item) {
       if (type === 'history') {
@@ -361,31 +496,27 @@ function createCommands({
       return parts.join('\n');
     }
 
-    function collapseListMsg(type, item) {
-      if (!listMsg) return;
-      const titleMap = { history: 'Sessions', chats: 'Chats', models: 'Models' };
-      listMsg.content = `${titleMap[type] || type}  ·  ${buildItemDetail(type, item)}`;
-      chatHistory.collapseById(listMsg.id);
-      listMsg = null;
+    function collapseListMsg(_type, _item) {
+      // Modal is transient — clearing it removes the picker from view; the
+      // selection's success line is emitted to scrollback by
+      // handlePendingSelection.
+      writer.clearModal();
     }
 
     function showPendingStep() {
       if (!pendingAction) return;
-      const content = buildListContent();
-      if (!listMsg) {
-        listMsg = { role: 'system', content, id: `list-${Date.now()}` };
-        chatHistory.addMessage(listMsg);
-      } else {
-        listMsg.content = content;
-        chatHistory.rerenderById(listMsg.id);
-      }
+      const lines = buildListContent().split('\n');
+      // Match the system-message bubble look so the modal reads as part of
+      // the same chat block: muted bullet on the title row, indented
+      // continuations underneath.
+      const modalLines = lines.length > 0
+        ? [`  ${FG_GRAY}●${RST} ${FG_GRAY}${lines[0]}${RST}`].concat(lines.slice(1).map((l) => `    ${l}`))
+        : [];
+      writer.setModal(modalLines);
     }
 
     function finalizeListMsg() {
-      if (listMsg) {
-        chatHistory.removeById(listMsg.id);
-        listMsg = null;
-      }
+      writer.clearModal();
     }
 
     function activateNavCapture() {
@@ -440,26 +571,35 @@ function createCommands({
       if (type === 'history') {
         const loaded = storage.load(activeItems[idx].id);
         if (loaded) {
-          messages = (loaded.messages || []).filter((m) => m.role !== 'system');
+          const filtered = (loaded.messages || []).filter((m) => m.role !== 'system');
+          const cleanup = cleanOrphanedToolMessages(filtered);
+          messages = cleanup.messages;
           session = { id: loaded.id, created_at: loaded.created_at, model: loaded.model, messages, stats: loaded.stats || { total_tokens: 0, duration_sec: 0 } };
           currentChatId = null; savedUpTo = 0;
           if (loaded.model && loaded.model !== currentModel) {
             currentModel = loaded.model;
             resolvedTokenLimit = await resolveTokenLimit(currentModel);
             statusBar.setModel(currentModel);
+            statusBar.setContextLimit(resolvedTokenLimit);
           }
           displayLoadedMessages(messages);
           chatHistory.addMessage({ role: 'system', content: `✓ Session loaded.  Model → ${currentModel}` });
+          emitCleanupWarning(cleanup);
+          seedContextFromMessages();
         }
       } else if (type === 'chats') {
         const selectedChat = activeItems[idx];
         try {
           const chatData = await dashboardGetChat(selectedChat.id);
           const loaded = chatData && chatData.messages ? chatData.messages : [];
-          messages = loaded.map((m) => ({ role: m.role, content: m.content }));
+          const reconstructed = loaded.map(reconstructLoadedMessage);
+          const cleanup = cleanOrphanedToolMessages(reconstructed);
+          messages = cleanup.messages;
           currentChatId = selectedChat.id; savedUpTo = messages.length;
           displayLoadedMessages(loaded);
           chatHistory.addMessage({ role: 'system', content: `✓ Resumed: ${selectedChat.title} (${loaded.length} messages)` });
+          emitCleanupWarning(cleanup);
+          seedContextFromMessages();
         } catch (err) {
           chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
         }
@@ -478,6 +618,7 @@ function createCommands({
           currentModel = model.model_id;
           resolvedTokenLimit = await resolveTokenLimit(currentModel);
           statusBar.setModel(currentModel);
+          statusBar.setContextLimit(resolvedTokenLimit);
           currentChatId = null;
           chatHistory.addMessage({ role: 'system', content: `✓ Model → ${model.name} (${model.model_id})` });
           statusBar.update('idle');
@@ -535,7 +676,7 @@ function createCommands({
       // Exit
       if (['exit', 'quit', '/exit', '/quit'].includes(text.toLowerCase())) {
         saveSession();
-        destroy();
+        destroy(buildExitArtifacts());
         resolveExit();
         return;
       }
@@ -569,6 +710,7 @@ function createCommands({
       }
 
       if (text === '/history') {
+        if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
         const sessions = storage.list();
         if (!sessions.length) { chatHistory.addMessage({ role: 'system', content: 'No saved sessions.' }); return; }
         refreshInputSearchItems();
@@ -617,6 +759,14 @@ function createCommands({
         inputField.setDisabled(true);
         statusBar.update('thinking', 'Starting login...');
         await _loginFlow(chatHistory, statusBar);
+        const picked = await ensureDefaultModel();
+        if (picked) {
+          currentModel = picked.modelId;
+          resolvedTokenLimit = await resolveTokenLimit(currentModel);
+          statusBar.setModel(currentModel);
+          statusBar.setContextLimit(resolvedTokenLimit);
+          chatHistory.addMessage({ role: 'system', content: `✓ Model → ${picked.name} (${picked.modelId})` });
+        }
         statusBar.update('idle');
         inputField.setDisabled(false);
         return;
@@ -666,6 +816,7 @@ function createCommands({
       }
 
       if (text === '/models') {
+        if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
         inputField.setDisabled(true);
         statusBar.update('thinking', 'Loading models...');
         try {
@@ -688,14 +839,17 @@ function createCommands({
       }
 
       if (text === '/model') {
+        if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
         chatHistory.addMessage({ role: 'system', content: `Current model: ${currentModel}` });
         return;
       }
 
       if (text.startsWith('/model ')) {
+        if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
         currentModel = text.slice(7).trim();
         resolvedTokenLimit = await resolveTokenLimit(currentModel);
         statusBar.setModel(currentModel);
+        statusBar.setContextLimit(resolvedTokenLimit);
         chatHistory.addMessage({ role: 'system', content: `✓ Model → ${currentModel}` });
         return;
       }
@@ -722,7 +876,8 @@ function createCommands({
       }
 
       if (text === '/prompt') {
-        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : getSystemPrompt();
+        const nativeTools = isNativeToolsActive(currentModel);
+        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : getSystemPrompt(nativeTools);
         const src = resolvedSystemPrompt !== null ? `file: ${opts.systemPromptFile}` : 'built-in';
         const mode = getConfig().system_prompt_mode || 'system_role';
         chatHistory.addMessage({
@@ -765,9 +920,12 @@ function createCommands({
           tail = '\nNo audit log found.';
         }
 
+        const sink = dbg.isFile()
+          ? `file (${dbg.getMode()} mode)`
+          : 'inline chat history';
         chatHistory.addMessage({
           role: 'system',
-          content: `Debug output: ${debugMode ? 'ON' : 'OFF'} (raw messages, raw AI responses, raw HTTP errors → stderr)${tail}`,
+          content: `Debug output: ${debugMode ? 'ON' : 'OFF'} → ${sink}${tail}`,
         });
         return;
       }
@@ -803,6 +961,11 @@ function createCommands({
       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);
       messages.push({ role: 'user', content: text });
 
@@ -845,9 +1008,14 @@ function createCommands({
           chatHistory.addMessage({ role: 'think', content });
           statusBar.update('streaming', 'Streaming response');
         },
-        onToolStart: (tag, input, attrs) => {
+        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;
-          const short = input.length > 40 ? input.slice(0, 40) + '…' : input;
+          const short = input && input.length > 40 ? input.slice(0, 40) + '…' : (input || '');
           const isDownload = tag === 'download' || tag === 'http_get';
           if (isDownload) {
             statusBar.update('waiting_download', `Waiting for download: ${short}`);
@@ -855,19 +1023,79 @@ function createCommands({
             statusBar.update('tool', `${actionLabel}: ${short}`);
           }
         },
-        onToolEnd: (tag, result, durationMs) => {
-          const isError = typeof result === 'string' && result.startsWith('Error');
-          if (isError) {
-            chatHistory.addMessage({
-              role: 'tool',
-              tag,
-              content: `${tag} ✕ [${durationMs}ms]`,
-              output: typeof result === 'string' && result.trim() ? result : null,
-            });
-            statusBar.update('streaming', 'Streaming response');
+        onToolStart: (tag, input, ctx) => {
+          const actionLabel = TAG_REGISTRY[tag]?.label || tag;
+          const short = input && input.length > 40 ? input.slice(0, 40) + '…' : (input || '');
+          const isDownload = tag === 'download' || tag === 'http_get';
+          if (isDownload) {
+            statusBar.update('waiting_download', `Waiting for download: ${short}`);
           } else {
-            const actionLabel = TAG_REGISTRY[tag]?.label || tag;
-            statusBar.update('tool', `✓ ${actionLabel} [${durationMs}ms]`);
+            statusBar.update('tool', `${actionLabel}: ${short}`);
+          }
+          // 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) {
+            if (tag === 'ask_user') {
+              const staticLine = formatToolLine({
+                status: 'pending',
+                tag,
+                arg: input,
+                attrs: ctx.attrs,
+                noDuration: true,
+              });
+              writerModule.startActivity(ctx.id, () => staticLine);
+            } else {
+              writerModule.startActivity(ctx.id, (elapsedMs) => formatToolLine({
+                status: 'pending',
+                tag,
+                arg: input,
+                attrs: ctx.attrs,
+                durationMs: elapsedMs,
+              }));
+            }
+          }
+        },
+        onToolEnd: (tag, result, durationMs, ctx) => {
+          const hasError = !!(ctx && ctx.error);
+          const isBlocking = tag === 'ask_user';
+          const finalLine = formatToolLine({
+            status: hasError ? 'failure' : 'success',
+            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,
+            durationMs,
+            meta: ctx ? ctx.meta : null,
+            error: ctx ? ctx.error : null,
+            noDuration: isBlocking,
+          });
+          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);
+          }
+          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');
           }
         },
         onToken: (token) => {
@@ -958,18 +1186,13 @@ function createCommands({
       saveSession();
     });
 
-    // Wait until user exits
+    // Wait until user exits. The /exit submit handler already ran
+    // destroy(buildExitArtifacts()), so the session summary, resume hint,
+    // and goodbye have been emitted as scrollback inside teardown's
+    // single atomic write. Nothing more to print here.
     await exitPromise;
     setUIActive(false);
     saveSession();
-    if (sessionMetrics) {
-      // Show summary in terminal after destroy
-      console.log('\n' + sessionMetrics.summary());
-    }
-    if (currentChatId !== null) {
-      console.log(`  ${FG_DARK}Resume this chat: ${FG_CYAN}semalt-code --resume ${currentChatId}${RST}`);
-    }
-    console.log(`\n  ${FG_GRAY}Goodbye!${RST}\n`);
   }
 
   async function _loginFlow(chatHistory, statusBar) {
@@ -1005,8 +1228,9 @@ function createCommands({
   }
 
   async function cmdCode(opts, promptArgs) {
-    if (!promptArgs.length) { console.log(`  ${FG_RED}Usage: semalt-code code <prompt>${RST}`); return; }
-    if (!getConfig().auth_token) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt-code login first.${RST}\n`); return; }
+    if (!promptArgs.length) { writer.scrollback(`  ${FG_RED}Usage: semalt-code code <prompt>${RST}`); return; }
+    if (!getConfig().auth_token) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt-code login first.${RST}\n`); return; }
+    await ensureDefaultModel();
     const model = opts.model || getConfig().default_model;
     const userPrompt = promptArgs.join(' ');
     const context = opts.file ? readFileContext(opts.file) : '';
@@ -1016,62 +1240,60 @@ function createCommands({
       try { resolvedSystemPrompt = fs.readFileSync(opts.systemPromptFile, 'utf8'); } catch {}
     }
     let messages = [{ role: 'user', content: fullPrompt }];
-    const statusBar = new StatusBar();
-    statusBar.update({ model, status: 'thinking' });
+    writer.scrollback(`  ${FG_GRAY}◆ ${model}${RST}`);
     const codeResult = await runAgentLoop(messages, model, undefined, null, {
-      debug: opts.debug || false,
+      debug: dbg.isActive(),
       systemPrompt: resolvedSystemPrompt,
       systemPromptMode: getConfig().system_prompt_mode || 'system_role',
     });
     messages = codeResult.messages;
-    statusBar.destroy();
-    console.log();
-    if (codeResult.metrics) console.log(codeResult.metrics.summary());
+    writer.scrollback('\n');
+    if (codeResult.metrics) writer.scrollback(codeResult.metrics.summary());
     if (opts.dryRun) printDryRunSummary();
   }
 
   async function cmdEdit(opts, filePath, instructionArgs) {
-    if (!filePath) { console.log(`  ${FG_RED}Usage: semalt-code edit <file> <instruction>${RST}`); return; }
-    if (!getConfig().auth_token) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt-code login first.${RST}\n`); return; }
-    if (!fs.existsSync(filePath)) { console.log(`  ${FG_RED}✗ File not found: ${filePath}${RST}`); return; }
+    if (!filePath) { writer.scrollback(`  ${FG_RED}Usage: semalt-code edit <file> <instruction>${RST}`); return; }
+    if (!getConfig().auth_token) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt-code login first.${RST}\n`); return; }
+    if (!fs.existsSync(filePath)) { writer.scrollback(`  ${FG_RED}✗ File not found: ${filePath}${RST}`); return; }
+    await ensureDefaultModel();
     const content = fs.readFileSync(filePath, 'utf8');
     const instruction = instructionArgs.join(' ');
     const messages = [
       { role: 'system', content: 'You are Semalt.AI. Output ONLY the modified file. No explanations, no fences.' },
       { role: 'user', content: `File: ${filePath}\n\n\`\`\`\n${content}\n\`\`\`\n\nInstruction: ${instruction}` },
     ];
-    console.log(`  ${FG_GRAY}Editing ${filePath}...${RST}`);
-    const editStatusBar = new StatusBar();
-    editStatusBar.update({ model: opts.model || getConfig().default_model, status: 'editing' });
+    writer.scrollback(`  ${FG_GRAY}Editing ${filePath}...${RST}`);
     let result = await chatSync(messages, { model: opts.model });
-    editStatusBar.destroy();
     if (result && !opts.dryRun) {
       if (result.startsWith('```')) { const lines = result.split('\n'); result = lines.at(-1).trim() === '```' ? lines.slice(1, -1).join('\n') : lines.slice(1).join('\n'); }
       fs.writeFileSync(filePath, result);
-      console.log(`  ${FG_GREEN}✓ Saved: ${filePath}${RST}`);
+      writer.scrollback(`  ${FG_GREEN}✓ Saved: ${filePath}${RST}`);
     } else if (opts.dryRun) {
-      console.log(`  ${FG_YELLOW}⚠ Dry run — not modified${RST}`);
+      writer.scrollback(`  ${FG_YELLOW}⚠ Dry run — not modified${RST}`);
     }
   }
 
   async function cmdShell(opts, commandArgs) {
     const command = commandArgs.join(' ');
-    if (!command) { console.log(`  ${FG_RED}Usage: semalt-code shell <command>${RST}`); return; }
+    if (!command) { writer.scrollback(`  ${FG_RED}Usage: semalt-code shell <command>${RST}`); return; }
     const result = await agentExecShell(command);
     if (opts.analyze) {
-      if (!getConfig().auth_token) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt-code login first.${RST}\n`); return; }
+      if (!getConfig().auth_token) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt-code login first.${RST}\n`); return; }
+      await ensureDefaultModel();
       const messages = [
         { role: 'system', content: 'You are Semalt.AI. Analyze the command output concisely.' },
         { role: 'user', content: `Command: ${command}\nExit: ${result.exit_code}\nStdout:\n${result.stdout}\nStderr:\n${result.stderr}` },
       ];
-      console.log(); console.log(`  ${FG_TEAL}${BOLD}◆ Semalt.AI${RST}`); console.log();
+      writer.scrollback(`\n  ${FG_TEAL}${BOLD}◆ Semalt.AI${RST}\n`);
+      // audit: allowed — non-TUI streaming prefix, must precede StreamRenderer sync writes.
       process.stdout.write('  ');
       try {
         await chatStream(messages, { model: opts.model });
       } catch (err) {
-        console.log(`\n  ${FG_RED}✗ ${err.message}${RST}`);
+        msgs.netError(err.message);
       }
-      console.log();
+      writer.scrollback('\n');
     }
   }
 
@@ -1079,10 +1301,10 @@ function createCommands({
     const config = getConfig();
     let response;
     try { response = await dashboardListModels(); }
-    catch (err) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
+    catch (err) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
     const models = Array.isArray(response && response.models) ? response.models : [];
-    if (!models.length) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}No models available.${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
-    console.log(); console.log(`  ${FG_TEAL}${BOLD}◆ Your Models${RST}`); console.log(`  ${FG_DARK}${'─'.repeat(60)}${RST}`);
+    if (!models.length) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}No models available.${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
+    writer.scrollback(`\n  ${FG_TEAL}${BOLD}◆ Your Models${RST}\n  ${FG_DARK}${'─'.repeat(60)}${RST}`);
     const activeIndex = models.findIndex((m) => m.base_url === config.api_base && m.model_id === config.default_model);
     const selectedIndex = await interactiveSelect(models, (model, isSelected, isFinal) => {
       const active = model.base_url === config.api_base && model.model_id === config.default_model;
@@ -1091,18 +1313,18 @@ function createCommands({
       const nameStyle = isSelected && !isFinal ? `${BG_SELECTED}${FG_CYAN}` : (isSelected ? FG_CYAN : FG_GRAY);
       return `  ${marker} ${cursor} ${nameStyle}${model.name} · ${model.model_id} @ ${model.base_url}${RST}`;
     }, { initialIndex: Math.max(0, activeIndex) });
-    if (selectedIndex === null) { console.log(`  ${FG_DARK}Cancelled${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
+    if (selectedIndex === null) { writer.scrollback(`  ${FG_DARK}Cancelled${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
     const selectedModel = models[selectedIndex];
     let credentialsResponse;
     try { credentialsResponse = await dashboardGetModelForCli(selectedModel.id); }
-    catch (err) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
+    catch (err) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
     const model = credentialsResponse && credentialsResponse.model ? credentialsResponse.model : null;
-    if (!model) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load selected model.${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
+    if (!model) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load selected model.${RST}\n`); return { model: config.default_model, dbId: config.dashboard_model_id }; }
     const contextLength = (Number.isInteger(model.context_length) && model.context_length > 0 ? model.context_length : null) || (Number.isInteger(model.max_tokens) && model.max_tokens > 0 ? model.max_tokens : null);
     const updatedConfig = { ...config, api_base: model.base_url, api_key: model.api_key, default_model: model.model_id, dashboard_model_id: model.id };
     if (contextLength !== null) updatedConfig.context_length = contextLength;
     setConfig(updatedConfig);
-    console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Current model → ${model.name} (${model.model_id})${RST}\n`);
+    writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Current model → ${model.name} (${model.model_id})${RST}\n`);
     return { model: model.model_id, dbId: model.id };
   }
 
@@ -1113,55 +1335,59 @@ function createCommands({
       api_key: opts.apiKey || 'any',
       dashboard_url: opts.dashboardUrl || current.dashboard_url,
       auth_token: current.auth_token || '',
-      default_model: opts.defaultModel || 'default',
+      default_model: opts.defaultModel || '',
       temperature: 0.7,
       request_timeout_ms: DEFAULT_API_TIMEOUT_MS,
       stream: true,
       models: current.models,
     };
     setConfig(cfg);
-    console.log(`\n  ${FG_GREEN}✓${RST} Config saved to ${CONFIG_PATH}`);
-    console.log(`  ${FG_GRAY}${JSON.stringify(cfg, null, 2)}${RST}\n`);
+    writer.scrollback(`\n  ${FG_GREEN}✓${RST} Config saved to ${CONFIG_PATH}\n  ${FG_GRAY}${JSON.stringify(cfg, null, 2)}${RST}\n`);
   }
 
   async function cmdLogin() {
-    console.log(); console.log(`  ${FG_TEAL}${BOLD}◆ CLI Login${RST}`); console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+    writer.scrollback(`\n  ${FG_TEAL}${BOLD}◆ CLI Login${RST}\n  ${FG_DARK}${'─'.repeat(40)}${RST}`);
     let loginRequest;
     try { loginRequest = await requestCliLogin(); }
-    catch (err) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to start login via ${getConfig().dashboard_url}: ${err.message}${RST}\n`); return; }
-    console.log(`  ${FG_GRAY}Open this URL in your browser and confirm the login:${RST}`);
-    console.log(`  ${FG_CYAN}${loginRequest.verification_url}${RST}`);
-    console.log(`  ${FG_DARK}Waiting for confirmation...${RST}`);
+    catch (err) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to start login via ${getConfig().dashboard_url}: ${err.message}${RST}\n`); return; }
+    writer.scrollback(`  ${FG_GRAY}Open this URL in your browser and confirm the login:${RST}\n  ${FG_CYAN}${loginRequest.verification_url}${RST}\n  ${FG_DARK}Waiting for confirmation...${RST}`);
     const startedAt = Date.now();
     while (Date.now() - startedAt < LOGIN_TIMEOUT_MS) {
       await new Promise((r) => setTimeout(r, LOGIN_POLL_INTERVAL_MS));
       let status;
       try { status = await getCliLoginStatus(loginRequest.id, loginRequest.hash); }
-      catch (err) { if (err.statusCode === 404 || err.statusCode === 410) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token is no longer valid.${RST}\n`); return; } continue; }
-      if (status.status === 'authorized') { const config = getConfig(); setConfig({ ...config, dashboard_url: config.dashboard_url, auth_token: loginRequest.token }); console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}CLI token saved to ${CONFIG_PATH}${RST}\n`); return; }
-      if (status.status === 'expired') { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token expired.${RST}\n`); return; }
+      catch (err) { if (err.statusCode === 404 || err.statusCode === 410) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token is no longer valid.${RST}\n`); return; } continue; }
+      if (status.status === 'authorized') { const config = getConfig(); setConfig({ ...config, dashboard_url: config.dashboard_url, auth_token: loginRequest.token }); writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}CLI token saved to ${CONFIG_PATH}${RST}\n`); return; }
+      if (status.status === 'expired') { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Login token expired.${RST}\n`); return; }
     }
-    console.log(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out.${RST}\n`);
+    writer.scrollback(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out.${RST}\n`);
   }
 
   async function cmdWhoAmI() {
     let response;
-    try { response = await dashboardWhoAmI(); } catch (err) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return; }
+    try { response = await dashboardWhoAmI(); } catch (err) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return; }
     const user = response && response.user ? response.user : null;
-    if (!user) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load current user.${RST}\n`); return; }
-    console.log(); console.log(`  ${FG_TEAL}${BOLD}◆ Current User${RST}`); console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
-    console.log(formatUserLine('ID', user.id)); console.log(formatUserLine('Email', user.email || '-'));
-    console.log(formatUserLine('Name', user.name || '-')); console.log(formatUserLine('Provider', user.provider || '-'));
-    if (user.avatar_url) console.log(formatUserLine('Avatar', user.avatar_url));
-    console.log();
+    if (!user) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to load current user.${RST}\n`); return; }
+    const lines = [
+      '',
+      `  ${FG_TEAL}${BOLD}◆ Current User${RST}`,
+      `  ${FG_DARK}${'─'.repeat(40)}${RST}`,
+      formatUserLine('ID', user.id),
+      formatUserLine('Email', user.email || '-'),
+      formatUserLine('Name', user.name || '-'),
+      formatUserLine('Provider', user.provider || '-'),
+    ];
+    if (user.avatar_url) lines.push(formatUserLine('Avatar', user.avatar_url));
+    lines.push('');
+    writer.scrollback(lines.join('\n'));
   }
 
   async function cmdLogout() {
     const config = getConfig();
-    if (!config.auth_token) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in.${RST}\n`); return; }
-    try { await dashboardLogout(); } catch (err) { if (err.statusCode !== 401) { console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return; } }
+    if (!config.auth_token) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in.${RST}\n`); return; }
+    try { await dashboardLogout(); } catch (err) { if (err.statusCode !== 401) { writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}${err.message}${RST}\n`); return; } }
     setConfig({ ...config, auth_token: '' });
-    console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Logged out and cleared local CLI token.${RST}\n`);
+    writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Logged out and cleared local CLI token.${RST}\n`);
   }
 
   function printDryRunSummary() {
@@ -1174,15 +1400,24 @@ function createCommands({
     const stripA = (s) => s.replace(/\x1b\[[^m]*m/g, '');
     const row = (content) => { const visible = stripA(content).length; const pad = ' '.repeat(Math.max(0, INNER - visible)); return isTTY ? `${FG_TEAL}║${RST}${content}${pad}${FG_TEAL}║${RST}` : `║${stripA(content)}${pad}║`; };
     const hr40 = (tl, fill, tr) => { const line = tl + fill.repeat(INNER) + tr; return isTTY ? `${FG_TEAL}${line}${RST}` : line; };
-    console.log(); console.log(hr40('╔','═','╗'));
-    console.log(row(`  ${isTTY ? BOLD : ''}DRY-RUN SUMMARY${isTTY ? RST : ''}`));
-    console.log(hr40('╠','═','╣'));
-    console.log(row(`  ✎  Files that would change:   ${files.length}   `));
-    console.log(row(`  ▶  Commands that would run:   ${cmds.length}   `));
-    console.log(row(`  ↓  Network calls:             ${nets.length}   `));
-    console.log(hr40('╚','═','╝'));
-    if (ops.length > 0) { console.log(); for (const op of ops) { if (isTTY) console.log(`  ${op.symbol}  ${FG_GRAY}${op.desc}${RST}`); else console.log(`  ${op.symbol}  ${op.desc}`); } }
-    console.log();
+    const out = [
+      '',
+      hr40('╔','═','╗'),
+      row(`  ${isTTY ? BOLD : ''}DRY-RUN SUMMARY${isTTY ? RST : ''}`),
+      hr40('╠','═','╣'),
+      row(`  ✎  Files that would change:   ${files.length}   `),
+      row(`  ▶  Commands that would run:   ${cmds.length}   `),
+      row(`  ↓  Network calls:             ${nets.length}   `),
+      hr40('╚','═','╝'),
+    ];
+    if (ops.length > 0) {
+      out.push('');
+      for (const op of ops) {
+        out.push(isTTY ? `  ${op.symbol}  ${FG_GRAY}${op.desc}${RST}` : `  ${op.symbol}  ${op.desc}`);
+      }
+    }
+    out.push('');
+    writer.scrollback(out.join('\n'));
   }
 
   return {