@semalt-ai/code 1.8.1 → 1.8.4

package/lib/commands.js

@@ -4,10 +4,14 @@ const fs = require('fs');
 
 const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS, TAG_REGISTRY } = require('./constants');
 const { configShow } = require('./config');
-const { SYSTEM_PROMPT } = require('./prompts');
+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');
 
 function formatTimeAgo(ts) {
   const diffMs = Date.now() - ts;
@@ -41,9 +45,8 @@ function createCommands({
     FG_TEAL,
     FG_YELLOW,
     RST,
-    StatusBar,
+    approxTokens,
     getCols,
-    hr,
     boxLine,
     interactiveSelect,
     createUI,
@@ -96,43 +99,79 @@ function createCommands({
       (m) => m.model === model || (m.api_base === config.api_base && m.model === config.default_model)
     );
     if (match && Number.isInteger(match.context_length) && match.context_length > 0) return match.context_length;
+    if (Number.isInteger(config.context_length) && config.context_length > 0) return config.context_length;
     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);
       },
     });
 
     setUIActive(true);
 
+    const writer = require('./ui/writer');
     permissionManager.setUICallbacks({
       onAddMessage:      (msg)     => chatHistory.addMessage(msg),
       onRerenderMessage: (id)      => chatHistory.rerenderById(id),
       onCollapseMessage: (id)      => chatHistory.collapseById(id),
       onRemoveMessage:   (id)      => chatHistory.removeById(id),
+      // Modal-region API: setModal replaces the modal live band above the
+      // status region; clearModal drops it. Arrow-key redraws go through
+      // setModal only — no scrollback churn. When the picker resolves we
+      // clear the modal and push a single summary line to scrollback.
+      onShowModal: (lines) => writer.setModal(lines),
+      onCloseModal: (summary) => {
+        writer.clearModal();
+        if (summary) chatHistory.addMessage({ role: 'system', content: summary });
+      },
       onCaptureNavigation: (handler) => {
         inputField.captureNavigation(handler);
         return () => inputField.releaseNavigation();
@@ -146,6 +185,10 @@ 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 = [];
@@ -187,14 +230,13 @@ function createCommands({
     }
     refreshInputSearchItems();
 
-    // Banner — write at row 1, then compact the layout so the fixed panels sit
-    // immediately below the banner with no blank gap.  The layout grows as
-    // messages are added (dynamic layout mode) until it reaches full-screen.
+    // Banner — emit once as scrollback above the live region. In the
+    // bottom-anchored live-region TUI, scrollback flows into terminal
+    // scrollback naturally, so no absolute positioning or scroll-region
+    // trickery is needed here.
     if (layout) {
-      const BANNER_LINES = 8; // blank + top-border + empty + title + desc + empty + bottom-border + blank
       const w = Math.min(getCols() - 4, 60);
-      process.stdout.write('\x1b[1;1H');
-      process.stdout.write([
+      const banner = [
         ``,
         `  ${FG_DARK}╭${'─'.repeat(w + 1)}╮${RST}`,
         boxLine('', w),
@@ -203,19 +245,8 @@ function createCommands({
         boxLine('', w),
         `  ${FG_DARK}╰${'─'.repeat(w + 1)}╯${RST}`,
         ``,
-      ].join('\n') + '\n');
-
-      // Keep historyStart = 1 so the banner is inside the scroll region.
-      // Growing mode uses _contentLines to position the first message below the
-      // banner (at row BANNER_LINES + 1).  When the terminal fills up the banner
-      // scrolls naturally into the terminal scrollback — nothing disappears behind
-      // a fixed header.
-      layout._contentLines = BANNER_LINES;
-      layout.rows = BANNER_LINES + 1 + layout.inputHeight + 3;
-
-      // Erase the stale full-screen panels createUI drew before we compacted.
-      process.stdout.write(`\x1b[${layout.rows + 1};1H\x1b[J`);
-
+      ].join('\n');
+      writer.scrollback(banner);
       redrawFixed();
     }
 
@@ -256,24 +287,29 @@ function createCommands({
       try { await dashboardSaveMessages(currentChatId, newMessages); savedUpTo = messages.length; } catch {}
     }
 
-    const HISTORY_DISPLAY_TURNS = 3; // user+assistant pairs to show on load
-
     function displayLoadedMessages(loadedMessages) {
       chatHistory.clearMessages();
-      const visible = loadedMessages.filter(
-        (m) => (m.role === 'user' || m.role === 'assistant') &&
-               (typeof m.content === 'string' ? m.content : '').trim()
-      );
-      const skip = Math.max(0, visible.length - HISTORY_DISPLAY_TURNS * 2);
-      if (skip > 0) {
-        chatHistory.addMessage({ role: 'system', content: `… ${skip} earlier messages not shown` });
-      }
-      for (const m of visible.slice(skip)) {
-        chatHistory.addMessage({
-          role: m.role,
-          content: typeof m.content === 'string' ? m.content : '',
-          ts: m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date()),
-        });
+      for (const m of loadedMessages) {
+        if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') continue;
+        const raw = typeof m.content === 'string' ? m.content : '';
+        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 });
+          continue;
+        }
+
+        if (m.role === 'user' && raw.startsWith('Tool execution results:')) {
+          const body = raw
+            .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 });
+          continue;
+        }
+
+        if (!raw.trim()) continue;
+        chatHistory.addMessage({ role: m.role, content: raw, ts });
       }
     }
 
@@ -296,32 +332,12 @@ function createCommands({
       }
     }
 
-    // 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;
-
-    // In-place progress indicator for chunked HTTP fetches (http_get + http_get_next)
-    let httpFetchMsg = null;
-
-    function showHttpFetchProgress(url, part, total) {
-      const maxUrl = Math.max(20, getCols() - 35);
-      const shortUrl = url.length > maxUrl ? url.slice(0, maxUrl - 1) + '…' : url;
-      const content = `Fetching URL  ·  ${shortUrl}  ·  Part ${part}/${total}`;
-      if (!httpFetchMsg) {
-        httpFetchMsg = { role: 'tool', tag: 'http_get', content, id: `http-fetch-${Date.now()}` };
-        chatHistory.addMessage(httpFetchMsg);
-      } else {
-        httpFetchMsg.content = content;
-        chatHistory.rerenderById(httpFetchMsg.id);
-      }
-    }
-
-    function finalizeHttpFetch() {
-      if (!httpFetchMsg) return;
-      chatHistory.removeById(httpFetchMsg.id);
-      httpFetchMsg = null;
-    }
 
     function getNavSearchText(type, item) {
       if (type === 'history') {
@@ -379,31 +395,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() {
@@ -465,6 +477,7 @@ function createCommands({
             currentModel = loaded.model;
             resolvedTokenLimit = await resolveTokenLimit(currentModel);
             statusBar.setModel(currentModel);
+            statusBar.setContextLimit(resolvedTokenLimit);
           }
           displayLoadedMessages(messages);
           chatHistory.addMessage({ role: 'system', content: `✓ Session loaded.  Model → ${currentModel}` });
@@ -496,6 +509,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');
@@ -553,7 +567,7 @@ function createCommands({
       // Exit
       if (['exit', 'quit', '/exit', '/quit'].includes(text.toLowerCase())) {
         saveSession();
-        destroy();
+        destroy(buildExitArtifacts());
         resolveExit();
         return;
       }
@@ -587,6 +601,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();
@@ -635,6 +650,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;
@@ -684,6 +707,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 {
@@ -706,14 +730,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;
       }
@@ -740,7 +767,7 @@ function createCommands({
       }
 
       if (text === '/prompt') {
-        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : SYSTEM_PROMPT;
+        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : getSystemPrompt();
         const src = resolvedSystemPrompt !== null ? `file: ${opts.systemPromptFile}` : 'built-in';
         const mode = getConfig().system_prompt_mode || 'system_role';
         chatHistory.addMessage({
@@ -821,6 +848,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 });
 
@@ -847,7 +879,7 @@ function createCommands({
           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' || tag === 'http_get_next';
+            const isDownload = tag === 'download' || tag === 'http_get';
             const barState = isDownload ? 'waiting_download' : 'tool';
             const label = isDownload
               ? `Waiting for download${detail ? ': ' + detail : ''}`
@@ -863,48 +895,57 @@ function createCommands({
           chatHistory.addMessage({ role: 'think', content });
           statusBar.update('streaming', 'Streaming response');
         },
-        onToolStart: (tag, input, attrs) => {
+        onToolStart: (tag, input, ctx) => {
           const actionLabel = TAG_REGISTRY[tag]?.label || tag;
-          const short = input.length > 40 ? input.slice(0, 40) + '…' : input;
-          const isDownload = tag === 'download' || tag === 'http_get' || tag === 'http_get_next';
+          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 {
             statusBar.update('tool', `${actionLabel}: ${short}`);
           }
-        },
-        onToolEnd: (tag, result, durationMs) => {
-          const isError = typeof result === 'string' && result.startsWith('Error');
-          if (isError) {
-            finalizeHttpFetch();
-            chatHistory.addMessage({
-              role: 'tool',
+          // 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.
+          if (ctx && ctx.id) {
+            writerModule.startActivity(ctx.id, (elapsedMs) => formatToolLine({
+              status: 'pending',
               tag,
-              content: `${tag} ✕ [${durationMs}ms]`,
-              output: typeof result === 'string' && result.trim() ? result : null,
-            });
-            statusBar.update('streaming', 'Streaming response');
-          } else if (tag === 'http_get') {
-            const chunkedMatch = typeof result === 'string' && result.match(/^HTTP GET (.+?) \(\d+\) \[Part 1\/(\d+)\]/);
-            if (chunkedMatch) {
-              showHttpFetchProgress(chunkedMatch[1], 1, parseInt(chunkedMatch[2], 10));
-            } else {
-              finalizeHttpFetch();
-              statusBar.update('tool', `✓ ${TAG_REGISTRY[tag]?.label || tag} [${durationMs}ms]`);
-            }
-          } else if (tag === 'http_get_next') {
-            const partMatch = typeof result === 'string' && result.match(/^HTTP content "(.+?)" \[Part (\d+)\/(\d+)\]/);
-            if (partMatch) {
-              const part = parseInt(partMatch[2], 10);
-              const total = parseInt(partMatch[3], 10);
-              showHttpFetchProgress(partMatch[1], part, total);
-              if (part === total) finalizeHttpFetch();
-            } else {
-              finalizeHttpFetch();
-            }
+              arg: input,
+              attrs: ctx.attrs,
+              durationMs: elapsedMs,
+            }));
+          }
+        },
+        onToolEnd: (tag, result, durationMs, ctx) => {
+          const hasError = !!(ctx && ctx.error);
+          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,
+          });
+          if (ctx && ctx.id) {
+            writerModule.endActivity(ctx.id, finalLine);
           } else {
-            const actionLabel = TAG_REGISTRY[tag]?.label || tag;
-            statusBar.update('tool', `✓ ${actionLabel} [${durationMs}ms]`);
+            // 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) => {
@@ -937,6 +978,11 @@ function createCommands({
         onRetry: (attempt, max) => {
           statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
         },
+        onDebug: (block) => {
+          // Render in-history as a tool-style bubble so ctrl+O expand works and
+          // the RAW RESPONSE text survives TUI redraws (stderr would be clobbered).
+          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) });
@@ -957,6 +1003,15 @@ function createCommands({
       };
       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 (resolvedTokenLimit == null) {
+        const cfg = getConfig();
+        if (Number.isInteger(cfg.context_length) && cfg.context_length > 0) {
+          resolvedTokenLimit = cfg.context_length;
+        }
+      }
+
       try {
         const agentResult = await runAgentLoop(messages, currentModel, undefined, resolvedTokenLimit, {
           showThink: opts.showThink || false,
@@ -981,18 +1036,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) {
@@ -1028,8 +1078,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) : '';
@@ -1039,62 +1090,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,
       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');
     }
   }
 
@@ -1102,10 +1151,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;
@@ -1114,18 +1163,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 };
   }
 
@@ -1136,55 +1185,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() {
@@ -1197,15 +1250,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 {