@semalt-ai/code 1.8.0 → 1.8.3

package/lib/commands.js

@@ -4,9 +4,10 @@ const fs = require('fs');
 
 const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS, TAG_REGISTRY } = require('./constants');
 const { configShow } = require('./config');
-const { SYSTEM_PROMPT } = require('./prompts');
+const { getSystemPrompt } = require('./prompts');
 const { SessionStorage } = require('./storage');
 const { getSkippedOps, setUIActive } = require('./tools');
+const { AUDIT_LOG } = require('./audit');
 
 function formatTimeAgo(ts) {
   const diffMs = Date.now() - ts;
@@ -95,6 +96,7 @@ function createCommands({
       (m) => m.model === model || (m.api_base === config.api_base && m.model === config.default_model)
     );
     if (match && Number.isInteger(match.context_length) && match.context_length > 0) return match.context_length;
+    if (Number.isInteger(config.context_length) && config.context_length > 0) return config.context_length;
     return null;
   }
 
@@ -127,11 +129,21 @@ function createCommands({
 
     setUIActive(true);
 
+    const writer = require('./ui/writer');
     permissionManager.setUICallbacks({
       onAddMessage:      (msg)     => chatHistory.addMessage(msg),
       onRerenderMessage: (id)      => chatHistory.rerenderById(id),
       onCollapseMessage: (id)      => chatHistory.collapseById(id),
       onRemoveMessage:   (id)      => chatHistory.removeById(id),
+      // Modal-region API: setModal replaces the modal live band above the
+      // status region; clearModal drops it. Arrow-key redraws go through
+      // setModal only — no scrollback churn. When the picker resolves we
+      // clear the modal and push a single summary line to scrollback.
+      onShowModal: (lines) => writer.setModal(lines),
+      onCloseModal: (summary) => {
+        writer.clearModal();
+        if (summary) chatHistory.addMessage({ role: 'system', content: summary });
+      },
       onCaptureNavigation: (handler) => {
         inputField.captureNavigation(handler);
         return () => inputField.releaseNavigation();
@@ -150,6 +162,7 @@ function createCommands({
     let messages = [];
     let currentChatId = null;
     let savedUpTo = 0;
+    let debugMode = !!opts.debug;
 
     // Resolve system prompt override from --system-prompt file if provided
     let resolvedSystemPrompt = null;
@@ -185,14 +198,13 @@ function createCommands({
     }
     refreshInputSearchItems();
 
-    // Banner — write at row 1, then compact the layout so the fixed panels sit
-    // immediately below the banner with no blank gap.  The layout grows as
-    // messages are added (dynamic layout mode) until it reaches full-screen.
+    // Banner — emit once as scrollback above the live region. In the
+    // bottom-anchored live-region TUI, scrollback flows into terminal
+    // scrollback naturally, so no absolute positioning or scroll-region
+    // trickery is needed here.
     if (layout) {
-      const BANNER_LINES = 8; // blank + top-border + empty + title + desc + empty + bottom-border + blank
       const w = Math.min(getCols() - 4, 60);
-      process.stdout.write('\x1b[1;1H');
-      process.stdout.write([
+      const banner = [
         ``,
         `  ${FG_DARK}╭${'─'.repeat(w + 1)}╮${RST}`,
         boxLine('', w),
@@ -201,19 +213,8 @@ function createCommands({
         boxLine('', w),
         `  ${FG_DARK}╰${'─'.repeat(w + 1)}╯${RST}`,
         ``,
-      ].join('\n') + '\n');
-
-      // Keep historyStart = 1 so the banner is inside the scroll region.
-      // Growing mode uses _contentLines to position the first message below the
-      // banner (at row BANNER_LINES + 1).  When the terminal fills up the banner
-      // scrolls naturally into the terminal scrollback — nothing disappears behind
-      // a fixed header.
-      layout._contentLines = BANNER_LINES;
-      layout.rows = BANNER_LINES + 1 + layout.inputHeight + 3;
-
-      // Erase the stale full-screen panels createUI drew before we compacted.
-      process.stdout.write(`\x1b[${layout.rows + 1};1H\x1b[J`);
-
+      ].join('\n');
+      writer.scrollback(banner);
       redrawFixed();
     }
 
@@ -254,24 +255,29 @@ function createCommands({
       try { await dashboardSaveMessages(currentChatId, newMessages); savedUpTo = messages.length; } catch {}
     }
 
-    const HISTORY_DISPLAY_TURNS = 3; // user+assistant pairs to show on load
-
     function displayLoadedMessages(loadedMessages) {
       chatHistory.clearMessages();
-      const visible = loadedMessages.filter(
-        (m) => (m.role === 'user' || m.role === 'assistant') &&
-               (typeof m.content === 'string' ? m.content : '').trim()
-      );
-      const skip = Math.max(0, visible.length - HISTORY_DISPLAY_TURNS * 2);
-      if (skip > 0) {
-        chatHistory.addMessage({ role: 'system', content: `… ${skip} earlier messages not shown` });
-      }
-      for (const m of visible.slice(skip)) {
-        chatHistory.addMessage({
-          role: m.role,
-          content: typeof m.content === 'string' ? m.content : '',
-          ts: m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date()),
-        });
+      for (const m of loadedMessages) {
+        if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') continue;
+        const raw = typeof m.content === 'string' ? m.content : '';
+        const ts = m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date());
+
+        if (m.role === 'tool') {
+          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: 'tool result', output: raw, ts });
+          continue;
+        }
+
+        if (m.role === 'user' && raw.startsWith('Tool execution results:')) {
+          const body = raw
+            .replace(/^Tool execution results[^\n]*\n+/, '')
+            .replace(/\n+Continue with the task\.[\s\S]*$/, '')
+            .trim();
+          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: 'tool result', output: body || raw, ts });
+          continue;
+        }
+
+        if (!raw.trim()) continue;
+        chatHistory.addMessage({ role: m.role, content: raw, ts });
       }
     }
 
@@ -299,28 +305,6 @@ function createCommands({
     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);
@@ -576,6 +560,7 @@ function createCommands({
             '  /shell <cmd>    Run shell command',
             '  !<cmd>          Run shell command',
             '  /approve        Toggle auto-approve',
+            '  /debug [off]    Enable debug output + show last 5 audit entries',
             '  /config         Show config',
             '  exit            Quit',
           ].join('\n'),
@@ -737,7 +722,7 @@ function createCommands({
       }
 
       if (text === '/prompt') {
-        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : SYSTEM_PROMPT;
+        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : getSystemPrompt();
         const src = resolvedSystemPrompt !== null ? `file: ${opts.systemPromptFile}` : 'built-in';
         const mode = getConfig().system_prompt_mode || 'system_role';
         chatHistory.addMessage({
@@ -753,6 +738,40 @@ function createCommands({
         return;
       }
 
+      if (text === '/debug' || text.startsWith('/debug ')) {
+        const arg = text === '/debug' ? '' : text.slice(7).trim().toLowerCase();
+        if (arg === 'off' || arg === 'false' || arg === '0') debugMode = false;
+        else debugMode = true;
+
+        let tail = '';
+        try {
+          const content = fs.readFileSync(AUDIT_LOG, 'utf8');
+          const lines = content.trim().split('\n').filter((l) => l.trim()).slice(-5);
+          if (lines.length) {
+            const formatted = lines.map((line) => {
+              try {
+                const entry = JSON.parse(line);
+                const mark = entry.approved ? '✓' : '✗';
+                return `  ${mark} ${entry.ts} ${entry.tag} ${entry.input} → ${entry.result}`;
+              } catch {
+                return `  ${line}`;
+              }
+            });
+            tail = '\nLast 5 audit entries:\n' + formatted.join('\n');
+          } else {
+            tail = '\nAudit log is empty.';
+          }
+        } catch {
+          tail = '\nNo audit log found.';
+        }
+
+        chatHistory.addMessage({
+          role: 'system',
+          content: `Debug output: ${debugMode ? 'ON' : 'OFF'} (raw messages, raw AI responses, raw HTTP errors → stderr)${tail}`,
+        });
+        return;
+      }
+
       if (text.startsWith('/shell ') || text.startsWith('!')) {
         const cmd = text.startsWith('/shell ') ? text.slice(7).trim() : text.slice(1).trim();
         inputField.setDisabled(true);
@@ -810,7 +829,12 @@ function createCommands({
           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 : ''}`);
+            const isDownload = tag === 'download' || tag === 'http_get';
+            const barState = isDownload ? 'waiting_download' : 'tool';
+            const label = isDownload
+              ? `Waiting for download${detail ? ': ' + detail : ''}`
+              : `${actionLabel}${detail ? ': ' + detail : ''}`;
+            statusBar.update(barState, label);
             if (!opts.showThink) chatHistory.clearStreamingContent();
           }
           if (entry?.display === 'think_bubble') {
@@ -824,12 +848,16 @@ function createCommands({
         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}`);
+          const isDownload = tag === 'download' || tag === 'http_get';
+          if (isDownload) {
+            statusBar.update('waiting_download', `Waiting for download: ${short}`);
+          } else {
+            statusBar.update('tool', `${actionLabel}: ${short}`);
+          }
         },
         onToolEnd: (tag, result, durationMs) => {
           const isError = typeof result === 'string' && result.startsWith('Error');
           if (isError) {
-            finalizeHttpFetch();
             chatHistory.addMessage({
               role: 'tool',
               tag,
@@ -837,24 +865,6 @@ function createCommands({
               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]`);
@@ -890,6 +900,11 @@ function createCommands({
         onRetry: (attempt, max) => {
           statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
         },
+        onDebug: (block) => {
+          // Render in-history as a tool-style bubble so ctrl+O expand works and
+          // the RAW RESPONSE text survives TUI redraws (stderr would be clobbered).
+          chatHistory.addMessage({ role: 'tool', tag: 'debug', content: 'DEBUG', output: block });
+        },
         onError: (err) => {
           if (err && err.isWarning) {
             chatHistory.addMessage({ role: 'system', content: err.message || String(err) });
@@ -910,10 +925,19 @@ function createCommands({
       };
       inputField.on('abort', _onAbort);
 
+      // Refresh in case a prior turn's 400 overflow persisted a learned
+      // context_length to config after this chat started.
+      if (resolvedTokenLimit == null) {
+        const cfg = getConfig();
+        if (Number.isInteger(cfg.context_length) && cfg.context_length > 0) {
+          resolvedTokenLimit = cfg.context_length;
+        }
+      }
+
       try {
         const agentResult = await runAgentLoop(messages, currentModel, undefined, resolvedTokenLimit, {
           showThink: opts.showThink || false,
-          debug: opts.debug || false,
+          debug: debugMode,
           callbacks,
           systemPrompt: resolvedSystemPrompt,
           systemPromptMode: getConfig().system_prompt_mode || 'system_role',

package/lib/config.js

@@ -2,9 +2,30 @@
 
 const fs = require('fs');
 const path = require('path');
+const { URL } = require('url');
 
 const { CONFIG_PATH, DEFAULT_CONFIG } = require('./constants');
 
+let _apiKeyAnyWarned = false;
+const _LOCAL_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]', '::1']);
+
+function _maybeWarnApiKeyAny(cfg) {
+  if (_apiKeyAnyWarned) return;
+  if (cfg.api_key !== 'any') return;
+  let host = '';
+  try {
+    host = new URL(cfg.api_base).hostname;
+  } catch {
+    return;
+  }
+  if (_LOCAL_HOSTS.has(host)) return;
+  _apiKeyAnyWarned = true;
+  process.stderr.write(
+    "⚠ api_key='any' against non-local endpoint — requests will likely fail " +
+    "with 401. Run 'semalt-code config set api_key <key>' to set a real key.\n"
+  );
+}
+
 function normalizeConfig(cfg = {}) {
   const merged = { ...DEFAULT_CONFIG, ...cfg };
   // Ensure every DEFAULT_CONFIG key is present without overwriting existing values
@@ -33,6 +54,7 @@ function normalizeConfig(cfg = {}) {
   merged.dashboard_model_id = Number.isInteger(cfg.dashboard_model_id) && cfg.dashboard_model_id > 0
     ? cfg.dashboard_model_id
     : null;
+  merged.repair_malformed_tool_xml = cfg.repair_malformed_tool_xml === true;
   merged.models = Array.isArray(cfg.models)
     ? cfg.models
         .filter((entry) => entry &&
@@ -53,6 +75,9 @@ function normalizeConfig(cfg = {}) {
           if (Number.isInteger(entry.context_length) && entry.context_length > 0) {
             normalized.context_length = entry.context_length;
           }
+          // native_tools defaults to true; only explicit false/0/"false"/"0" opts out.
+          const nt = entry.native_tools;
+          normalized.native_tools = !(nt === false || nt === 0 || nt === '0' || nt === 'false');
           return normalized;
         })
     : [];
@@ -61,13 +86,16 @@ function normalizeConfig(cfg = {}) {
 
 function loadConfig() {
   fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  let cfg;
   if (fs.existsSync(CONFIG_PATH)) {
     try {
       const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-      return normalizeConfig(data);
+      cfg = normalizeConfig(data);
     } catch {}
   }
-  return normalizeConfig();
+  if (!cfg) cfg = normalizeConfig();
+  _maybeWarnApiKeyAny(cfg);
+  return cfg;
 }
 
 function saveConfig(cfg) {
@@ -94,8 +122,8 @@ function configShow(systemPromptOverride = null) {
   if (systemPromptOverride) {
     lines.push(`  system_prompt: [override from ${systemPromptOverride}]`);
   } else {
-    const { SYSTEM_PROMPT } = require('./prompts');
-    lines.push(`  system_prompt: ${SYSTEM_PROMPT.slice(0, 80)}...`);
+    const { getSystemPrompt } = require('./prompts');
+    lines.push(`  system_prompt: ${getSystemPrompt().slice(0, 80)}...`);
   }
   return lines.join('\n');
 }

package/lib/constants.js

@@ -17,23 +17,40 @@ const DEFAULT_CONFIG = {
   temperature: 0.7,
   request_timeout_ms: DEFAULT_API_TIMEOUT_MS,
   stream: true,
+  // native_tools (boolean, default true): when true, the
+  // client sends an OpenAI-format `tools` parameter and
+  // expects structured tool_calls in responses. Set to
+  // false only for models/endpoints that do not support
+  // native function calling (legacy finetunes, XML-only
+  // adapters). Per-profile flag on models[] entries.
   models: [],
   theme: 'dark',
   max_file_size_kb: 512,
   command_timeout_ms: 30000,
   max_output_lines: 50,
+  http_fetch_max_bytes: 262144,
   show_token_count: true,
   show_cost: false,
   system_prompt_mode: 'system_role',
+  repair_malformed_tool_xml: false,
 };
 
 const CONFIG_PATH = path.join(os.homedir(), '.semalt-ai', 'config.json');
 
+// TAG_REGISTRY classifies every XML tag the stream parser may encounter.
+// For 'tool'-type tags, the *parameter schema* lives in lib/tool_specs.js
+// (TOOL_SPECS) — that file is the single source of truth for argument
+// names, types, required flags, and descriptions used to build the
+// native function-calling `tools` array and the system-prompt tag
+// inventory. Adding or renaming a 'tool' entry here requires a matching
+// change in TOOL_SPECS; the assertion at the bottom of this module
+// enforces that parity at load time.
 const TAG_REGISTRY = {
   // Rendered visually in chat, never shown as raw text
   think:      { type: 'visual', streaming: true,  display: 'think_bubble' },
   reasoning:  { type: 'visual', streaming: true,  display: 'think_bubble' },
   reflection: { type: 'visual', streaming: true,  display: 'think_bubble' },
+  plan:       { type: 'visual', streaming: true,  display: 'think_bubble' },
 
   // Executed as tool calls
   exec:             { type: 'tool', streaming: false, label: 'Running command' },
@@ -58,13 +75,35 @@ const TAG_REGISTRY = {
   download:         { type: 'tool', streaming: false, label: 'Downloading' },
   upload:           { type: 'tool', streaming: false, label: 'Uploading' },
   http_get:         { type: 'tool', streaming: false, label: 'Fetching URL' },
-  http_get_next:    { type: 'tool', streaming: false, label: 'Fetching next content chunk' },
   ask_user:         { type: 'tool', streaming: false, label: 'Asking user' },
   store_memory:     { type: 'tool', streaming: false, label: 'Storing memory' },
   recall_memory:    { type: 'tool', streaming: false, label: 'Recalling memory' },
   list_memories:    { type: 'tool', streaming: false, label: 'Listing memories' },
   system_info:      { type: 'tool', streaming: false, label: 'Reading system info' },
 
+  // MiniMax-M2 native tool-call wrappers. `extractToolCalls` parses them into
+  // internal calls; classifying them here keeps raw XML out of the UI stream.
+  'minimax:tool_call': { type: 'tool', streaming: false, label: 'Using tool' },
+  invoke:    { type: 'strip' },
+  parameter: { type: 'strip' },
+
+  // Qwen / Hermes native tool-call wrappers. Qwen3-family models emit a
+  // JSON-shaped `<tool_call>{"name":"...","arguments":{...}}</tool_call>`
+  // block inline when the server's tool parser is not applied, and some
+  // finetunes also use the namespaced `<qwen:tool_call>` or the
+  // `<function_call>` spelling. `extractToolCalls` parses all three.
+  'qwen:tool_call': { type: 'tool', streaming: false, label: 'Using tool' },
+  tool_call:       { type: 'tool', streaming: false, label: 'Using tool' },
+  function_call:   { type: 'tool', streaming: false, label: 'Using tool' },
+
+  // Qwen3-Coder / Qwen3.5 XML tool-call format: `<function=tool_name>…</function>`.
+  // The tool name is carried as an `=name` suffix on the opening tag rather
+  // than an attribute; `parameter` (already registered as `strip` above) covers
+  // the matching `<parameter=key>…</parameter>` child tags. StreamParser splits
+  // the tag name on `[\s=]`, so the registry lookup for `<function=read_file>`
+  // resolves here.
+  function: { type: 'tool', streaming: false, label: 'Using tool' },
+
   // Silently stripped — model wrapper artifacts
   answer:    { type: 'strip' },
   response:  { type: 'strip' },
@@ -74,8 +113,35 @@ const TAG_REGISTRY = {
   text:      { type: 'strip' },
   result:    { type: 'strip' },
   code:      { type: 'strip' },
+
+  // Protocol wrapper: the model's declared final reply to the user. Tags are
+  // stripped from rendered output but the inner content IS the user-facing
+  // answer and must stream through onToken, not be buffered like tool blocks.
+  final_answer: { type: 'final', streaming: true, label: 'Final answer' },
 };
 
+// Load-time parity check: every 'tool'-type tag in TAG_REGISTRY must have a
+// matching entry in TOOL_SPECS, and TOOL_SPECS must not declare phantom
+// tools that aren't registered. Requiring tool_specs.js here (rather than
+// at the top of the file) keeps the module boundary one-directional —
+// tool_specs.js does not depend on this file.
+const { TOOL_SPECS } = require('./tool_specs');
+(function assertToolSpecParity() {
+  const registryTools = Object.entries(TAG_REGISTRY)
+    .filter(([, v]) => v.type === 'tool')
+    .map(([k]) => k)
+    .sort();
+  const specTools = Object.keys(TOOL_SPECS).sort();
+  const missing = registryTools.filter((k) => !Object.prototype.hasOwnProperty.call(TOOL_SPECS, k));
+  const extra = specTools.filter((k) => !(k in TAG_REGISTRY) || TAG_REGISTRY[k].type !== 'tool');
+  if (missing.length || extra.length) {
+    const parts = [];
+    if (missing.length) parts.push(`missing in TOOL_SPECS: ${missing.join(', ')}`);
+    if (extra.length) parts.push(`extra in TOOL_SPECS: ${extra.join(', ')}`);
+    throw new Error(`TAG_REGISTRY ↔ TOOL_SPECS mismatch — ${parts.join('; ')}`);
+  }
+})();
+
 module.exports = {
   CONFIG_PATH,
   DEFAULT_API_TIMEOUT_MS,

package/lib/metrics.js

@@ -32,13 +32,22 @@ class Metrics {
   }
 
   tokenLimitStatus() {
-    if (this.modelTokenLimit === null) return null;
     const used = this.contextTokens();
+    if (this.modelTokenLimit == null) {
+      // No known limit — still expose `used` once we have a turn's prompt_tokens
+      // so the UI can render "N tok · limit unknown" instead of hiding the line.
+      if (!this.turns.length || !used) return null;
+      return { used, limit: null, pct: null, bar: null };
+    }
     const pct = Math.round((used / this.modelTokenLimit) * 100);
     const bar = this._buildBar(pct, 10);
     return { used, limit: this.modelTokenLimit, pct, bar };
   }
 
+  setModelTokenLimit(limit) {
+    this.modelTokenLimit = Number.isInteger(limit) && limit > 0 ? limit : null;
+  }
+
   _buildBar(pct, width) {
     const filled = Math.min(Math.round((pct / 100) * width), width);
     const empty = Math.max(0, width - filled);
@@ -79,8 +88,12 @@ class Metrics {
 
     const status = this.tokenLimitStatus();
     if (status !== null) {
-      lines.push(row(`  Context used:  ${this.contextTokens()}`));
-      lines.push(row(`  Token limit:   ${status.used}/${status.limit} (${status.pct}%)`));
+      if (status.limit === null) {
+        lines.push(row(`  Context used:  ${status.used} (limit unknown)`));
+      } else {
+        lines.push(row(`  Context used:  ${this.contextTokens()}`));
+        lines.push(row(`  Token limit:   ${status.used}/${status.limit} (${status.pct}%)`));
+      }
     }
 
     lines.push(row(`  Duration:      ${durationStr}`));