@semalt-ai/code 1.7.0 → 1.8.0

package/lib/commands.js

@@ -1,10 +1,22 @@
 'use strict';
 
 const fs = require('fs');
-const readline = require('readline');
 
-const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS } = require('./constants');
-const { getSystemPrompt } = require('./prompts');
+const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS, TAG_REGISTRY } = require('./constants');
+const { configShow } = require('./config');
+const { SYSTEM_PROMPT } = require('./prompts');
+const { SessionStorage } = require('./storage');
+const { getSkippedOps, setUIActive } = require('./tools');
+
+function formatTimeAgo(ts) {
+  const diffMs = Date.now() - ts;
+  const diffMin = Math.floor(diffMs / 60000);
+  if (diffMin < 1) return 'just now';
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHr = Math.floor(diffMin / 60);
+  if (diffHr < 24) return `${diffHr}h ago`;
+  return `${Math.floor(diffHr / 24)}d ago`;
+}
 
 function createCommands({
   getConfig,
@@ -18,6 +30,7 @@ function createCommands({
 }) {
   const {
     BOLD,
+    BG_SELECTED,
     FG_BLUE,
     FG_CYAN,
     FG_DARK,
@@ -27,20 +40,24 @@ function createCommands({
     FG_TEAL,
     FG_YELLOW,
     RST,
+    StatusBar,
     getCols,
-    printBanner,
-    printHelpHints,
-    printStatusBar,
-    readInteractiveInput,
+    hr,
+    boxLine,
+    interactiveSelect,
+    createUI,
   } = ui;
   const {
     chatStream,
     chatSync,
+    dashboardCreateChat,
+    dashboardGetChat,
     dashboardGetModelForCli,
+    dashboardListChats,
     dashboardListModels,
     dashboardLogout,
+    dashboardSaveMessages,
     dashboardWhoAmI,
-    describeModelProfile,
     estimateTokens,
     getCliLoginStatus,
     requestCliLogin,
@@ -54,201 +71,958 @@ function createCommands({
     return `  ${FG_CYAN}${label}:${RST} ${FG_GRAY}${value}${RST}`;
   }
 
+  async function resolveTokenLimit(model) {
+    const config = getConfig();
+    if (config.auth_token && config.dashboard_model_id) {
+      try {
+        const resp = await dashboardGetModelForCli(config.dashboard_model_id);
+        const m = resp && resp.model ? resp.model : null;
+        if (m) {
+          const limit = (Number.isInteger(m.context_length) && m.context_length > 0 ? m.context_length : null)
+            || (Number.isInteger(m.max_tokens) && m.max_tokens > 0 ? m.max_tokens : null);
+          if (limit) {
+            // Persist so chatStream's proactive trimming can use it without an extra API call.
+            if (config.context_length !== limit) {
+              setConfig({ ...config, context_length: limit });
+            }
+            return limit;
+          }
+        }
+      } catch {}
+    }
+    const localModels = Array.isArray(config.models) ? config.models : [];
+    const match = localModels.find(
+      (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;
+    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();
+  }
+
   async function cmdChat(opts) {
-    printBanner();
+    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`);
+        process.exit(0);
+      },
+    });
+
+    setUIActive(true);
+
+    permissionManager.setUICallbacks({
+      onAddMessage:      (msg)     => chatHistory.addMessage(msg),
+      onRerenderMessage: (id)      => chatHistory.rerenderById(id),
+      onCollapseMessage: (id)      => chatHistory.collapseById(id),
+      onRemoveMessage:   (id)      => chatHistory.removeById(id),
+      onCaptureNavigation: (handler) => {
+        inputField.captureNavigation(handler);
+        return () => inputField.releaseNavigation();
+      },
+      captureSelect: (menu) => inputField.captureSelect(menu),
+    });
+
+    inputField.on('expand', () => chatHistory.toggleLastExpand());
+
     const cwd = process.cwd();
     let currentModel = opts.model || getConfig().default_model;
-    let isRunningAgent = false;
+    let resolvedTokenLimit = await resolveTokenLimit(currentModel);
+    statusBar.setModel(currentModel);
+    let sessionMetrics = null;
+    // system prompt is prepended fresh on every API call in agent.js — never stored in history
+    let messages = [];
+    let currentChatId = null;
+    let savedUpTo = 0;
+
+    // Resolve system prompt override from --system-prompt file if provided
+    let resolvedSystemPrompt = null;
+    if (opts.systemPromptFile) {
+      try {
+        resolvedSystemPrompt = fs.readFileSync(opts.systemPromptFile, 'utf8');
+      } catch (err) {
+        // will be shown after UI initializes
+      }
+    }
+    const storage = new SessionStorage();
+    const sessionStart = Date.now();
+    let session = {
+      id: storage.generateId(),
+      created_at: sessionStart,
+      model: currentModel,
+      messages: [],
+      stats: { total_tokens: 0, duration_sec: 0 },
+    };
+
+    // Seed Ctrl+R search with local session summaries
+    function refreshInputSearchItems(extraItems) {
+      const sessions = storage.list();
+      const items = sessions.map(s => ({
+        type: 'session',
+        text: (() => {
+          const date = new Date(s.created_at).toISOString().slice(0, 16).replace('T', ' ');
+          return `${date} ${s.model || ''} (${s.message_count} msgs)`;
+        })(),
+      }));
+      if (extraItems) items.push(...extraItems);
+      inputField.setSearchItems(items);
+    }
+    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.
+    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([
+        ``,
+        `  ${FG_DARK}╭${'─'.repeat(w + 1)}╮${RST}`,
+        boxLine('', w),
+        boxLine(`${FG_TEAL}${BOLD}◆ Semalt.AI${RST}`, w),
+        boxLine(`${FG_GRAY}Self-hosted AI coding assistant${RST}`, w),
+        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`);
+
+      redrawFixed();
+    }
 
-    printStatusBar(currentModel, cwd);
-    printHelpHints();
+    // Welcome message
+    chatHistory.addMessage({
+      role: 'system',
+      content: `◆ Semalt.AI  ·  ${currentModel}  ·  ${cwd}\nType /help for commands.`,
+    });
 
-    let messages = [{ role: 'system', content: getSystemPrompt() }];
-    const promptHistory = [];
-    const cols = getCols();
+    if (opts.systemPromptFile && resolvedSystemPrompt === null) {
+      chatHistory.addMessage({ role: 'system', content: `✗ Could not read system prompt file: ${opts.systemPromptFile}`, isError: true });
+    } else if (opts.systemPromptFile && resolvedSystemPrompt !== null) {
+      chatHistory.addMessage({ role: 'system', content: `✓ Using system prompt from: ${opts.systemPromptFile}` });
+    }
 
-    while (true) {
-      const inputResult = await readInteractiveInput(`  ${FG_TEAL}${BOLD}>${RST} `, {
-        trim: false,
-        allowCursorNavigation: true,
-        history: promptHistory,
-      });
+    function saveSession() {
+      session.model = currentModel;
+      session.messages = messages;
+      session.stats.duration_sec = Math.round((Date.now() - sessionStart) / 1000);
+      session.stats.total_tokens = messages.reduce((s, m) => s + Math.round((m.content || '').length / 4), 0);
+      try { storage.save(session); } catch {}
+    }
 
-      if (inputResult.type === 'eof') {
-        console.log(`\n  ${FG_GRAY}Goodbye!${RST}\n`);
-        return;
+    async function createChatIfNeeded(firstUserText) {
+      const config = getConfig();
+      if (currentChatId !== null || !config.auth_token || !config.dashboard_model_id) return;
+      try {
+        const title = firstUserText.length > 60 ? firstUserText.slice(0, 57) + '...' : firstUserText;
+        const resp = await dashboardCreateChat(title, config.dashboard_model_id);
+        if (resp && resp.chat && resp.chat.id) currentChatId = resp.chat.id;
+      } catch {}
+    }
+
+    async function saveTurnToDashboard() {
+      if (currentChatId === null) return;
+      const newMessages = messages.slice(savedUpTo).filter((m) => m.role !== 'system');
+      if (!newMessages.length) return;
+      try { await dashboardSaveMessages(currentChatId, newMessages); savedUpTo = messages.length; } catch {}
+    }
+
+    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()),
+        });
       }
+    }
 
-      if (inputResult.type === 'sigint') {
-        if (!isRunningAgent) {
-          console.log(`\n  ${FG_YELLOW}Use Ctrl+D or type exit to quit.${RST}`);
+    // --resume: load previous chat
+    if (opts.resume) {
+      const resumeId = parseInt(opts.resume, 10);
+      if (!isNaN(resumeId)) {
+        try {
+          const chatData = await dashboardGetChat(resumeId);
+          const loaded = chatData && chatData.messages ? chatData.messages : [];
+          for (const m of loaded) messages.push({ role: m.role, content: m.content });
+          currentChatId = resumeId;
+          savedUpTo = messages.length;
+          const title = chatData.chat && chatData.chat.title ? chatData.chat.title : `#${resumeId}`;
+          displayLoadedMessages(loaded);
+          chatHistory.addMessage({ role: 'system', content: `✓ Resumed: ${title} (${loaded.length} messages)` });
+        } catch (error) {
+          chatHistory.addMessage({ role: 'system', content: `✗ Could not resume chat: ${error.message}`, isError: true });
         }
-        continue;
       }
+    }
 
-      const text = (inputResult.value || '').trim();
-      if (!text) continue;
-      promptHistory.push(text);
+    // Pending selection state (for in-chat /history, /models, /chats)
+    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') {
+        const date = new Date(item.created_at).toISOString().slice(0, 16);
+        return `${date} ${item.model || ''} ${item.message_count || ''}`;
+      } else if (type === 'chats') {
+        return `${item.title || ''} ${item.model_name || ''}`;
+      } else if (type === 'models') {
+        return `${item.name || ''} ${item.model_id || ''}`;
+      }
+      return '';
+    }
 
+    function buildItemDetail(type, item) {
+      const cfg = getConfig();
+      const maxDetail = Math.max(20, getCols() - 12);
+      let detail = '';
+      if (type === 'history') {
+        const date = new Date(item.created_at).toISOString().slice(0, 16).replace('T', ' ');
+        detail = `${date}  ${(item.model || '').slice(0, 20)}  (${item.message_count} msgs)`;
+      } else if (type === 'chats') {
+        const date = item.updated_at ? String(item.updated_at).slice(0, 10) : '';
+        detail = `${item.title}  ·  ${item.model_name || ''}  ·  ${date}`;
+      } else if (type === 'models') {
+        const active = item.base_url === cfg.api_base && item.model_id === cfg.default_model;
+        detail = `${active ? '●' : ' '}  ${item.name}  ·  ${item.model_id}`;
+      }
+      if (detail.length > maxDetail) detail = detail.slice(0, maxDetail - 1) + '…';
+      return detail;
+    }
+
+    function buildListContent() {
+      if (!pendingAction) return '';
+      const { type, items, displayItems: di, stepIdx, searchQuery } = pendingAction;
+      const items2 = di || items;
+      const page = Math.floor(stepIdx / PAGE_SIZE);
+      const pageCount = Math.ceil(items2.length / PAGE_SIZE);
+      const pageStart = page * PAGE_SIZE;
+      const pageItems = items2.slice(pageStart, pageStart + PAGE_SIZE);
+      const localIdx = stepIdx - pageStart;
+      const titleMap = { history: 'Sessions', chats: 'Chats', models: 'Models' };
+      const pageLabel = pageCount > 1 ? `  · Page ${page + 1}/${pageCount}` : '';
+      const countLabel = items2.length > 0 ? `[${stepIdx + 1}/${items2.length}]` : '[0 results]';
+      const searchLabel = searchQuery ? `  · filter: '${searchQuery}'` : '';
+      const parts = [`${titleMap[type] || type}  ${countLabel}${pageLabel}${searchLabel}`, ''];
+      for (let i = 0; i < pageItems.length; i++) {
+        const item = pageItems[i];
+        const sel = i === localIdx;
+        const detail = buildItemDetail(type, item);
+        parts.push(sel ? `\x1b[1m\x1b[36m  ►  ${detail}` : `     ${detail}`);
+      }
+      // Pad to a fixed height so rerenderById always clears the same number of rows,
+      // regardless of how many items the current page has (last page may have fewer).
+      while (parts.length < PAGE_SIZE + 2) parts.push('');
+      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 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);
+      }
+    }
+
+    function finalizeListMsg() {
+      if (listMsg) {
+        chatHistory.removeById(listMsg.id);
+        listMsg = null;
+      }
+    }
+
+    function activateNavCapture() {
+      inputField.captureNavigation(async (action) => {
+        if (!pendingAction) { inputField.releaseNavigation(); return; }
+        const { items, displayItems: di, stepIdx } = pendingAction;
+        const activeItems = di || items;
+
+        if (action.startsWith('search:')) {
+          const query = action.slice(7);
+          if (!query) {
+            pendingAction = { ...pendingAction, displayItems: null, searchQuery: '', stepIdx: 0 };
+          } else {
+            const filtered = items.filter(item => getNavSearchText(pendingAction.type, item).toLowerCase().includes(query.toLowerCase()));
+            pendingAction = { ...pendingAction, displayItems: filtered, searchQuery: query, stepIdx: 0 };
+          }
+          showPendingStep();
+          return;
+        }
+
+        if (action === 'next') {
+          pendingAction = { ...pendingAction, stepIdx: activeItems.length ? (stepIdx + 1) % activeItems.length : 0 };
+          showPendingStep();
+        } else if (action === 'prev') {
+          pendingAction = { ...pendingAction, stepIdx: activeItems.length ? (stepIdx - 1 + activeItems.length) % activeItems.length : 0 };
+          showPendingStep();
+        } else if (action === 'select') {
+          if (!activeItems.length) return;
+          inputField.releaseNavigation();
+          const si = pendingAction.stepIdx;
+          collapseListMsg(pendingAction.type, activeItems[si]);
+          statusBar.update('idle');
+          await handlePendingSelection(si);
+          inputField.setDisabled(false);
+        } else if (action === 'cancel') {
+          inputField.releaseNavigation();
+          finalizeListMsg();
+          chatHistory.addMessage({ role: 'system', content: 'Cancelled.' });
+          pendingAction = null;
+          statusBar.update('idle');
+          inputField.setDisabled(false);
+        }
+      });
+    }
+
+    async function handlePendingSelection(idx) {
+      if (!pendingAction) return;
+      const { type, items, displayItems: di } = pendingAction;
+      const activeItems = di || items;
+      pendingAction = null;
+
+      if (type === 'history') {
+        const loaded = storage.load(activeItems[idx].id);
+        if (loaded) {
+          messages = (loaded.messages || []).filter((m) => m.role !== 'system');
+          session = { id: loaded.id, created_at: loaded.created_at, model: loaded.model, messages, stats: loaded.stats || { total_tokens: 0, duration_sec: 0 } };
+          currentChatId = null; savedUpTo = 0;
+          if (loaded.model && loaded.model !== currentModel) {
+            currentModel = loaded.model;
+            resolvedTokenLimit = await resolveTokenLimit(currentModel);
+            statusBar.setModel(currentModel);
+          }
+          displayLoadedMessages(messages);
+          chatHistory.addMessage({ role: 'system', content: `✓ Session loaded.  Model → ${currentModel}` });
+        }
+      } else if (type === 'chats') {
+        const selectedChat = activeItems[idx];
+        try {
+          const chatData = await dashboardGetChat(selectedChat.id);
+          const loaded = chatData && chatData.messages ? chatData.messages : [];
+          messages = loaded.map((m) => ({ role: m.role, content: m.content }));
+          currentChatId = selectedChat.id; savedUpTo = messages.length;
+          displayLoadedMessages(loaded);
+          chatHistory.addMessage({ role: 'system', content: `✓ Resumed: ${selectedChat.title} (${loaded.length} messages)` });
+        } catch (err) {
+          chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+        }
+      } else if (type === 'models') {
+        const selectedModel = activeItems[idx];
+        try {
+          const credResp = await dashboardGetModelForCli(selectedModel.id);
+          const model = credResp && credResp.model ? credResp.model : null;
+          if (!model) { chatHistory.addMessage({ role: 'system', content: '✗ Unable to load model.', isError: true }); return; }
+          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 config = getConfig();
+          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);
+          currentModel = model.model_id;
+          resolvedTokenLimit = await resolveTokenLimit(currentModel);
+          statusBar.setModel(currentModel);
+          currentChatId = null;
+          chatHistory.addMessage({ role: 'system', content: `✓ Model → ${model.name} (${model.model_id})` });
+          statusBar.update('idle');
+        } catch (err) {
+          chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+        }
+      }
+    }
+
+    let resolveExit;
+    const exitPromise = new Promise((r) => { resolveExit = r; });
+
+
+    statusBar.update('idle');
+
+    inputField.onSubmit(async (text) => {
+      // Handle pending selection (text fallback for non-TTY; TTY uses captureNavigation)
+      if (pendingAction) {
+        inputField.releaseNavigation();
+        const t = text.trim().toLowerCase();
+        const { items, displayItems: di, stepIdx, type } = pendingAction;
+        const activeItems = di || items;
+        if (t === 's' || t === 'select' || t === 'y' || t === 'yes') {
+          collapseListMsg(type, activeItems[stepIdx]);
+          statusBar.update('idle');
+          await handlePendingSelection(stepIdx);
+          inputField.setDisabled(false);
+          return;
+        } else if (t === 'n' || t === 'next') {
+          pendingAction = { ...pendingAction, stepIdx: (stepIdx + 1) % items.length };
+          showPendingStep();
+          activateNavCapture();
+          return;
+        } else if (t === 'p' || t === 'prev') {
+          pendingAction = { ...pendingAction, stepIdx: (stepIdx - 1 + items.length) % items.length };
+          showPendingStep();
+          activateNavCapture();
+          return;
+        } else if (t === 'c' || t === 'cancel') {
+          finalizeListMsg();
+          chatHistory.addMessage({ role: 'system', content: 'Cancelled.' });
+          pendingAction = null;
+          statusBar.update('idle');
+          inputField.setDisabled(false);
+          return;
+        } else {
+          // Not a nav key: close nav silently and let the message go to AI
+          finalizeListMsg();
+          pendingAction = null;
+          statusBar.update('idle');
+          // fall through to AI processing below
+        }
+      }
+
+      // Exit
       if (['exit', 'quit', '/exit', '/quit'].includes(text.toLowerCase())) {
-        console.log(`\n  ${FG_GRAY}Goodbye!${RST}\n`);
+        saveSession();
+        destroy();
+        resolveExit();
         return;
       }
 
       if (text === '/help') {
-        console.log(`
-  ${FG_BLUE}${BOLD}Commands:${RST}
-  ${FG_CYAN}/file <path>${RST}     ${FG_GRAY}Load file or dir into context${RST}
-  ${FG_CYAN}/login${RST}           ${FG_GRAY}Authorize this CLI via browser${RST}
-  ${FG_CYAN}/whoami${RST}          ${FG_GRAY}Show current authorized user${RST}
-  ${FG_CYAN}/logout${RST}          ${FG_GRAY}Clear current CLI login${RST}
-  ${FG_CYAN}/model${RST}           ${FG_GRAY}Show or set current model id${RST}
-  ${FG_CYAN}/model <name>${RST}    ${FG_GRAY}Switch model manually${RST}
-  ${FG_CYAN}/models${RST}          ${FG_GRAY}Choose one of your dashboard models${RST}
-  ${FG_CYAN}/clear${RST}           ${FG_GRAY}Clear conversation${RST}
-  ${FG_CYAN}/compact${RST}         ${FG_GRAY}Show token usage${RST}
-  ${FG_CYAN}/shell <cmd>${RST}     ${FG_GRAY}Run shell command directly${RST}
-  ${FG_CYAN}!<cmd>${RST}           ${FG_GRAY}Run shell command directly${RST}
-  ${FG_CYAN}/approve${RST}         ${FG_GRAY}Toggle auto-approve for all actions${RST}
-  ${FG_CYAN}/config${RST}          ${FG_GRAY}Show config${RST}
-  ${FG_CYAN}exit${RST}             ${FG_GRAY}Quit${RST}
-
-  ${FG_DARK}The AI can execute commands — you'll be asked to approve each one.${RST}
-`);
-        continue;
+        chatHistory.addMessage({
+          role: 'system',
+          content: [
+            'Commands:',
+            '  /file <path>    Load file or dir into context',
+            '  /history        Browse local sessions',
+            '  /chats          Browse saved dashboard chats',
+            '  /new            Start fresh conversation',
+            '  /login          Authorize via browser',
+            '  /whoami         Show current user',
+            '  /logout         Clear CLI login',
+            '  /model          Show current model',
+            '  /model <name>   Switch model manually',
+            '  /models         Choose from dashboard models',
+            '  /clear          Clear conversation',
+            '  /compact        Show token usage',
+            '  /shell <cmd>    Run shell command',
+            '  !<cmd>          Run shell command',
+            '  /approve        Toggle auto-approve',
+            '  /config         Show config',
+            '  exit            Quit',
+          ].join('\n'),
+        });
+        return;
+      }
+
+      if (text === '/history') {
+        const sessions = storage.list();
+        if (!sessions.length) { chatHistory.addMessage({ role: 'system', content: 'No saved sessions.' }); return; }
+        refreshInputSearchItems();
+        chatHistory.addMessage({ role: 'system', content: '/history' });
+        pendingAction = { type: 'history', items: sessions, stepIdx: 0 };
+        showPendingStep();
+        statusBar.update('waiting', 'Select session...');
+        activateNavCapture();
+        return;
+      }
+
+      if (text === '/chats') {
+        const config = getConfig();
+        if (!config.auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
+        inputField.setDisabled(true);
+        statusBar.update('thinking', 'Loading chats...');
+        try {
+          const response = await dashboardListChats();
+          const chats = Array.isArray(response && response.chats) ? response.chats : [];
+          if (!chats.length) { chatHistory.addMessage({ role: 'system', content: 'No saved chats found.' }); statusBar.update('idle'); }
+          else {
+            refreshInputSearchItems(chats.map(c => ({ type: 'chat', text: c.title || `chat #${c.id}` })));
+            chatHistory.addMessage({ role: 'system', content: '/chats' });
+            pendingAction = { type: 'chats', items: chats, stepIdx: 0 };
+            showPendingStep();
+            statusBar.update('waiting', 'Select chat...');
+            activateNavCapture();
+          }
+        } catch (err) {
+          chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+          statusBar.update('idle');
+        }
+        inputField.setDisabled(false);
+        return;
+      }
+
+      if (text === '/new') {
+        messages = [];
+        currentChatId = null; savedUpTo = 0;
+        permissionManager.clear();
+        chatHistory.addMessage({ role: 'system', content: '✓ Started new conversation.' });
+        return;
       }
 
       if (text === '/login') {
-        await cmdLogin();
-        printStatusBar(currentModel, cwd);
-        continue;
+        inputField.setDisabled(true);
+        statusBar.update('thinking', 'Starting login...');
+        await _loginFlow(chatHistory, statusBar);
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+        return;
       }
 
       if (text === '/whoami') {
-        await cmdWhoAmI();
-        continue;
+        inputField.setDisabled(true);
+        statusBar.update('thinking', 'Loading...');
+        try {
+          const response = await dashboardWhoAmI();
+          const user = response && response.user ? response.user : null;
+          if (!user) { chatHistory.addMessage({ role: 'system', content: '✗ Unable to load current user.', isError: true }); }
+          else {
+            chatHistory.addMessage({ role: 'system', content: `Current User:\n  ID: ${user.id}\n  Email: ${user.email || '-'}\n  Name: ${user.name || '-'}\n  Provider: ${user.provider || '-'}` });
+          }
+        } catch (err) {
+          chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+        }
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+        return;
       }
 
       if (text === '/logout') {
-        await cmdLogout();
-        printStatusBar(currentModel, cwd);
-        continue;
+        const config = getConfig();
+        if (!config.auth_token) { chatHistory.addMessage({ role: 'system', content: '✗ Not logged in.' }); return; }
+        inputField.setDisabled(true);
+        statusBar.update('thinking', 'Logging out...');
+        try { await dashboardLogout(); } catch (err) { if (err.statusCode !== 401) { chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true }); statusBar.update('idle'); inputField.setDisabled(false); return; } }
+        setConfig({ ...config, auth_token: '' });
+        chatHistory.addMessage({ role: 'system', content: '✓ Logged out and cleared local CLI token.' });
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+        return;
       }
 
       if (text.startsWith('/file ')) {
         const fp = text.slice(6).trim();
-        const ctx = readFileContext([fp], ui);
-        if (ctx) messages.push({ role: 'user', content: `Here is the file context:\n${ctx}` });
-        continue;
+        const ctx = readFileContext([fp]);
+        if (ctx) {
+          messages.push({ role: 'user', content: `Here is the file context:\n${ctx}` });
+          chatHistory.addMessage({ role: 'system', content: `✓ Loaded: ${fp}` });
+        } else {
+          chatHistory.addMessage({ role: 'system', content: `✗ Could not load: ${fp}`, isError: true });
+        }
+        return;
       }
 
       if (text === '/models') {
-        currentModel = await cmdModels(currentModel, cwd);
-        continue;
+        inputField.setDisabled(true);
+        statusBar.update('thinking', 'Loading models...');
+        try {
+          const response = await dashboardListModels();
+          const models = Array.isArray(response && response.models) ? response.models : [];
+          if (!models.length) { chatHistory.addMessage({ role: 'system', content: '✗ No models available.' }); statusBar.update('idle'); }
+          else {
+            chatHistory.addMessage({ role: 'system', content: '/models' });
+            pendingAction = { type: 'models', items: models, stepIdx: 0 };
+            showPendingStep();
+            statusBar.update('waiting', 'Select model...');
+            activateNavCapture();
+          }
+        } catch (err) {
+          chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+          statusBar.update('idle');
+        }
+        inputField.setDisabled(false);
+        return;
       }
 
       if (text === '/model') {
-        console.log(`  ${FG_GRAY}Current model: ${currentModel}${RST}\n`);
-        continue;
+        chatHistory.addMessage({ role: 'system', content: `Current model: ${currentModel}` });
+        return;
       }
 
       if (text.startsWith('/model ')) {
         currentModel = text.slice(7).trim();
-        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Model → ${currentModel}${RST}`);
-        printStatusBar(currentModel, cwd);
-        continue;
+        resolvedTokenLimit = await resolveTokenLimit(currentModel);
+        statusBar.setModel(currentModel);
+        chatHistory.addMessage({ role: 'system', content: `✓ Model → ${currentModel}` });
+        return;
       }
 
       if (text === '/clear') {
-        messages = [{ role: 'system', content: getSystemPrompt() }];
+        messages = [];
+        currentChatId = null; savedUpTo = 0;
         permissionManager.clear();
-        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Conversation and approvals cleared${RST}\n`);
-        continue;
+        chatHistory.addMessage({ role: 'system', content: '✓ Conversation and approvals cleared.' });
+        return;
       }
 
       if (text === '/compact' || text === '/cost') {
-        const total = messages.reduce((sum, message) => sum + estimateTokens(message.content), 0);
-        console.log(`  ${FG_GRAY}${messages.length - 1} messages · ~${total} tokens${RST}\n`);
-        continue;
+        const total = messages.reduce((s, m) => s + estimateTokens(m.content), 0);
+        let msg = `${messages.length} messages · ~${total} tokens`;
+        if (sessionMetrics) msg += '\n' + sessionMetrics.summary();
+        chatHistory.addMessage({ role: 'system', content: msg });
+        return;
       }
 
       if (text === '/config') {
-        console.log(`  ${FG_GRAY}${JSON.stringify(getConfig(), null, 2)}${RST}\n`);
-        continue;
+        chatHistory.addMessage({ role: 'system', content: configShow(opts.systemPromptFile || null) });
+        return;
+      }
+
+      if (text === '/prompt') {
+        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : SYSTEM_PROMPT;
+        const src = resolvedSystemPrompt !== null ? `file: ${opts.systemPromptFile}` : 'built-in';
+        const mode = getConfig().system_prompt_mode || 'system_role';
+        chatHistory.addMessage({
+          role: 'system',
+          content: `System prompt (${src}, mode: ${mode}):\n\n${activePrompt}`,
+        });
+        return;
       }
 
       if (text === '/approve') {
         const enabled = permissionManager.toggleAll();
-        const state = enabled ? 'ON' : 'OFF';
-        const color = enabled ? FG_GREEN : FG_RED;
-        console.log(`  ${color}●${RST} ${FG_GRAY}Auto-approve: ${state}${RST}\n`);
-        continue;
+        chatHistory.addMessage({ role: 'system', content: `Auto-approve: ${enabled ? 'ON' : 'OFF'}` });
+        return;
       }
 
       if (text.startsWith('/shell ') || text.startsWith('!')) {
         const cmd = text.startsWith('/shell ') ? text.slice(7).trim() : text.slice(1).trim();
-        await agentExecShell(cmd);
-        continue;
+        inputField.setDisabled(true);
+        statusBar.update('tool', cmd);
+        try {
+          const shellResult = await agentExecShell(cmd);
+          let output = shellResult.stdout || '';
+          if (shellResult.stderr && shellResult.stderr !== 'Permission denied by user') {
+            output += (output ? '\n' : '') + `STDERR: ${shellResult.stderr}`;
+          }
+          const exitSuffix = shellResult.exit_code !== 0 ? `  [exit ${shellResult.exit_code}]` : '';
+          const display = output.trim() ? output.trim() + exitSuffix : `(no output)${exitSuffix}`;
+          chatHistory.addMessage({ role: 'shell', cmd, content: display, ts: new Date() });
+        } catch (err) {
+          chatHistory.addMessage({ role: 'system', content: `✗ Shell error: ${err.message}`, isError: true });
+        }
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+        return;
       }
 
+      // Block unauthenticated users from running the agent
+      if (!getConfig().auth_token) {
+        chatHistory.addMessage({ role: 'system', content: '✗ Not logged in. Run /login first.', isError: true });
+        return;
+      }
+
+      // Normal message → run agent
+      inputField.setDisabled(true);
+      chatHistory.addMessage({ role: 'user', content: text });
+      statusBar.update('thinking', 'Thinking...');
+      await createChatIfNeeded(text);
       messages.push({ role: 'user', content: text });
-      console.log(`  ${FG_DARK}${'─'.repeat(Math.min(cols, 70) - 4)}${RST}`);
 
-      isRunningAgent = true;
-      messages = await runAgentLoop(messages, currentModel);
-      isRunningAgent = false;
+      // Per-turn state: buffer tokens until we know if the model is in an implicit
+      // think block (Qwen3-style: plain text followed by </think>, no opening tag).
+      let implicitThinkPhase = !opts.showThink;
+      let implicitThinkBuffer = '';
+
+      const callbacks = {
+        onThinking: () => statusBar.update('thinking', 'Thinking...'),
+        onRequestSent: () => {
+          statusBar.update('thinking', 'Thinking...');
+          // Reset think-phase detection for each new agent iteration.
+          implicitThinkPhase = !opts.showThink;
+          implicitThinkBuffer = '';
+        },
+        onStreamStart: () => {
+          // If showThink is on, switch to streaming immediately.
+          // Otherwise keep "Thinking…" until </think> is resolved.
+          if (opts.showThink) statusBar.update('streaming', 'Streaming response');
+        },
+        onTagOpen: (tag, attrs) => {
+          const entry = TAG_REGISTRY[tag];
+          if (entry?.type === 'tool') {
+            const actionLabel = entry.label || tag;
+            const detail = attrs.path || attrs.url || attrs.key || attrs.src || '';
+            statusBar.update('tool', `${actionLabel}${detail ? ': ' + detail : ''}`);
+            if (!opts.showThink) chatHistory.clearStreamingContent();
+          }
+          if (entry?.display === 'think_bubble') {
+            statusBar.update('thinking', 'Reasoning...');
+          }
+        },
+        onThinkEnd: (content) => {
+          chatHistory.addMessage({ role: 'think', content });
+          statusBar.update('streaming', 'Streaming response');
+        },
+        onToolStart: (tag, input, attrs) => {
+          const actionLabel = TAG_REGISTRY[tag]?.label || tag;
+          const short = input.length > 40 ? input.slice(0, 40) + '…' : input;
+          statusBar.update('tool', `${actionLabel}: ${short}`);
+        },
+        onToolEnd: (tag, result, durationMs) => {
+          const isError = typeof result === 'string' && result.startsWith('Error');
+          if (isError) {
+            finalizeHttpFetch();
+            chatHistory.addMessage({
+              role: 'tool',
+              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();
+            }
+          } else {
+            const actionLabel = TAG_REGISTRY[tag]?.label || tag;
+            statusBar.update('tool', `✓ ${actionLabel} [${durationMs}ms]`);
+          }
+        },
+        onToken: (token) => {
+          if (!opts.showThink && implicitThinkPhase) {
+            // Check if this token is the closing think tag (Qwen3-style implicit think).
+            if (/^<\/(think|reasoning|reflection)>$/i.test(token.trim())) {
+              // Thinking phase is over — discard buffered reasoning, start streaming.
+              implicitThinkPhase = false;
+              implicitThinkBuffer = '';
+              statusBar.update('streaming', 'Streaming response');
+              return;
+            }
+            // Buffer the token; keep the thinking animation visible.
+            implicitThinkBuffer += token;
+            return;
+          }
+          chatHistory.streamToken(token);
+          statusBar.onToken();
+        },
+        onAssistantMessage: (cleanContent) => {
+          // If </think> was never seen, the model had no implicit think block —
+          // flush whatever was buffered as normal streaming content.
+          if (implicitThinkPhase && implicitThinkBuffer) {
+            implicitThinkPhase = false;
+            implicitThinkBuffer = '';
+          }
+          chatHistory.finalizeLastMessage(cleanContent);
+        },
+        onMetricsUpdate: (data) => statusBar.updateMetrics(data),
+        onRetry: (attempt, max) => {
+          statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
+        },
+        onError: (err) => {
+          if (err && err.isWarning) {
+            chatHistory.addMessage({ role: 'system', content: err.message || String(err) });
+          } else {
+            const msg = (err && err.message) || String(err);
+            statusBar.update('error', msg);
+            chatHistory.addMessage({ role: 'system', content: `✗ ${msg}`, isError: true });
+          }
+        },
+      };
+
+      let _agentAborted = false;
+      const _onAbort = () => {
+        if (!_agentAborted) {
+          _agentAborted = true;
+          chatHistory.addMessage({ role: 'system', content: '⏹ Interrupted.' });
+        }
+      };
+      inputField.on('abort', _onAbort);
 
-      console.log(`  ${FG_DARK}${'━'.repeat(Math.min(cols, 70) - 4)}${RST}`);
-      console.log();
+      try {
+        const agentResult = await runAgentLoop(messages, currentModel, undefined, resolvedTokenLimit, {
+          showThink: opts.showThink || false,
+          debug: opts.debug || false,
+          callbacks,
+          systemPrompt: resolvedSystemPrompt,
+          systemPromptMode: getConfig().system_prompt_mode || 'system_role',
+          getAbortFlag: () => _agentAborted,
+        });
+        messages = agentResult.messages;
+        sessionMetrics = agentResult.metrics;
+      } catch (err) {
+        statusBar.update('error', err.message || 'Agent error');
+        chatHistory.addMessage({ role: 'system', content: err.message || 'Agent error', isError: true });
+      } finally {
+        inputField.removeListener('abort', _onAbort);
+      }
+
+      statusBar.update('idle');
+      inputField.setDisabled(false);
+      await saveTurnToDashboard();
+      saveSession();
+    });
+
+    // Wait until user exits
+    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 cmdCode(opts, promptArgs) {
-    if (!promptArgs.length) {
-      console.log(`  ${FG_RED}Usage: semalt-code code <prompt>${RST}`);
+  async function _loginFlow(chatHistory, statusBar) {
+    let loginRequest;
+    try { loginRequest = await requestCliLogin(); }
+    catch (err) {
+      chatHistory.addMessage({ role: 'system', content: `✗ Login failed: ${err.message}`, isError: true });
       return;
     }
+    chatHistory.addMessage({ role: 'system', content: `Open this URL to authorize:\n  ${loginRequest.verification_url}\n\nWaiting for confirmation...` });
+    statusBar.update('waiting', 'Waiting for browser auth...');
+    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) { chatHistory.addMessage({ role: 'system', content: '✗ Login token is no longer valid.', isError: true }); return; }
+        continue;
+      }
+      if (status.status === 'authorized') {
+        const config = getConfig();
+        setConfig({ ...config, dashboard_url: config.dashboard_url, auth_token: loginRequest.token });
+        chatHistory.addMessage({ role: 'system', content: `✓ CLI token saved to ${CONFIG_PATH}` });
+        return;
+      }
+      if (status.status === 'expired') {
+        chatHistory.addMessage({ role: 'system', content: '✗ Login token expired. Run /login again.', isError: true });
+        return;
+      }
+    }
+    chatHistory.addMessage({ role: 'system', content: '⚠ Login timed out.' });
+  }
 
