@semalt-ai/code 1.8.3 → 1.8.4

package/index.js

@@ -18,6 +18,7 @@ const { createCommands } = require('./lib/commands');
 const { parseArgs } = require('./lib/args');
 const { CONFIG_PATH } = require('./lib/constants');
 const { AUDIT_LOG } = require('./lib/audit');
+const writer = require('./lib/ui/writer');
 
 // Install process-wide signal handlers so every exit path (normal, SIGINT,
 // SIGHUP, SIGTERM, uncaught exception) restores the terminal. Safe to call
@@ -90,7 +91,7 @@ async function main() {
   const command = rawArgs[0];
 
   if (command === '--help' || command === '-h') {
-    console.log(`
+    writer.scrollback(`
 Semalt.AI — Self-hosted AI Coding Assistant
 
 Usage: semalt-code [command] [options]
@@ -130,11 +131,13 @@ Options:
 
 Config: ${CONFIG_PATH}
 `);
+    await writer.flush();
     return;
   }
 
   if (command === '--version' || command === '-v') {
-    console.log(PACKAGE_JSON.version);
+    writer.scrollback(PACKAGE_JSON.version);
+    await writer.flush();
     return;
   }
 
@@ -170,20 +173,22 @@ Config: ${CONFIG_PATH}
         try {
           const entry = JSON.parse(line);
           const icon = entry.approved ? `${ui.FG_GREEN}✓${ui.RST}` : `${ui.FG_RED}✗${ui.RST}`;
-          console.log(`${icon} ${line}`);
+          writer.scrollback(`${icon} ${line}`);
         } catch {
-          console.log(line);
+          writer.scrollback(line);
         }
       }
     } catch {
-      console.log('No audit log found.');
+      writer.scrollback('No audit log found.');
     }
+    await writer.flush();
   } else if (command === 'config') {
     const sub = rawArgs[1];
     if (sub === 'set') {
       const key = rawArgs[2];
       const value = rawArgs[3];
       if (!key || value === undefined) {
+        // audit: allowed — pre-UI argparse usage error to stderr; exits immediately.
         process.stderr.write(`Usage: semalt-code config set <key> <value>\n`);
         process.exit(1);
       }
@@ -194,11 +199,12 @@ Config: ${CONFIG_PATH}
         parsed = value;
       }
       configSet(key, parsed);
-      console.log(`Set ${key} = ${JSON.stringify(parsed)}`);
+      writer.scrollback(`Set ${key} = ${JSON.stringify(parsed)}`);
     } else {
       // default: "show" or bare "config"
-      console.log(configShow());
+      writer.scrollback(configShow());
     }
+    await writer.flush();
   } else {
     const { opts } = parseArgs(rawArgs);
     await commands.cmdChat(opts);
@@ -209,6 +215,7 @@ main().catch((error) => {
   // Tear down the TUI synchronously so the error message lands below the
   // last scrollback line, not on top of a still-rendered live region.
   try { ui.teardownTerminal(); } catch {}
+  // audit: allowed — fatal error message to stderr after writer teardown.
   process.stderr.write(`\n  ${ui.FG_RED}✗ Fatal: ${error.message}${ui.RST}\n\n`);
   process.exit(1);
 });

package/lib/agent.js

@@ -8,6 +8,8 @@ const { mapInvokeToCall } = require('./tools');
 const { UI_THEME } = require('./ui/theme');
 const { RST } = require('./ui/ansi');
 const { getCols: _getCols, repeatToWidth } = require('./ui/utils');
+const writer = require('./ui/writer');
+const messages = require('./ui/messages');
 
 class StreamParser {
   constructor(onToken, onTagOpen, onTagContent, onTagClose) {
@@ -153,6 +155,31 @@ function estimateTokens(text) {
   return Math.floor((text || '').length / 4);
 }
 
+// User-initiated aborts surface through several shapes depending on where in
+// the Node http stack the signal fires: `new Error('Aborted')` from our own
+// abort paths in api.js, or AbortError/ABORT_ERR from Node's built-ins. The
+// authoritative check is the signal itself — this helper is the fallback.
+function isAbortError(err) {
+  if (!err) return false;
+  if (err.name === 'AbortError') return true;
+  if (err.code === 'ABORT_ERR' || err.code === 'ERR_ABORTED') return true;
+  if (typeof err.message === 'string' && /^Aborted$/i.test(err.message)) return true;
+  return false;
+}
+
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal && signal.aborted) { resolve(); return; }
+    const t = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        clearTimeout(t);
+        resolve();
+      }, { once: true });
+    }
+  });
+}
+
 function detectFormat(reply, toolCalls) {
   if (!reply || !reply.trim()) return 'empty';
   if (/<(minimax:tool_call|qwen:tool_call|tool_call|function_call)\b/i.test(reply)) return 'tool_call';
@@ -281,6 +308,116 @@ function truncateForDebug(text, maxLines = 40, maxChars = 2000) {
   return s;
 }
 
+// Per-tag meta extractor. Converts a tool-executor return value into the
+// compact meta object consumed by the tool-line formatter — exit codes for
+// shell, byte counts for file ops, status_code + bytes for HTTP, etc. A
+// pure function by design: no UI state, no config reads. The callback
+// layer (commands.js) feeds the meta into formatToolLine together with
+// the tag, so the formatter can produce the 4-segment line in either the
+// pending (live region) or final (scrollback) context.
+function _metaForTool(tag, result) {
+  if (!result || result.error) return null;
+  switch (tag) {
+    case 'shell':
+    case 'exec':
+      return { exit_code: result.exit_code };
+    case 'read':
+    case 'read_file':
+      return {
+        bytes: typeof result.bytes === 'number'
+          ? result.bytes
+          : (result.content ? Buffer.byteLength(String(result.content), 'utf8') : 0),
+      };
+    case 'write':
+    case 'write_file':
+    case 'create_file':
+    case 'append':
+    case 'append_file':
+    case 'upload':
+      return { bytes: typeof result.bytes === 'number' ? result.bytes : 0 };
+    case 'list_dir':
+      return { count: Array.isArray(result.items) ? result.items.length : 0 };
+    case 'search_files':
+      return { count: Array.isArray(result.files) ? result.files.length : 0 };
+    case 'search_in_file':
+      return { count: Array.isArray(result.matches) ? result.matches.length : 0 };
+    case 'replace_in_file':
+      return { count: typeof result.count === 'number' ? result.count : 0 };
+    case 'http_get':
+    case 'download':
+      return {
+        status_code: result.status_code,
+        bytes: typeof result.bytes === 'number'
+          ? result.bytes
+          : (result.body ? Buffer.byteLength(String(result.body), 'utf8') : 0),
+      };
+    case 'file_stat':
+      return {
+        bytes: result.size_kb ? Math.round(parseFloat(result.size_kb) * 1024) : 0,
+        kind: result.type || null,
+      };
+    default:
+      return null;
+  }
+}
+
+// Turn a [action, arg1, arg2, …] call tuple into the `attrs` bag that
+// formatToolLine looks up when building the operation string. Centralized
+// here so the per-tag positional-arg contract is written down in exactly
+// one place — any new tool added to the agent-loop tuple schema also gets
+// its attrs mapping here.
+function _attrsFromCall(call) {
+  if (!Array.isArray(call) || call.length === 0) return {};
+  const [tag, ...args] = call;
+  switch (tag) {
+    case 'shell':
+    case 'exec':
+      return { command: args[0] || '' };
+    case 'read':
+    case 'read_file':
+    case 'list_dir':
+    case 'delete_file':
+    case 'make_dir':
+    case 'remove_dir':
+    case 'file_stat':
+      return { path: args[0] || '' };
+    case 'write':
+    case 'write_file':
+    case 'create_file':
+    case 'append':
+    case 'append_file':
+      return { path: args[0] || '', content: args[1] || '' };
+    case 'upload':
+      return { path: args[0] || '' };
+    case 'move_file':
+    case 'copy_file':
+      return { src: args[0] || '', dst: args[1] || '' };
+    case 'edit_file':
+      return { path: args[0] || '', line: args[1], content: args[2] || '' };
+    case 'search_files':
+      return { pattern: args[0] || '', dir: args[1] || '.' };
+    case 'search_in_file':
+      return { path: args[0] || '', pattern: args[1] || '' };
+    case 'replace_in_file':
+      return { path: args[0] || '', search: args[1] || '', replace: args[2] || '', flags: args[3] || '' };
+    case 'get_env':
+      return { name: args[0] || '' };
+    case 'set_env':
+      return { name: args[0] || '', value: args[1] || '' };
+    case 'download':
+    case 'http_get':
+      return { url: args[0] || '' };
+    case 'ask_user':
+      return { question: args[0] || '' };
+    case 'store_memory':
+      return { key: args[0] || '', value: args[1] || '' };
+    case 'recall_memory':
+      return { key: args[0] || '' };
+    default:
+      return {};
+  }
+}
+
 function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agentExecFile, ui, getConfig }) {
   const { BOLD, FG_DARK, FG_GRAY, FG_TEAL, FG_YELLOW, RST, THEME, getCols } = ui;
 
@@ -466,6 +603,7 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
     // for one-shot/non-TTY flows where there's no UI to host the block.
     const emitDebug = (block) => {
       if (typeof cb.onDebug === 'function') cb.onDebug(block);
+      // audit: allowed — stderr debug under --debug flag (no UI hosting available).
       else process.stderr.write('\n' + block + '\n');
     };
 
@@ -479,12 +617,6 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
 
     const activeSystemPrompt = overrideSystemPrompt !== null ? overrideSystemPrompt : getSystemPrompt(nativeTools);
 
-    // Response contract: every model response must end with a tool call or
-    // <final_answer>...</final_answer>. Anything else is degraded — push a
-    // synthetic nudge and retry, capped to prevent runaway loops.
-    const MAX_DEGRADED_RETRIES = 2;
-    let degradedRetries = 0;
-
     for (let iteration = 0; iteration < maxIterations; iteration++) {
       if (isAborted()) break;
       const linePrefix = `${FG_TEAL}${BOLD}◆ ${RST}`;
@@ -582,6 +714,14 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
             lastApiErr = null;
             break;
           } catch (err) {
+            // User-initiated abort: not a transient failure. Skip the retry
+            // counter, the "Retrying (N/M)..." status update, the debug dump,
+            // and the post-loop error surface. The "Interrupted." feedback is
+            // already shown by the input-field abort listener.
+            if (controller.signal.aborted || isAborted() || isAbortError(err)) {
+              lastApiErr = null;
+              break;
+            }
             lastApiErr = err;
             if (debug) {
               const status = err.statusCode ? `HTTP ${err.statusCode}` : 'network error';
@@ -621,13 +761,25 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
               }
             }
             cb.onRetry?.(attempt + 1, MAX_RETRIES);
-            await new Promise((r) => setTimeout(r, delayMs));
+            await abortableSleep(delayMs, controller.signal);
+            // Ctrl+C pressed during backoff: bail without the next attempt.
+            if (controller.signal.aborted || isAborted()) {
+              lastApiErr = null;
+              break;
+            }
           }
         }
       } finally {
         clearInterval(abortWatcher);
       }
 
+      // User-initiated abort: exit the turn quietly. Skip the empty-reply
+      // "connection dropped" warning below — the abort listener already
+      // surfaced "Interrupted." and the outer prompt will return.
+      if (controller.signal.aborted || isAborted()) {
+        break;
+      }
+
       if (lastApiErr) {
         if (cb.onError) cb.onError(lastApiErr);
         break;
@@ -652,13 +804,7 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
         if (cb.onError) {
           cb.onError({ message: warnMsg, isWarning: true });
         } else {
-          // Non-TUI fallback (cb.onError is unset only for one-shot CLI
-          // commands like `cmdCode`, which don't run the shared live-region
-          // writer). Direct stdout write is safe here: no status-bar timer
-          // or bubble renderer is competing for stdout.
-          process.stdout.write(
-            `\n  ${THEME.warn}⚠ ${warnMsg}${THEME.reset}\n`
-          );
+          messages.sysWarn(warnMsg);
         }
       }
 
@@ -729,9 +875,6 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
       }
       const isNativeCall = nativeToolCalls.length > 0;
       const cleanedReply = cleanAssistantContent(reply);
-      // Protocol contract: a valid response ends with a tool call OR a
-      // <final_answer>...</final_answer> block. Anything else is degraded.
-      const hasFinal = /<final_answer\b[\s\S]*?<\/final_answer>/i.test(reply);
 
       if (debug && result) {
         const lastUserMsg = [...messagesWithSystem].reverse().find((m) => m.role === 'user');
@@ -864,46 +1007,25 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
           continue;
         }
 
-        if (hasFinal) {
-          // Model declared it is done — honor the protocol and terminate.
-          // An empty <final_answer></final_answer> is the model's choice;
-          // we don't police content.
-          degradedRetries = 0;
-          break;
-        }
-
-        // Protocol violation: neither a tool call nor a <final_answer>. Nudge
-        // the model to restate in-protocol, capped to prevent runaway loops.
-        if (degradedRetries >= MAX_DEGRADED_RETRIES) {
-          if (cb.onError) {
-            cb.onError({ message: `Agent violated the response contract after ${MAX_DEGRADED_RETRIES} retries — no tool call or <final_answer> block emitted. Stopping.`, isWarning: false });
-          }
-          break;
-        }
-        degradedRetries++;
-        if (cb.onError) {
-          cb.onError({ message: 'Response missing tool call or <final_answer> — nudging model to retry in-protocol.', isWarning: true });
-        }
-        messages.push({
-          role: 'user',
-          content: 'Your previous response contained neither a tool call nor a <final_answer> block, which violates the response contract. If you need to perform an action, emit the appropriate tool tag now. If you are done, wrap your reply in <final_answer>...</final_answer>. Do not describe intended actions in prose.',
-        });
-        continue;
+        // No tool calls and non-empty content (the empty case was already
+        // handled by the `!reply` guard above). This is the model's final
+        // answer for this turn — end the loop and return control to the user.
+        break;
       }
-      // Non-degraded response (has tool calls) — reset the retry counter.
-      degradedRetries = 0;
       if (isAborted()) break;
 
       if (!cb.onToolStart) {
-        // Non-TUI fallback: only one-shot CLI commands leave cb.onToolStart
-        // unset. The shared live-region writer isn't running, so a direct
-        // write here can't interleave with a bubble/status redraw.
-        process.stdout.write(`\n  ${FG_TEAL}◆${RST} ${FG_GRAY}Found ${toolCalls.length} action(s) to execute${RST}\n`);
+        writer.scrollback(`\n  ${FG_TEAL}◆${RST} ${FG_GRAY}Found ${toolCalls.length} action(s) to execute${RST}`);
       }
 
       const results = [];
       const debugEntries = debug ? [] : null;
       let aborted = false;
+      // Per-invocation id. Paired across onToolStart/onToolEnd so the UI
+      // layer can track each concurrent tool's activity-region slot and
+      // commit its final line atomically via endActivity. Monotonic —
+      // never reused even if the agent runs the same tag twice.
+      let invocationCounter = 0;
 
       for (const call of toolCalls) {
         if (isAborted()) { aborted = true; break; }
@@ -911,8 +1033,11 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
         const tag = call[0] || 'unknown';
         const arg = call[1] || '';
         const toolStart = Date.now();
+        const invocationId = `tool-${iteration}-${invocationCounter++}-${tag}`;
+        const attrs = _attrsFromCall(call);
+        const startCtx = { id: invocationId, call, attrs, startedAt: toolStart };
 
-        if (cb.onToolStart) cb.onToolStart(tag, arg);
+        if (cb.onToolStart) cb.onToolStart(tag, arg, startCtx);
 
         try {
           if (tag === 'shell') {
@@ -920,7 +1045,7 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
             const ms = Date.now() - toolStart;
             if (shellResult.stderr === 'Permission denied by user') {
               const resultStr = `Command \`${arg}\`: Permission denied by user.`;
-              if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms);
+              if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms, { id: invocationId, call, attrs, meta: null, error: { message: 'denied' }, denied: true });
               results.push(resultStr);
               if (debugEntries) debugEntries.push({ tag, call, ms, status: 'denied', exitCode: null, result: resultStr });
               aborted = true;
@@ -929,7 +1054,11 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
               let out = shellResult.stdout;
               if (shellResult.stderr) out += `\nSTDERR: ${shellResult.stderr}`;
               const resultStr = `Command \`${arg}\`:\nExit code: ${shellResult.exit_code}\n${out}`;
-              if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms);
+              const meta = _metaForTool(tag, shellResult);
+              const error = shellResult.exit_code !== 0
+                ? { message: `exit ${shellResult.exit_code}`, code: shellResult.exit_code }
+                : null;
+              if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms, { id: invocationId, call, attrs, meta, error });
               results.push(resultStr);
               if (debugEntries) debugEntries.push({
                 tag,
@@ -948,14 +1077,18 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
 
           if (fileResult.error === 'Permission denied') {
             const resultStr = `${tag} ${call[1] || ''}: Permission denied by user.`;
-            if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms);
+            if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms, { id: invocationId, call, attrs, meta: null, error: { message: 'denied' }, denied: true });
             results.push(resultStr);
             if (debugEntries) debugEntries.push({ tag, call, ms, status: 'denied', exitCode: null, result: resultStr });
             aborted = true;
             break;
           } else {
             const resultStr = formatFileResult(call, fileResult);
-            if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms);
+            const meta = _metaForTool(tag, fileResult);
+            const error = fileResult.error
+              ? { message: fileResult.error, code: fileResult.error_code || null }
+              : null;
+            if (cb.onToolEnd) cb.onToolEnd(tag, resultStr, ms, { id: invocationId, call, attrs, meta, error });
             results.push(resultStr);
             if (debugEntries) debugEntries.push({
               tag,
@@ -968,12 +1101,11 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
           }
         } catch (err) {
           const ms = Date.now() - toolStart;
-          if (cb.onToolEnd) cb.onToolEnd(tag, `Error: ${err.message}`, ms);
+          if (cb.onToolEnd) cb.onToolEnd(tag, `Error: ${err.message}`, ms, { id: invocationId, call, attrs, meta: null, error: err });
           if (cb.onError) {
             cb.onError({ message: `Tool error (${tag}): ${err.message}`, isWarning: true });
           } else {
-            // Non-TUI fallback — see comment on the onToolStart branch above.
-            process.stdout.write(`\n  ${THEME.warn}⚠ Tool error (${tag}): ${err.message}${THEME.reset}\n`);
+            messages.toolError(tag, err.message);
           }
           logToolCall(tag, { args: call.slice(1) }, false, 'error');
           results.push(`${tag}: Error — ${err.message}`);
@@ -1033,8 +1165,7 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
         if (cb.onError) {
           cb.onError({ message: warnMsg, isWarning: true });
         } else {
-          // Non-TUI fallback — see comment above on the Found-actions path.
-          process.stdout.write(`\n  ${FG_YELLOW}⚠${RST} ${FG_GRAY}${warnMsg}${RST}`);
+          messages.sysWarn(warnMsg);
         }
         // Push whatever results accumulated before the denial so the LLM has
         // context if the user asks to continue.

package/lib/api.js

@@ -6,6 +6,8 @@ const { URL } = require('url');
 
 const { buildToolsSchema, isUIActive } = require('./tools');
 const { TOOL_SPECS } = require('./tool_specs');
+const writer = require('./ui/writer');
+const messages = require('./ui/messages');
 
 function createApiClient({ getConfig, saveConfig, ui }) {
   const {
@@ -17,7 +19,6 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     FG_RED,
     FG_TEAL,
     RST,
-    StatusBar,
     StreamRenderer,
   } = ui;
 
@@ -472,10 +473,10 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       const toolCallAcc = [];
       const renderer = new StreamRenderer({ firstLinePrefix: linePrefix, showThink });
       if (!silent) {
+        // audit: allowed — non-TUI streaming setup, must interleave with StreamRenderer sync writes.
         process.stdout.write('\n');
         renderer._linesWritten = 1;
       }
-      let firstContentToken = true;
       let lineBuffer = '';
 
       function escapeXml(s) {
@@ -517,14 +518,6 @@ function createApiClient({ getConfig, saveConfig, ui }) {
           }));
         if (!nativeTools) appendToolCallsXml();
         if (!silent) renderer.flush();
-        const elapsed = (Date.now() - startTime) / 1000;
-        const tps = tokenCount / (elapsed || 1);
-        if (StatusBar.current) {
-          let latency = `${Math.round(tps)} tok/s · ${elapsed.toFixed(1)}s`;
-          if (reasoningText) latency += ` · ${estimateTokens(reasoningText)} think`;
-          StatusBar.current.liveUpdate({ tokens: `${tokenCount} tok`, latency });
-          StatusBar.current.render();
-        }
         // Fallback for endpoints that don't honor stream_options.include_usage:
         // estimate prompt/completion tokens locally so the status bar still updates.
         let usage = streamUsage;
@@ -613,6 +606,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               if (!inReasoning) {
                 inReasoning = true;
                 if (showThink && !uiActive) {
+                  // audit: allowed — non-TUI thinking output, interleaves with StreamRenderer sync writes.
                   process.stdout.write(`\n  ${FG_DARK}${DIM}⟨thinking⟩${RST}`);
                   renderer._linesWritten++;
                 }
@@ -620,6 +614,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               reasoningText += reasoning;
               tokenCount++;
               if (showThink && !uiActive) {
+                // audit: allowed — non-TUI thinking output, interleaves with StreamRenderer sync writes.
                 process.stdout.write(`${FG_DARK}${DIM}${reasoning}${RST}`);
               }
             }
@@ -633,14 +628,6 @@ function createApiClient({ getConfig, saveConfig, ui }) {
                 if (tc.id) toolCallAcc[idx].id = tc.id;
                 if (tc.function?.name) toolCallAcc[idx].name += tc.function.name;
                 if (tc.function?.arguments) toolCallAcc[idx].arguments += tc.function.arguments;
-                // When the model streams purely via delta.tool_calls (no
-                // delta.content), firstContentToken never flips, so the status
-                // bar stays on "Thinking…" for the entire tool-call stream.
-                // Surface each new tool slot the moment its name is known so
-                // the user sees "Using tool: <name>" instead of a frozen UI.
-                if (isNew && StatusBar.current && toolCallAcc[idx].name) {
-                  StatusBar.current.update('tool', `Using tool: ${toolCallAcc[idx].name}`);
-                }
               }
             }
 
