@semalt-ai/code 1.8.3 → 1.8.4

package/lib/commands.js

@@ -8,6 +8,10 @@ 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,
@@ -100,29 +103,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,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 = [];
@@ -300,10 +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;
 
     function getNavSearchText(type, item) {
       if (type === 'history') {
@@ -361,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() {
@@ -447,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}` });
@@ -478,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');
@@ -535,7 +567,7 @@ function createCommands({
       // Exit
       if (['exit', 'quit', '/exit', '/quit'].includes(text.toLowerCase())) {
         saveSession();
-        destroy();
+        destroy(buildExitArtifacts());
         resolveExit();
         return;
       }
@@ -569,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();
@@ -617,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;
@@ -666,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 {
@@ -688,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;
       }
@@ -803,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 });
 
@@ -845,29 +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 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) {
-            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');
+              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) => {
@@ -958,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) {
@@ -1005,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) : '';
@@ -1016,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');
     }
   }
 
@@ -1079,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;
@@ -1091,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 };
   }
 
@@ -1113,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() {
@@ -1174,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 {

package/lib/config.js

@@ -20,6 +20,7 @@ function _maybeWarnApiKeyAny(cfg) {
   }
   if (_LOCAL_HOSTS.has(host)) return;
   _apiKeyAnyWarned = true;
+  // audit: allowed — pre-UI startup warning, fires once before TUI initialises.
   process.stderr.write(
     "⚠ api_key='any' against non-local endpoint — requests will likely fail " +
     "with 401. Run 'semalt-code config set api_key <key>' to set a real key.\n"

package/lib/constants.js

@@ -12,7 +12,7 @@ const DEFAULT_CONFIG = {
   api_key: 'any',
   dashboard_url: 'https://cli.semalt.ai',
   auth_token: '',
-  default_model: 'default',
+  default_model: '',
   dashboard_model_id: null,
   temperature: 0.7,
   request_timeout_ms: DEFAULT_API_TIMEOUT_MS,