+  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; }
+    const model = opts.model || getConfig().default_model;
     const userPrompt = promptArgs.join(' ');
-    const context = opts.file ? readFileContext(opts.file, ui) : '';
+    const context = opts.file ? readFileContext(opts.file) : '';
     const fullPrompt = context ? `Context files:\n${context}\n\nTask: ${userPrompt}` : userPrompt;
-
-    let messages = [
-      { role: 'system', content: getSystemPrompt() },
-      { role: 'user', content: fullPrompt },
-    ];
-    messages = await runAgentLoop(messages, opts.model || getConfig().default_model);
+    let resolvedSystemPrompt = null;
+    if (opts.systemPromptFile) {
+      try { resolvedSystemPrompt = fs.readFileSync(opts.systemPromptFile, 'utf8'); } catch {}
+    }
+    let messages = [{ role: 'user', content: fullPrompt }];
+    const statusBar = new StatusBar();
+    statusBar.update({ model, status: 'thinking' });
+    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());
+    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 (!fs.existsSync(filePath)) {
-      console.log(`  ${FG_RED}✗ File not found: ${filePath}${RST}`);
-      return;
-    }
-
+    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; }
     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' });
     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');
-      }
+      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}`);
     } else if (opts.dryRun) {
@@ -258,23 +1032,21 @@ function createCommands({
 
   async function cmdShell(opts, commandArgs) {
     const command = commandArgs.join(' ');
-    if (!command) {
-      console.log(`  ${FG_RED}Usage: semalt-code shell <command>${RST}`);
-      return;
-    }
-
+    if (!command) { console.log(`  ${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; }
       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();