@@ -649,28 +636,18 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               if (inReasoning) {
                 inReasoning = false;
                 if (showThink && !silent) {
+                  // audit: allowed — non-TUI thinking output, interleaves with StreamRenderer sync writes.
                   process.stdout.write(`${FG_DARK}⟨/thinking⟩${RST}\n`);
                   renderer._linesWritten++;
                 }
               }
               if (onToken) {
-                if (firstContentToken) {
-                  firstContentToken = false;
-                  if (StatusBar.current) StatusBar.current.update({ status: 'streaming' });
-                }
                 onToken(content);
               } else {
                 renderer.feed(content);
               }
               fullText += content;
               tokenCount++;
-              if (tokenCount % 20 === 0 && StatusBar.current) {
-                const elapsedSec = (Date.now() - startTime) / 1000 || 0.001;
-                StatusBar.current.liveUpdate({
-                  tokens: `${tokenCount} tok`,
-                  latency: `${Math.round(tokenCount / elapsedSec)} tok/s`,
-                });
-              }
             }
           } catch {}
         }
@@ -712,7 +689,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         },
       }, body);
     } catch (error) {
-      console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+      messages.netError(error.message);
       return '';
     }
 
@@ -724,7 +701,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       });
       res.on('end', () => {
         if (res.statusCode !== 200) {
-          console.log(`  ${FG_RED}✗ Error: HTTP ${res.statusCode} — ${data}${RST}`);
+          messages.netError(`HTTP ${res.statusCode} — ${data}`);
           resolve('');
           return;
         }
@@ -732,15 +709,15 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         try {
           const parsed = JSON.parse(data);
           const content = parsed.choices[0].message.content;
-          console.log(content);
+          writer.scrollback(content);
           resolve(content);
         } catch (error) {
-          console.log(`  ${FG_RED}✗ Parse error: ${error.message}${RST}`);
+          messages.netError(`Parse error: ${error.message}`);
           resolve('');
         }
       });
       res.on('error', (error) => {
-        console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        messages.netError(error.message);
         resolve('');
       });
     });