@semalt-ai/code 1.8.5 → 1.20.0

package/lib/commands/auth.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// Authentication / account CLI commands, extracted from lib/commands.js in
+// Task 1.5. `shared` is the dependency bag built by createCommands; it is
+// destructured once here so the command bodies below are unchanged.
+
+function createAuthCommands(shared) {
+  const {
+    writer, getConfig, setConfig,
+    requestCliLogin, getCliLoginStatus, dashboardWhoAmI, dashboardLogout,
+    formatUserLine, keychainSet, ENV_VAR, CONFIG_PATH,
+    LOGIN_POLL_INTERVAL_MS, LOGIN_TIMEOUT_MS,
+    FG_RED, FG_GRAY, FG_TEAL, FG_DARK, FG_GREEN, FG_CYAN, FG_YELLOW, BOLD, RST,
+  } = shared;
+
+  async function cmdLogin() {
+    writer.scrollback(`\n  ${FG_TEAL}${BOLD}◆ CLI Login${RST}\n  ${FG_DARK}${'─'.repeat(40)}${RST}`);
+    let loginRequest;
+    try { loginRequest = await requestCliLogin(); }
+    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) { 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; }
+    }
+    writer.scrollback(`  ${FG_YELLOW}⚠${RST} ${FG_GRAY}Login timed out.${RST}\n`);
+  }
+
+  async function cmdWhoAmI() {
+    let response;
+    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) { 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) { 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: '' });
+    writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Logged out and cleared local CLI token.${RST}\n`);
+  }
+
+  // `semalt-code auth set-key [key]` — store the API key in the OS keychain so
+  // it is no longer kept in plaintext in config.json. If [key] is omitted, read
+  // it from stdin (so it does not land in shell history / the process table).
+  async function cmdAuthSetKey(keyArg) {
+    let key = typeof keyArg === 'string' ? keyArg.trim() : '';
+    if (!key) {
+      if (process.stdin.isTTY) {
+        process.stdout.write(`  ${FG_GRAY}Paste API key (input hidden is not available; press Enter when done):${RST}\n  > `);
+      }
+      key = await new Promise((resolve) => {
+        let buf = '';
+        const onData = (d) => { buf += d; if (buf.includes('\n')) { process.stdin.pause(); process.stdin.off('data', onData); resolve(buf.split('\n')[0]); } };
+        try { process.stdin.resume(); process.stdin.setEncoding('utf8'); process.stdin.on('data', onData); } catch { resolve(''); }
+      });
+      key = (key || '').trim();
+    }
+    if (!key) {
+      writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}No key provided.${RST}\n`);
+      return;
+    }
+    const ok = keychainSet(key);
+    if (ok) {
+      writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_GRAY}API key stored in the OS keychain. It will be used automatically (env var still takes precedence).${RST}\n`);
+      writer.scrollback(`  ${FG_DARK}It is NOT written to config.json. Verify with 'semalt-code config' → api_key_source: keychain.${RST}\n`);
+    } else {
+      writer.scrollback(`  ${FG_RED}✗${RST} ${FG_GRAY}Could not store the key in the OS keychain (native tool missing or unavailable on this platform).${RST}\n`);
+      writer.scrollback(`  ${FG_DARK}Alternative: set the ${ENV_VAR} environment variable instead.${RST}\n`);
+    }
+  }
+
+  return { cmdLogin, cmdWhoAmI, cmdLogout, cmdAuthSetKey };
+}
+
+module.exports = { createAuthCommands };

package/lib/commands/chat-session.js

@@ -0,0 +1,489 @@
+'use strict';
+
+// Chat session/state management extracted from cmdChat in Task 1.5: local- and
+// dashboard-history sync plus the in-chat picker (history / chats / models).
+// Bodies are unchanged except that mutable session fields are read/written
+// through ctx (the getter/setter hub built in cmdChat) instead of as closure
+// locals; stable collaborators are destructured from ctx once below. The
+// functions call each other by bare name (same module scope); other chat
+// modules reach them via ctx, onto which createCommands' cmdChat assigns them.
+
+function createChatSession(ctx) {
+  const {
+    storage, inputField, chatHistory, statusBar, writer, msgs,
+    getConfig, setConfig, getCols, approxTokens, PAGE_SIZE, sessionStart,
+    dashboardCreateChat, dashboardSaveMessages, dashboardGetChat, dashboardGetModelForCli,
+    cleanOrphanedToolMessages, reconstructLoadedMessage, resolveTokenLimit,
+    FG_GRAY, RST,
+  } = ctx;
+
+  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);
+  }
+
+  function saveSession() {
+    ctx.session.model = ctx.currentModel;
+    ctx.session.messages = ctx.messages;
+    ctx.session.stats.duration_sec = Math.round((Date.now() - sessionStart) / 1000);
+    ctx.session.stats.total_tokens = ctx.messages.reduce((s, m) => s + Math.round((m.content || '').length / 4), 0);
+    try { storage.save(ctx.session); } catch {}
+  }
+
+  async function createChatIfNeeded(firstUserText) {
+    const config = getConfig();
+    if (ctx.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) ctx.currentChatId = resp.chat.id;
+    } catch (err) {
+      // Surface (don't swallow) a creation failure: a silent failure here leaves
+      // currentChatId null, so saveTurnToDashboard early-returns with no warning —
+      // quiet data loss. Non-fatal to the turn; the local session save still runs.
+      msgs.sysWarn(`could not create dashboard chat: ${err && err.message ? err.message : String(err)}`);
+    }
+  }
+
+  async function saveTurnToDashboard() {
+    if (ctx.currentChatId === null) return;
+    const newMessages = ctx.messages.slice(ctx.savedUpTo).filter((m) => m.role !== 'system');
+    if (!newMessages.length) return;
+    try {
+      const resp = await dashboardSaveMessages(ctx.currentChatId, newMessages);
+      ctx.savedUpTo = ctx.messages.length;
+      if (resp && typeof resp.skipped_count === 'number' && resp.skipped_count > 0) {
+        msgs.sysWarn(`history save: ${resp.skipped_count} message(s) skipped by server`);
+      }
+    } catch (err) {
+      // A 404 means the chat id is stale for the CURRENT token — the chat belongs
+      // to another principal (relogin) or was deleted on the dashboard. Self-heal
+      // ONCE per turn: recreate a fresh chat under the current token and re-save
+      // the SAME pending slice. Scoped strictly to 404 — a transient network/5xx
+      // must NOT recreate the chat (that would spawn duplicates); leave savedUpTo
+      // unadvanced so a later turn retries the same slice naturally.
+      if (err && err.statusCode === 404) {
+        ctx.currentChatId = null;
+        const firstUser = ctx.messages.find((m) => m.role === 'user');
+        const title = firstUser && typeof firstUser.content === 'string' && firstUser.content
+          ? firstUser.content : 'Untitled chat';
+        await createChatIfNeeded(title);   // warns on its own failure (see above)
+        if (ctx.currentChatId === null) return;  // recreation failed; already warned
+        try {
+          const resp = await dashboardSaveMessages(ctx.currentChatId, newMessages);
+          ctx.savedUpTo = ctx.messages.length;   // advance ONLY after re-save succeeds
+          if (resp && typeof resp.skipped_count === 'number' && resp.skipped_count > 0) {
+            msgs.sysWarn(`history save: ${resp.skipped_count} message(s) skipped by server`);
+          }
+        } catch (err2) {
+          msgs.sysWarn(`history save failed: ${err2 && err2.message ? err2.message : String(err2)}`);
+        }
+        return;
+      }
+      msgs.sysWarn(`history save failed: ${err && err.message ? err.message : String(err)}`);
+    }
+  }
+
+  function displayLoadedMessages(loadedMessages) {
+    chatHistory.clearMessages();
+    const cfg = getConfig() || {};
+    const { descriptorFromStored } = require('../ui/tool-operation');
+    const { isWebCore, aggregateWebOps, formatWebSummaryLine } = require('../ui/web-activity');
+    const {
+      isGroupableFileCore, fileSummaryState, formatFileSummaryLine,
+    } = require('../ui/file-activity');
+
+    // Phase 6c-ii — replayed web activity renders as the aggregated `✓ web · …`
+    // committed summary, byte-identical to the live committed line. A web GROUP
+    // is a maximal consecutive run of web ops, so the buffer is LOOP-LEVEL (not
+    // blob-/message-local): a group spans iterations, and those iterations live
+    // in separate {role:'tool'} messages (native rail) or separate
+    // {role:'user'} feedback blobs (XML rail). The live flush triggers
+    // (chat-turn.js) are mirrored below: a non-web tool starting, a terminal
+    // assistant message with content, and turn end (the trailing flushWeb()).
+    // flushWeb() calls ONLY the pure aggregateWebOps/formatWebSummaryLine — it
+    // never instantiates createWebActivityTracker or touches the live region.
+    let webBuf = [];
+    function flushWeb() {
+      if (!webBuf.length) return;
+      const line = formatWebSummaryLine(aggregateWebOps(webBuf), { pending: false });
+      chatHistory.addRawLine(line);
+      webBuf = [];
+    }
+
+    // Parallel re-grouping for consecutive file ops (read_file/list_dir),
+    // mirroring flushWeb but with the live tracker's THRESHOLD applied at the
+    // REPLAY terminal width: a buffered run of ≥3 commits one aggregated summary
+    // (formatFileSummaryLine reads getCols() at flush, so a 200-col session
+    // re-groups correctly in an 80-col terminal); a run of 1–2 commits each op as
+    // its own per-op line via the SAME `_display` render the live path uses —
+    // byte-identical to a fresh per-op commit. read_file and list_dir share ONE
+    // group (mirroring the live merged key): a mixed run re-groups into the same
+    // single summary, with fileSummaryState picking the homogeneous-vs-mixed verb.
+    let fileBuf = [];   // [{ core, ts }]
+    function flushFile() {
+      if (!fileBuf.length) return;
+      const buf = fileBuf;
+      fileBuf = [];
+      if (buf.length >= 3) {
+        const line = formatFileSummaryLine(fileSummaryState(buf.map((e) => e.core)), { pending: false });
+        chatHistory.addRawLine(line);
+      } else {
+        for (const { core, ts } of buf) {
+          chatHistory.addMessage({
+            role: 'tool', tag: 'tool', content: '', ts,
+            _display: core,
+            diffMaxLines: cfg.diff_max_lines,
+            previewLines: cfg.shell_preview_lines || 5,
+          });
+        }
+      }
+    }
+    // pushFile is only reached for groupable file cores (the caller gates on
+    // isGroupableFileCore), and read_file + list_dir now share one group, so every
+    // buffered op belongs to the same run — no key split. A non-groupable op
+    // flushes the buffer via the flushFile() calls on the other branches.
+    function pushFile(core, ts) {
+      fileBuf.push({ core, ts });
+    }
+
+    // A message that carries tool activity for an in-flight iteration: a native
+    // {role:'tool'} result, or an XML {role:'user'} feedback blob. The replay
+    // analogue of "an assistant iteration had tool calls" (live: cleanContent==='')
+    // is "the assistant is immediately followed by tool activity" — rail-agnostic,
+    // and independent of whether `tool_calls` survived the storage round-trip.
+    const isToolActivity = (msg) => !!msg && (
+      msg.role === 'tool' ||
+      (msg.role === 'user' && typeof msg.content === 'string' && msg.content.startsWith('Tool execution results:'))
+    );
+
+    const relevant = loadedMessages.filter(
+      (m) => m.role === 'user' || m.role === 'assistant' || m.role === 'tool',
+    );
+
+    for (let ri = 0; ri < relevant.length; ri++) {
+      const m = relevant[ri];
+      const raw = typeof m.content === 'string' ? m.content : '';
+      const ts = m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date());
+
+      if (m.role === 'tool') {
+        // Phase 6c-ii — a native web op persists a {v:1,kind:'web',…} core in
+        // `_display`. Buffer it into the current web group (no per-op line) and
+        // continue; the aggregated summary commits when the group flushes. A
+        // non-web tool first ENDS any open web run so its summary lands ABOVE this
+        // line (mirrors chat-turn.js:222), then renders via the 6a path.
+        if (isWebCore(m._display)) { flushFile(); webBuf.push(m._display); continue; }
+        // A groupable file core (read_file/list_dir) buffers into the file group
+        // (flushing any open web run first so its summary lands above); the
+        // aggregated/per-op commit happens when the file group flushes.
+        if (isGroupableFileCore(m._display)) { flushWeb(); pushFile(m._display, ts); continue; }
+        flushWeb(); flushFile();
+        // Phase 6a — forward the persisted display descriptor (native rail) so
+        // chat-history can replay it with full fidelity. `_display` absent →
+        // legacy summarizeToolResult fallback. The budgets match the live path
+        // (diff_max_lines for an edit diff; shell_preview_lines for an output
+        // preview) so a replayed line is byte-identical to a fresh render.
+        chatHistory.addMessage({
+          role: 'tool', tag: 'tool', content: raw, ts,
+          _display: m._display,
+          diffMaxLines: cfg.diff_max_lines,
+          previewLines: cfg.shell_preview_lines || 5,
+        });
+        continue;
+      }
+
+      if (m.role === 'user' && raw.startsWith('Tool execution results:')) {
+        // Phase 6b — XML rail per-call replay parity. The feedback blob folds all
+        // tool results of a turn into one {role:'user'} message; it cannot be
+        // split back by parsing (the \n\n separator appears freely inside result
+        // bodies). When the persisted aligned `_display[]` array is present AND
+        // EVERY slot is a valid core — a normal descriptor core OR (Phase 6c-ii)
+        // a web-op core — replay each in order. The gate stays fail-safe: a single
+        // `null` slot or an unknown core drops the WHOLE blob to the legacy
+        // whole-blob summary below (no partial render), so a web op's activity
+        // never silently vanishes on replay.
+        const displays = Array.isArray(m._display) ? m._display : null;
+        // Phase 6c-ii — flip the 6c-i gate: a web-op core ({v:1,kind:'web',…}) is
+        // now a VALID slot (it aggregates into the web summary) instead of failing
+        // the gate. Normal slots must still pass descriptorFromStored; web slots
+        // must be v:1 web-cores. Any other slot (null / unknown) still fails.
+        if (displays && displays.length > 0 && displays.every(
+          (el) => el && ((isWebCore(el) && el.v === 1) || (!isWebCore(el) && descriptorFromStored(el))),
+        )) {
+          for (const el of displays) {
+            // A web slot buffers into the open web group; a groupable file slot
+            // buffers into the file group; a normal slot first flushes any
+            // preceding grouped run (mirrors a non-grouped tool starting), then
+            // renders.
+            if (isWebCore(el)) { flushFile(); webBuf.push(el); continue; }
+            if (isGroupableFileCore(el)) { flushWeb(); pushFile(el, ts); continue; }
+            flushWeb(); flushFile();
+            chatHistory.addMessage({
+              role: 'tool', tag: 'tool', content: '', ts,
+              _display: el,
+              diffMaxLines: cfg.diff_max_lines,
+              previewLines: cfg.shell_preview_lines || 5,
+            });
+          }
+          continue;
+        }
+        // Gate failed — a preceding grouped run (if any) ends here, then the legacy
+        // whole-blob summary renders (6b/6c-i fail-safe preserved).
+        flushWeb(); flushFile();
+        const body = raw
+          .replace(/^Tool execution results[^\n]*\n+/, '')
+          .replace(/\n+Continue with the task\.[\s\S]*$/, '')
+          .trim();
+        chatHistory.addMessage({ role: 'tool', tag: 'tool', content: body || raw, ts });
+        continue;
+      }
+
+      // Plain user / assistant message. Empty-content messages never flush (an
+      // intermediate, tool-call-only assistant message between two web iterations
+      // carries empty display content — flushing there would split a cross-
+      // iteration group into two summaries) and are not rendered.
+      if (!raw.trim()) continue;
+      if (m.role === 'assistant') {
+        // Flush ONLY on a TERMINAL assistant message — one not immediately
+        // followed by tool activity (the replay analogue of live cleanContent!==''
+        // at chat-turn.js:389-391). An intermediate assistant with content is
+        // still rendered, but does NOT flush, so the open web group survives.
+        if (!isToolActivity(relevant[ri + 1])) { flushWeb(); flushFile(); }
+      } else {
+        // A plain user message starts a NEW turn — close any grouped run left open
+        // by the prior turn (the live per-turn `finally` flush, chat-turn.js).
+        flushWeb(); flushFile();
+      }
+      chatHistory.addMessage({ role: m.role, content: raw, ts });
+    }
+
+    // Turn-end safety net: a trailing grouped run (turn ended/was interrupted
+    // right after a web or file op, with no terminal assistant) commits here —
+    // mirrors the live per-turn `finally` flush in chat-turn.js.
+    flushWeb();
+    flushFile();
+  }
+
+  function seedContextFromMessages() {
+    let total = 0;
+    for (const m of ctx.messages) {
+      if (typeof m.content === 'string') total += approxTokens(m.content);
+    }
+    statusBar.updateMetrics({ contextTokens: total });
+  }
+
+  function emitCleanupWarning(cleanup) {
+    if (cleanup.droppedTool === 0 && cleanup.droppedAssistantCalls === 0 && cleanup.droppedAssistantMsgs === 0) return;
+    const parts = [];
+    if (cleanup.droppedTool > 0) parts.push(`${cleanup.droppedTool} orphaned tool result(s)`);
+    if (cleanup.droppedAssistantCalls > 0) parts.push(`${cleanup.droppedAssistantCalls} dangling tool_call(s)`);
+    if (cleanup.droppedAssistantMsgs > 0) parts.push(`${cleanup.droppedAssistantMsgs} empty assistant message(s)`);
+    chatHistory.addMessage({
+      role: 'system',
+      content: `⚠ Loaded chat had ${parts.join(', ')}, cleaned up. The chat may be missing some context.`,
+    });
+  }
+
+  // ── In-chat picker (history / chats / models) ────────────────────────────
+
+  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 (!ctx.pendingAction) return '';
+    const { type, items, displayItems: di, stepIdx, searchQuery } = ctx.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) {
+    // 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 (!ctx.pendingAction) return;
+    const lines = buildListContent().split('\n');
+    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() {
+    writer.clearModal();
+  }
+
+  function activateNavCapture() {
+    inputField.captureNavigation(async (action) => {
+      if (!ctx.pendingAction) { inputField.releaseNavigation(); return; }
+      const { items, displayItems: di, stepIdx } = ctx.pendingAction;
+      const activeItems = di || items;
+
+      if (action.startsWith('search:')) {
+        const query = action.slice(7);
+        if (!query) {
+          ctx.pendingAction = { ...ctx.pendingAction, displayItems: null, searchQuery: '', stepIdx: 0 };
+        } else {
+          const filtered = items.filter(item => getNavSearchText(ctx.pendingAction.type, item).toLowerCase().includes(query.toLowerCase()));
+          ctx.pendingAction = { ...ctx.pendingAction, displayItems: filtered, searchQuery: query, stepIdx: 0 };
+        }
+        showPendingStep();
+        return;
+      }
+
+      if (action === 'next') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: activeItems.length ? (stepIdx + 1) % activeItems.length : 0 };
+        showPendingStep();
+      } else if (action === 'prev') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: activeItems.length ? (stepIdx - 1 + activeItems.length) % activeItems.length : 0 };
+        showPendingStep();
+      } else if (action === 'select') {
+        if (!activeItems.length) return;
+        inputField.releaseNavigation();
+        const si = ctx.pendingAction.stepIdx;
+        collapseListMsg(ctx.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.' });
+        ctx.pendingAction = null;
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+      }
+    });
+  }
+
+  async function handlePendingSelection(idx) {
+    if (!ctx.pendingAction) return;
+    const { type, items, displayItems: di } = ctx.pendingAction;
+    const activeItems = di || items;
+    ctx.pendingAction = null;
+
+    if (type === 'history') {
+      const loaded = storage.load(activeItems[idx].id);
+      if (loaded) {
+        const filtered = (loaded.messages || []).filter((m) => m.role !== 'system');
+        const cleanup = cleanOrphanedToolMessages(filtered);
+        ctx.messages = cleanup.messages;
+        ctx.session = { id: loaded.id, created_at: loaded.created_at, model: loaded.model, messages: ctx.messages, stats: loaded.stats || { total_tokens: 0, duration_sec: 0 } };
+        ctx.currentChatId = null; ctx.savedUpTo = 0;
+        if (loaded.model && loaded.model !== ctx.currentModel) {
+          ctx.currentModel = loaded.model;
+          ctx.resolvedTokenLimit = await resolveTokenLimit(ctx.currentModel);
+          statusBar.setModel(ctx.currentModel);
+          statusBar.setContextLimit(ctx.resolvedTokenLimit);
+        }
+        displayLoadedMessages(ctx.messages);
+        chatHistory.addMessage({ role: 'system', content: `✓ Session loaded.  Model → ${ctx.currentModel}` });
+        emitCleanupWarning(cleanup);
+        seedContextFromMessages();
+      }
+    } else if (type === 'chats') {
+      const selectedChat = activeItems[idx];
+      try {
+        const chatData = await dashboardGetChat(selectedChat.id);
+        const loaded = chatData && chatData.messages ? chatData.messages : [];
+        const reconstructed = loaded.map(reconstructLoadedMessage);
+        const cleanup = cleanOrphanedToolMessages(reconstructed);
+        ctx.messages = cleanup.messages;
+        ctx.currentChatId = selectedChat.id; ctx.savedUpTo = ctx.messages.length;
+        displayLoadedMessages(loaded);
+        chatHistory.addMessage({ role: 'system', content: `✓ Resumed: ${selectedChat.title} (${loaded.length} messages)` });
+        emitCleanupWarning(cleanup);
+        seedContextFromMessages();
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+      }
+    } 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);
+        ctx.currentModel = model.model_id;
+        ctx.resolvedTokenLimit = await resolveTokenLimit(ctx.currentModel);
+        statusBar.setModel(ctx.currentModel);
+        statusBar.setContextLimit(ctx.resolvedTokenLimit);
+        ctx.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 });
+      }
+    }
+  }
+
+  return {
+    refreshInputSearchItems, saveSession, createChatIfNeeded, saveTurnToDashboard,
+    displayLoadedMessages, seedContextFromMessages, emitCleanupWarning,
+    getNavSearchText, buildItemDetail, buildListContent, collapseListMsg,
+    showPendingStep, finalizeListMsg, activateNavCapture, handlePendingSelection,
+  };
+}
+
+module.exports = { createChatSession };