+      console.log(); console.log(`  ${FG_TEAL}${BOLD}◆ Semalt.AI${RST}`); console.log();
       process.stdout.write('  ');
-      await chatStream(messages, { model: opts.model });
+      try {
+        await chatStream(messages, { model: opts.model });
+      } catch (err) {
+        console.log(`\n  ${FG_RED}✗ ${err.message}${RST}`);
+      }
       console.log();
     }
   }
@@ -282,109 +1054,32 @@ function createCommands({
   async function cmdModels() {
     const config = getConfig();
     let response;
-    try {
-      response = await dashboardListModels();
-    } catch (error) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
-      return config.default_model;
-    }
-
+    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 }; }
     const models = Array.isArray(response && response.models) ? response.models : [];
-    if (!models.length) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}No models found in your dashboard account.${RST}\n`);
-      return config.default_model;
-    }
-
-    console.log();
-    console.log(`  ${FG_TEAL}${BOLD}◆ Your Models${RST}`);
-    console.log(`  ${FG_DARK}${'─'.repeat(60)}${RST}`);
-    models.forEach((model, index) => {
+    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}`);
+    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;
       const marker = active ? `${FG_GREEN}●${RST}` : `${FG_DARK}○${RST}`;
-      console.log(`  ${marker} ${FG_CYAN}${index + 1}.${RST} ${FG_GRAY}${model.name} · ${model.model_id} @ ${model.base_url}${RST}`);
-    });
-    console.log();
-
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: true,
-    });
-
-    const selectedIndex = await new Promise((resolve) => {
-      rl.question(`  ${FG_TEAL}${BOLD}Select model>${RST} `, (answer) => {
-        rl.close();
-        resolve(Number((answer || '').trim()));
-      });
-    });
-
-    if (!Number.isInteger(selectedIndex) || selectedIndex < 1 || selectedIndex > models.length) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Invalid selection${RST}\n`);
-      return config.default_model;
-    }
-
-    const selectedModel = models[selectedIndex - 1];
+      const cursor = isSelected ? `${FG_TEAL}❯${RST}` : ' ';
+      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 }; }
+    const selectedModel = models[selectedIndex];
     let credentialsResponse;
-    try {
-      credentialsResponse = await dashboardGetModelForCli(selectedModel.id);
-    } catch (error) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
-      return config.default_model;
-    }
-
+    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 }; }
     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 config.default_model;
-    }
-
-    setConfig({
-      ...config,
-      api_base: model.base_url,
-      api_key: model.api_key,
-      default_model: model.model_id,
-    });
+    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 }; }
+    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`);
-    return model.model_id;
-  }
-
-  async function cmdModelsAdd() {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: true,
-    });
-
-    function ask(question) {
-      return new Promise((resolve) => {
-        rl.question(question, (answer) => resolve((answer || '').trim()));
-      });
-    }
-
-    console.log();
-    console.log(`  ${FG_TEAL}${BOLD}◆ Add Model Profile${RST}`);
-    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
-
-    const apiBase = await ask(`  ${FG_CYAN}API Base URL:${RST} `);
-    const apiKey = await ask(`  ${FG_CYAN}API Key:${RST} `);
-    const modelId = await ask(`  ${FG_CYAN}Model ID:${RST} `);
-    rl.close();
-
-    if (!apiBase || !modelId) {
-      console.log(`\n  ${FG_RED}✗${RST} ${FG_GRAY}API Base URL and Model ID are required.${RST}\n`);
-      return;
-    }
-
-    const config = getConfig();
-    const profile = {
-      api_base: apiBase,
-      api_key: apiKey || 'any',
-      model: modelId,
-    };
-
-    config.models.push(profile);
-    setActiveModelProfile(profile);
-    console.log(`\n  ${FG_GREEN}✓${RST} Saved model profile: ${describeModelProfile(profile)}\n`);
+    return { model: model.model_id, dbId: model.id };
   }
 
   function cmdInit(opts) {
@@ -406,108 +1101,66 @@ function createCommands({
   }
 
   async function cmdLogin() {
-    console.log();
-    console.log(`  ${FG_TEAL}${BOLD}◆ CLI Login${RST}`);
-    console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
-
+    console.log(); console.log(`  ${FG_TEAL}${BOLD}◆ CLI Login${RST}`); console.log(`  ${FG_DARK}${'─'.repeat(40)}${RST}`);
     let loginRequest;
-    try {
-      loginRequest = await requestCliLogin();
-    } catch (error) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Unable to start login via ${getConfig().dashboard_url}: ${error.message}${RST}\n`);
-      return;
-    }
-
+    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}`);
-
     const startedAt = Date.now();
     while (Date.now() - startedAt < LOGIN_TIMEOUT_MS) {
-      await new Promise((resolve) => setTimeout(resolve, LOGIN_POLL_INTERVAL_MS));
-
+      await new Promise((r) => setTimeout(r, LOGIN_POLL_INTERVAL_MS));
       let status;
-      try {
-        status = await getCliLoginStatus(loginRequest.id, loginRequest.hash);
-      } catch (error) {
-        if (error.statusCode === 404 || error.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. Run semalt login again.${RST}\n`);
-        return;
-      }
+      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; }
     }
-
-    console.log(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out. The URL may still work for a short time.${RST}\n`);
+    console.log(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out.${RST}\n`);
   }
 
   async function cmdWhoAmI() {
     let response;
-    try {
-      response = await dashboardWhoAmI();
-    } catch (error) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
-      return;
-    }
-
+    try { response = await dashboardWhoAmI(); } catch (err) { console.log(`  ${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));
-    }
+    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();
   }
 
   async function cmdLogout() {
     const config = getConfig();
-    if (!config.auth_token) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not logged in. Run semalt login first.${RST}\n`);
-      return;
-    }
-
-    try {
-      await dashboardLogout();
-    } catch (error) {
-      if (error.statusCode !== 401) {
-        console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${error.message}${RST}\n`);
-        return;
-      }
-    }
-
-    setConfig({
-      ...config,
-      auth_token: '',
-    });
+    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; } }
+    setConfig({ ...config, auth_token: '' });
     console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Logged out and cleared local CLI token.${RST}\n`);
   }
 
+  function printDryRunSummary() {
+    const ops = getSkippedOps();
+    const files = ops.filter((o) => o.category === 'file');
+    const cmds = ops.filter((o) => o.category === 'cmd');
+    const nets = ops.filter((o) => o.category === 'net');
+    const BOX_W = 40, INNER = BOX_W - 2;
+    const isTTY = process.stdout.isTTY;
+    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();
+  }
+
   return {
     cmdChat,
     cmdCode,
@@ -515,7 +1168,6 @@ function createCommands({
     cmdInit,
     cmdLogin,
     cmdModels,
-    cmdModelsAdd,
     cmdShell,
     cmdLogout,
     cmdWhoAmI,