ispbills-icli 8.1.1 → 8.2.0

package/README.md

@@ -99,7 +99,8 @@ icli --reasoning "audit the config on olt#1"   # stream reasoning inline
 
 | Flag | Description |
 |---|---|
-| `--reasoning` | Stream the model's reasoning inline |
+| `--reasoning` | Stream the model's reasoning inline (on by default in the REPL) |
+| `--no-reasoning` | Hide the reasoning trace |
 | `--loader-style STYLE` | Thinking indicator: `spinner` (default), `gradient`, or `minimal` |
 | `--ascii` | Force ASCII-safe glyphs (use if symbols show as boxes) |
 | `--unicode` | Force full Unicode glyphs |
@@ -165,6 +166,7 @@ suggestion (accept with **Tab** or **→**), and runs the highlighted command on
 |---|---|
 | **Enter** | Send message (or run the highlighted slash command) |
 | **/** then **↑/↓** | Open the slash menu and move the selection; **Tab** / **→** completes, **Enter** runs |
+| **@** | Mention a device/entity (e.g. `@olt:`, `@onu:`); **Tab** / **→** completes the tag |
 | **↑/↓** (empty input) | Navigate input history |
 | **Shift+Tab** | Toggle autopilot mode |
 | **Ctrl+T** | Toggle reasoning display |
@@ -194,8 +196,11 @@ iCli connects to the same AI engine as the in-browser terminal:
 - **Customer lookup** — find customers by name, IP, MAC, username, or invoice  
 - **Config audits** — review running config and get concrete suggestions  
 - **Web search** — looks up vendor CLI docs when it needs to  
-- **Streaming output** — answers stream live with a thinking indicator, reasoning, and step-by-step server progress  
-- **Plans & connect cards** — proposed fixes render as a reviewable plan (`apply fix` to confirm); device connections show as a connect card  
+- **Streaming output** — reasoning, thoughts, and multi-step plans all stream live as they form, with an animated working indicator and step-by-step server progress  
+- **Reasoning on by default** — the model's reasoning trace streams inline (toggle with **Ctrl+T** / `/reasoning`, or start with `--no-reasoning`)  
+- **Rich rendering** — Markdown tables, colored lists, headings, and code blocks; `@`-mentions are highlighted; long lists render as aligned tables  
+- **Interactive prompts** — when the AI needs a decision, it shows a selectable choice list (↑/↓, **Enter**) with an optional free-text answer (**Tab**)  
+- **Plans & connect cards** — proposed fixes stream in live as a reviewable plan (`apply fix` to confirm, or use the Apply/Explain/Cancel prompt); device connections show as a connect card  
 - **Full-screen terminal UI** — a full-height alternate-screen TUI (built on [Ink](https://github.com/vadimdemedes/ink)) with the banner pinned to the top, a bottom-pinned bordered input, a selectable slash-command menu, input history, and a bottom-anchored transcript — the same layout as GitHub Copilot CLI / Gemini CLI. Piped/non-interactive use falls back to plain streaming output  
 - **Terminal-aware rendering** — the layout reflows to your terminal width and resizes live; on classic Windows consoles (`cmd.exe` / legacy PowerShell) it auto-switches to ASCII-safe glyphs and borders so nothing shows as broken boxes  
 

package/bin/icli.js

@@ -54,9 +54,9 @@ if (has('--ascii')) process.env.ICLI_ASCII = '1';
 if (has('--unicode')) process.env.ICLI_UNICODE = '1';
 
 const display = {
-  reasoning: has('--reasoning'),
+  reasoning: !has('--no-reasoning'),
   loader: {
-    text: 'Thinking',
+    text: 'Working',
     style: flag('--loader-style') || 'spinner',
   },
 };
@@ -109,7 +109,8 @@ function printHelp() {
 
   console.log(`\n  ${BOLD}Flags${RESET}`);
   [
-    ['--reasoning',            'Stream the model\'s reasoning inline'],
+    ['--reasoning',            'Stream reasoning inline (on by default)'],
+    ['--no-reasoning',         'Hide the reasoning trace'],
     ['--loader-style STYLE',   'spinner | gradient | minimal'],
     ['--ascii',                'Force ASCII-safe glyphs (classic Windows cmd.exe)'],
     ['--unicode',              'Force full Unicode glyphs'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ispbills-icli",
-  "version": "8.1.1",
+  "version": "8.2.0",
   "description": "iCli — IspBills AI network engineer in your terminal",
   "keywords": [
     "ispbills",

package/src/client.js

@@ -7,7 +7,11 @@ import { refreshToken } from './auth.js';
 function parseStreamText(raw) {
   const m = raw.match(/"text"\s*:\s*"((?:[^"\\]|\\.)*)/);
   if (!m) return raw.trimStart().startsWith('{') ? null : raw;
-  return m[1]
+  return unescapeJsonStr(m[1]);
+}
+
+function unescapeJsonStr(s) {
+  return s
     .replace(/\\n/g, '\n')
     .replace(/\\t/g, '\t')
     .replace(/\\r/g, '')
@@ -15,6 +19,53 @@ function parseStreamText(raw) {
     .replace(/\\\\/g, '\\');
 }
 
+/** Pull the value of a top-level string key out of a (possibly partial) JSON blob. */
+function grabString(raw, key) {
+  const m = raw.match(new RegExp('"' + key + '"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"'));
+  return m ? unescapeJsonStr(m[1]) : null;
+}
+
+/**
+ * Extract a partially-streamed `plan` reply from the raw JSON.
+ * Returns { summary, steps:[{cmd, why, risk}] } using only the step objects
+ * that have finished streaming (balanced braces), so the plan can grow live.
+ */
+export function parsePartialPlan(raw) {
+  const summary = grabString(raw, 'summary') || '';
+  const steps = [];
+  const sm = raw.match(/"steps"\s*:\s*\[/);
+  if (sm) {
+    let i = sm.index + sm[0].length;
+    while (i < raw.length) {
+      // find next object start
+      while (i < raw.length && raw[i] !== '{' && raw[i] !== ']') i++;
+      if (i >= raw.length || raw[i] === ']') break;
+      // scan a balanced object, respecting strings
+      let depth = 0, inStr = false, esc = false, start = i;
+      for (; i < raw.length; i++) {
+        const ch = raw[i];
+        if (inStr) {
+          if (esc) esc = false;
+          else if (ch === '\\') esc = true;
+          else if (ch === '"') inStr = false;
+        } else if (ch === '"') inStr = true;
+        else if (ch === '{') depth++;
+        else if (ch === '}') { depth--; if (depth === 0) { i++; break; } }
+      }
+      if (depth !== 0) break; // object still streaming
+      const objRaw = raw.slice(start, i);
+      const cmd = grabString(objRaw, 'cmd');
+      if (cmd === null) continue;
+      steps.push({
+        cmd,
+        why: grabString(objRaw, 'why') || grabString(objRaw, 'reason') || '',
+        risk: grabString(objRaw, 'risk') || '',
+      });
+    }
+  }
+  return { type: 'plan', summary, steps };
+}
+
 /**
  * Stream a chat turn from the IspBills Terminal AI backend.
  *
@@ -82,10 +133,17 @@ export async function streamChat(cfg, messages, options = {}) {
         onEvent({ type: 'reasoning', delta: ev.reason_delta });
       } else if (ev.delta !== undefined) {
         rawAnswer += ev.delta;
-        const txt = parseStreamText(rawAnswer);
-        if (txt !== null && txt.length > answerText.length) {
-          onEvent({ type: 'text', delta: txt.slice(answerText.length) });
-          answerText = txt;
+        const trimmed = rawAnswer.trimStart();
+        const isPlan = /"type"\s*:\s*"plan"/.test(rawAnswer) ||
+          (trimmed.startsWith('{') && /"steps"\s*:/.test(rawAnswer));
+        if (isPlan) {
+          onEvent({ type: 'plan', reply: parsePartialPlan(rawAnswer) });
+        } else {
+          const txt = parseStreamText(rawAnswer);
+          if (txt !== null && txt.length > answerText.length) {
+            onEvent({ type: 'text', delta: txt.slice(answerText.length) });
+            answerText = txt;
+          }
         }
       } else if (ev.done) {
         finalResult = ev.result;

package/src/tui/app.js

@@ -7,7 +7,7 @@ import { Box, Text, useStdout, useApp, useInput } from 'ink';
 import { C, glyphs, midDot, dash } from './theme.js';
 import {
   Banner, UserMessage, AssistantMessage, StatusLines, Reasoning,
-  Plan, Connect, Notice, Thinking,
+  Plan, Connect, Notice, Thinking, Choice,
 } from './components.js';
 import { Composer } from './composer.js';
 import { streamChat } from '../client.js';
@@ -59,6 +59,7 @@ function liveHeight(live, cols, showReasoning) {
   let h = 2; // thinking line + margin
   if (live.status?.length) h += 1 + live.status.length;
   if (showReasoning && live.reasoning) h += 1 + wrapLines(live.reasoning, cols);
+  if (live.reply?.steps) h += 3 + live.reply.steps.length * 2 + (live.reply.summary ? 1 : 0);
   if (live.text) h += 1 + wrapLines(live.text, cols);
   return h;
 }
@@ -74,6 +75,8 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
   const [showReasoning, setShowReasoning] = useState(!!display.reasoning);
   const [autopilot, setAutopilot] = useState(false);
   const [hint, setHint] = useState('');
+  const [startedAt, setStartedAt] = useState(0);
+  const [choice, setChoice] = useState(null); // { title, note, options, allowText, sel, text, focusText, onPick }
 
   const convo = useRef([]);      // [{role, content}] for the backend
   const plain = useRef([]);      // plain-text transcript for exit reprint
@@ -96,13 +99,18 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
     convo.current.push({ role: 'user', content: question });
     setBusy(true);
     setHint('');
-    const s = { status: [], reasoning: '', text: '' };
+    setStartedAt(Date.now());
+    const s = { status: [], reasoning: '', text: '', reply: null };
     setLive({ ...s });
 
     const abort = new AbortController();
     abortRef.current = abort;
 
-    const context = { autopilot: apRef.current };
+    const context = {
+      autopilot: apRef.current,
+      client: 'icli',
+      ui: { tables: true, prompts: true, markdown: true },
+    };
     if (modelRef.current) context.model = modelRef.current;
 
     try {
@@ -113,6 +121,7 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
           if (ev.type === 'status') s.status = [...s.status, ev.line];
           else if (ev.type === 'reasoning') s.reasoning += ev.delta;
           else if (ev.type === 'text') s.text += ev.delta;
+          else if (ev.type === 'plan') s.reply = ev.reply;
           setLive({ ...s });
         },
       });
@@ -120,20 +129,46 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
       const type = reply.type ?? 'message';
       if (type === 'plan') { push({ type: 'plan', reply }); log('[plan] ' + (reply.summary || '')); }
       else if (type === 'connect') { push({ type: 'connect', reply }); log('[connect] ' + (reply.device?.kind || '')); }
+      else if (type === 'prompt' || type === 'choice') { push({ type: 'assistant', text: text || reply.question || '' }); log(text || reply.question || ''); }
       else { push({ type: 'assistant', text: text || '(no response)' }); log(text || ''); }
       if (text) convo.current.push({ role: 'assistant', content: text });
 
       // Autopilot: auto-confirm a proposed plan without waiting for the user.
       if (type === 'plan' && apRef.current && depth < 3) {
         push({ type: 'notice', text: `${glyphs.bolt} autopilot ${dash()} applying fix…`, color: C.yellow });
-        setLive(null);
-        setBusy(false);
-        abortRef.current = null;
+        setLive(null); setBusy(false); abortRef.current = null;
         return runTurn('apply fix', depth + 1);
       }
+
+      // Otherwise surface an interactive prompt for the user to choose/answer.
+      setLive(null); setBusy(false); abortRef.current = null;
+      if (type === 'plan') {
+        const destructive = (reply.steps || []).some((st) => /destruct|high/.test(st.risk || ''));
+        setChoice({
+          title: 'Apply this fix?',
+          note: reply.summary || '',
+          sel: 0, text: '', focusText: false, allowText: false,
+          options: [
+            { label: destructive ? 'Apply fix (destructive)' : 'Apply fix', value: 'apply fix', danger: destructive },
+            { label: 'Explain the plan first', value: 'explain this plan in more detail before applying' },
+            { label: 'Cancel', value: null },
+          ],
+        });
+      } else if (type === 'prompt' || type === 'choice') {
+        const opts = (reply.options || []).map((o) =>
+          typeof o === 'string' ? { label: o, value: o } : { label: o.label ?? o.value, value: o.value ?? o.label, hint: o.hint });
+        setChoice({
+          title: reply.question || 'Choose an option',
+          note: reply.note || '',
+          sel: 0, text: '', focusText: opts.length === 0,
+          allowText: reply.allowText !== false,
+          options: opts,
+        });
+      }
     } catch (e) {
       if (abort.signal.aborted) push({ type: 'notice', text: `${glyphs.cross} Cancelled.`, color: C.yellow });
       else push({ type: 'notice', text: `${glyphs.cross} ${e.message}`, color: C.red });
+      setLive(null); setBusy(false); abortRef.current = null;
     } finally {
       abortRef.current = null;
       setLive(null);
@@ -209,8 +244,43 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
     runTurn(question);
   }, [doExit, push, runTurn, onExternal, setAutopilotMode, model, cfg]);
 
+  // Interactive prompt/choice handling (owns the keyboard while open).
+  const pickChoice = useCallback((value) => {
+    setChoice(null);
+    if (value == null) { push({ type: 'notice', text: 'Dismissed.', color: C.gray }); return; }
+    runTurn(String(value));
+  }, [push, runTurn]);
+
+  useInput((input, key) => {
+    if (!choice) return;
+    if (key.escape || (key.ctrl && input === 'c')) { setChoice(null); return; }
+    if (key.tab && choice.allowText) { setChoice((c) => ({ ...c, focusText: !c.focusText })); return; }
+    if (key.upArrow) { setChoice((c) => ({ ...c, focusText: false, sel: Math.max(0, c.sel - 1) })); return; }
+    if (key.downArrow) {
+      setChoice((c) => {
+        const max = c.options.length - 1;
+        if (c.allowText && c.sel >= max) return { ...c, focusText: true };
+        return { ...c, sel: Math.min(max, c.sel + 1) };
+      });
+      return;
+    }
+    if (key.return) {
+      if (choice.focusText) { const t = choice.text.trim(); if (t) pickChoice(t); return; }
+      pickChoice(choice.options[choice.sel]?.value);
+      return;
+    }
+    if (choice.focusText) {
+      if (key.backspace || key.delete) { setChoice((c) => ({ ...c, text: c.text.slice(0, -1) })); return; }
+      if (input && !key.ctrl && !key.meta) {
+        const printable = input.replace(/[\x00-\x1f\x7f]/g, '');
+        if (printable) setChoice((c) => ({ ...c, text: c.text + printable }));
+      }
+    }
+  });
+
   // Global keys (Composer handles text editing; here we handle app-level keys).
   useInput((input, key) => {
+    if (choice) return; // the Choice prompt owns the keyboard
     if (key.ctrl && input === 'c') {
       if (busy) { abortRef.current?.abort(); setHint(''); return; }
       const now = Date.now();
@@ -280,16 +350,19 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
         ${chosen.map(renderItem)}
         ${live
           ? html`<${Box} flexDirection="column">
-              <${StatusLines} lines=${live.status} />
+              <${StatusLines} lines=${live.status} busy=${busy} />
               ${showReasoning && live.reasoning ? html`<${Reasoning} text=${live.reasoning} />` : null}
+              ${live.reply?.steps ? html`<${Plan} reply=${live.reply} live=${true} />` : null}
               ${live.text ? html`<${Box} marginTop=${1}><${AssistantMessage} text=${live.text} /><//>` : null}
-              <${Thinking} label=${live.text ? 'Responding' : 'Thinking'} />
+              <${Thinking} label=${live.reply ? 'Planning' : live.text ? 'Responding' : 'Working'} startedAt=${startedAt} />
             <//>`
           : null}
       <//>
 
       <${Box} flexShrink=${0} flexDirection="column">
-        <${Composer} onSubmit=${onSubmit} busy=${busy} width=${cols} />
+        ${choice
+          ? html`<${Choice} ...${choice} />`
+          : html`<${Composer} onSubmit=${onSubmit} busy=${busy} width=${cols} />`}
         <${Box} paddingX=${1} width=${cols}>
           <${Box} flexGrow=${1}><${Text} color=${C.gray} wrap="truncate-end">${ctx}<//><//>
           <${Text} color=${hint || autopilot ? C.yellow : C.gray} wrap="truncate-end">${footerRight}<//>

package/src/tui/components.js

@@ -1,5 +1,5 @@
 // Presentational components for the iCli Ink TUI.
-import { html } from './dom.js';
+import { html, useState, useEffect } from './dom.js';
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { C, glyphs, spinnerType, borderStyle, midDot, dash } from './theme.js';
@@ -55,12 +55,22 @@ export function Banner({ cfg = {}, model, width = 80, compact = false }) {
     <//>`;
 }
 
+/** Split text into spans, colouring @mentions. */
+function withMentions(text, base = C.white) {
+  const parts = String(text).split(/(@[\w:.\-/]+)/g);
+  return parts.map((p, i) =>
+    /^@[\w:.\-/]+$/.test(p)
+      ? html`<${Text} key=${'mn' + i} color=${C.cyan} bold>${p}<//>`
+      : html`<${Text} key=${'mn' + i} color=${base}>${p}<//>`,
+  );
+}
+
 /** The user's prompt line. */
 export function UserMessage({ text }) {
   return html`
     <${Box} marginTop=${1}>
       <${Text} color=${C.accent} bold>${glyphs.prompt} <//>
-      <${Text} color=${C.white}>${text}<//>
+      <${Text}>${withMentions(text)}<//>
     <//>`;
 }
 
@@ -72,44 +82,71 @@ export function AssistantMessage({ text }) {
     <//>`;
 }
 
-/** Icon for a server progress/status line. */
-function statusIcon(line) {
+/** Classify a server progress/status line into an icon + tone. */
+function classify(line) {
   const l = String(line).toLowerCase();
-  if (/unreachable|skip|fail|error|denied|timeout/.test(l)) return html`<${Text} color=${C.red}>${glyphs.cross}<//>`;
-  if (/done|success|found|complet|online|ready|ok\b/.test(l)) return html`<${Text} color=${C.green}>${glyphs.check}<//>`;
-  if (/batch|sub.?agent|fleet|parallel/.test(l)) return html`<${Text} color=${C.accent}>${glyphs.ring}<//>`;
-  if (/\[\d+\/\d+\]/.test(l)) return html`<${Text} color=${C.accent}>${glyphs.diamond}<//>`;
-  if (/probe|reachab|ping/.test(l)) return html`<${Text} color=${C.yellow}>${glyphs.target}<//>`;
-  if (/connect|ssh|telnet|api|session/.test(l)) return html`<${Text} color=${C.accent}>${glyphs.arrow}<//>`;
-  return html`<${Text} color=${C.gray}>${glyphs.bullet}<//>`;
+  if (/unreachable|skip|fail|error|denied|timeout|down\b|offline/.test(l)) return { icon: glyphs.cross, color: C.red };
+  if (/done|success|found|complet|online|ready|free\b|ok\b|\bup\b/.test(l)) return { icon: glyphs.check, color: C.green };
+  if (/assign|sub.?agent|fleet|parallel|dispatch|spawn/.test(l)) return { icon: glyphs.ring, color: C.magenta };
+  if (/probe|reachab|ping/.test(l)) return { icon: glyphs.target, color: C.yellow };
+  if (/connect|ssh|telnet|api|session|running|exec|command/.test(l)) return { icon: glyphs.arrow, color: C.accent };
+  return { icon: glyphs.bullet, color: C.gray };
 }
 
-/** Live server activity (tool calls happening backend-side). */
-export function StatusLines({ lines = [] }) {
+// A sub-agent progress line, e.g. "✓ [1/3] nas#1: FREE" or "[2/3] olt#1: down".
+const SUBAGENT = /^\s*[✓✗x]?\s*\[(\d+)\/(\d+)\]\s*(.+?)\s*[:：]\s*(.+?)\s*$/;
+
+/** Live server activity — tool calls and sub-agents happening backend-side. */
+export function StatusLines({ lines = [], busy = false }) {
   if (!lines.length) return null;
+  const subLines = lines.filter((l) => SUBAGENT.test(l));
   return html`
     <${Box} flexDirection="column" marginTop=${1}>
-      ${lines.map((line, i) => html`
-        <${Box} key=${'s' + i}>
-          ${statusIcon(line)}
-          <${Text} color=${C.gray}> ${line}<//>
-        <//>`)}
+      ${lines.map((line, i) => {
+        const sm = String(line).match(SUBAGENT);
+        if (sm) {
+          const [, idx, total, host, result] = sm;
+          const good = !/fail|error|down|offline|unreachable|timeout|deny/i.test(result);
+          const isLast = subLines[subLines.length - 1] === line;
+          const running = busy && isLast && Number(idx) < Number(total);
+          const branch = Number(idx) === Number(total) ? glyphs.branchEnd : glyphs.branchMid;
+          return html`
+            <${Box} key=${'s' + i}>
+              <${Text} color=${C.magenta}>${branch} <//>
+              <${Text} color=${C.gray}>${idx}/${total} <//>
+              <${Text} color=${C.white} bold>${host}<//>
+              <${Text} color=${C.gray}> ${dash()} <//>
+              ${running
+                ? html`<${Text} color=${C.accent}><${Spinner} type=${spinnerType()} /><//>`
+                : html`<${Text} color=${good ? C.green : C.red} bold>${good ? glyphs.check : glyphs.cross} ${result}<//>`}
+            <//>`;
+        }
+        const { icon, color } = classify(line);
+        const clean = String(line).replace(/^[\s◈◆●○◎⇢→>*✓✗×!⚠·-]+/u, '').trimStart() || String(line);
+        return html`
+          <${Box} key=${'s' + i}>
+            <${Text} color=${color}>${icon}<//>
+            <${Text} color=${C.gray}> ${clean}<//>
+          <//>`;
+      })}
     <//>`;
 }
 
-/** Reasoning trace (only when enabled). */
+/** Reasoning trace (shown by default; toggle with Ctrl+T). */
 export function Reasoning({ text }) {
   if (!text) return null;
   return html`
-    <${Box} flexDirection="column" marginTop=${1}>
-      <${Text} color=${C.accent}>${glyphs.reasoning} ${html`<${Text} color=${C.gray}>Reasoning<//>`}<//>
-      <${Text} color=${C.gray}>${text}<//>
+    <${Box} flexDirection="column" marginTop=${1} borderStyle=${borderStyle()} borderColor=${C.gray}
+           borderTop=${false} borderRight=${false} borderBottom=${false} paddingLeft=${1}>
+      <${Text} color=${C.magenta}>${glyphs.reasoning} ${html`<${Text} color=${C.gray} bold>Reasoning<//>`}<//>
+      <${Text} color=${C.gray} italic>${text}<//>
     <//>`;
 }
 
 /** A proposed remediation plan. */
-export function Plan({ reply = {} }) {
+export function Plan({ reply = {}, live = false }) {
   const steps = reply.steps || [];
+  const dot3 = '…';
   return html`
     <${Box} flexDirection="column" marginTop=${1}>
       <${Text} color=${C.accent} bold>${glyphs.diamond} Plan<//>
@@ -133,7 +170,9 @@ export function Plan({ reply = {} }) {
           <//>`;
       })}
       <${Box} marginTop=${1}>
-        <${Text} color=${C.gray}>Type ${html`<${Text} color=${C.white}>apply fix<//>`} to confirm.<//>
+        ${live
+          ? html`<${Text} color=${C.gray} italic>${glyphs.bullet} forming plan${dot3}<//>`
+          : html`<${Text} color=${C.gray}>Type ${html`<${Text} color=${C.white}>apply fix<//>`} to confirm.<//>`}
       <//>
     <//>`;
 }
@@ -157,11 +196,54 @@ export function Notice({ text, color = C.gray }) {
   return html`<${Box} marginTop=${1}><${Text} color=${color}>${text}<//><//>`;
 }
 
-/** The active "thinking" line with a spinner. */
-export function Thinking({ label = 'Thinking' }) {
+/** The active "working" line — animated spinner, elapsed time, cancel hint. */
+export function Thinking({ label = 'Working', startedAt }) {
+  const [, tick] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => tick((n) => n + 1), 1000);
+    return () => clearInterval(id);
+  }, []);
+  const secs = startedAt ? Math.max(0, Math.round((Date.now() - startedAt) / 1000)) : 0;
   return html`
     <${Box} marginTop=${1}>
       <${Text} color=${C.accent}><${Spinner} type=${spinnerType()} /><//>
-      <${Text} color=${C.gray}> ${label}…<//>
+      <${Text} color=${C.accent} bold> ${label}<//>
+      <${Text} color=${C.gray}>… (${secs}s ${midDot()}esc to interrupt)<//>
+    <//>`;
+}
+
+/**
+ * An interactive prompt — pick an option with ↑/↓ + Enter, or (when
+ * `allowText`) type a free-form answer. Mirrors GitHub Copilot CLI prompts.
+ * Presentational only: the parent owns `sel`/`textValue` and key handling.
+ */
+export function Choice({ title, note, options = [], sel = 0, allowText = false, text = '', focusText = false }) {
+  return html`
+    <${Box} flexDirection="column" marginTop=${1} borderStyle=${borderStyle()} borderColor=${C.accent} paddingX=${1}>
+      ${title ? html`<${Text} color=${C.accent} bold>${glyphs.diamond} ${title}<//>` : null}
+      ${note ? html`<${Text} color=${C.gray}>${note}<//>` : null}
+      <${Box} flexDirection="column" marginTop=${title || note ? 1 : 0}>
+        ${options.map((o, i) => {
+          const on = !focusText && i === sel;
+          const label = o.label ?? o.value ?? String(o);
+          const tone = o.danger ? C.red : on ? C.accent : C.white;
+          return html`
+            <${Box} key=${'o' + i}>
+              <${Text} color=${on ? C.accent : C.gray}>${on ? glyphs.prompt + ' ' : '  '}<//>
+              <${Text} color=${tone} bold=${on}>${label}<//>
+              ${o.hint ? html`<${Text} color=${C.gray}> ${dash()} ${o.hint}<//>` : null}
+            <//>`;
+        })}
+        ${allowText
+          ? html`<${Box} key="freetext">
+              <${Text} color=${focusText ? C.accent : C.gray}>${focusText ? glyphs.prompt + ' ' : '  '}<//>
+              <${Text} color=${C.gray}>${text ? '' : 'Type a custom answer…'}<//>
+              <${Text} color=${C.white}>${text}<//>${focusText ? html`<${Text} inverse> <//>` : null}
+            <//>`
+          : null}
+      <//>
+      <${Box} marginTop=${1}>
+        <${Text} color=${C.gray}>${glyphs.up}${glyphs.down} choose ${midDot()}${allowText ? 'Tab type ' + midDot() : ''}Enter confirm ${midDot()}Esc dismiss<//>
+      <//>
     <//>`;
 }

package/src/tui/composer.js

@@ -6,6 +6,20 @@ import { Box, Text, useInput } from 'ink';
 import { C, glyphs, borderStyle } from './theme.js';
 import { SLASH_COMMANDS } from '../commands.js';
 
+// @-mention entity types. Selecting one inserts e.g. "@olt:" so the user can
+// append an identifier (@olt:3); the backend treats it as a scoped reference.
+const MENTIONS = [
+  { tag: '@device',   desc: 'Any device by name or id' },
+  { tag: '@olt',      desc: 'An OLT' },
+  { tag: '@router',   desc: 'A router / NAS' },
+  { tag: '@onu',      desc: 'An ONU' },
+  { tag: '@customer', desc: 'A customer' },
+  { tag: '@vlan',     desc: 'A VLAN id' },
+  { tag: '@circuit',  desc: 'A circuit / uplink' },
+  { tag: '@ip',       desc: 'An IP address' },
+  { tag: '@mac',      desc: 'A MAC address' },
+];
+
 export function Composer({ onSubmit, busy, width = 80 }) {
   const [value, setValue] = useState('');
   const [cursor, setCursor] = useState(0);
@@ -13,9 +27,16 @@ export function Composer({ onSubmit, busy, width = 80 }) {
   const [histIdx, setHistIdx] = useState(-1);
   const [sel, setSel] = useState(0);
 
-  // The slash palette is open while typing the command token (no space yet).
-  const matches = value.startsWith('/') && !value.includes(' ')
-    ? SLASH_COMMANDS.filter((s) => s.cmd.startsWith(value))
+  // Determine the token being typed at the cursor to drive the palette.
+  const upto = value.slice(0, cursor);
+  const tokStart = Math.max(upto.lastIndexOf(' '), upto.lastIndexOf('\n')) + 1;
+  const token = upto.slice(tokStart);
+  const slashMode = value.startsWith('/') && tokStart === 0;
+  const mentionMode = token.startsWith('@');
+  const matches = slashMode
+    ? SLASH_COMMANDS.filter((s) => s.cmd.startsWith(token))
+    : mentionMode
+    ? MENTIONS.filter((m) => m.tag.startsWith(token.toLowerCase()))
     : [];
   const menuOpen = matches.length > 0;
 
@@ -32,12 +53,23 @@ export function Composer({ onSubmit, busy, width = 80 }) {
 
   const setText = (v, c) => { setValue(v); setCursor(c ?? v.length); };
 
+  // Complete the active token to the highlighted palette entry.
+  const complete = () => {
+    if (!menuOpen) return;
+    if (slashMode) { const c = matches[sel].cmd + ' '; setText(c, c.length); return; }
+    const ins = matches[sel].tag + ':';
+    const v = value.slice(0, tokStart) + ins + value.slice(cursor);
+    setText(v, tokStart + ins.length);
+  };
+
   useInput((input, key) => {
     if (busy) return; // ignore edits while a turn streams (App handles Ctrl+C/Esc)
 
     // ── Submit / complete ──
     if (key.return) {
-      if (menuOpen) { submit(matches[sel].cmd); return; }
+      // In slash mode Enter runs the command; in mention mode it completes.
+      if (menuOpen && slashMode) { submit(matches[sel].cmd); return; }
+      if (menuOpen && mentionMode) { complete(); return; }
       submit(value);
       return;
     }
@@ -46,10 +78,7 @@ export function Composer({ onSubmit, busy, width = 80 }) {
       submit(value.slice(0, cursor) + first + value.slice(cursor));
       return;
     }
-    if (key.tab && !key.shift) {
-      if (menuOpen) { const c = matches[sel].cmd + ' '; setText(c, c.length); }
-      return;
-    }
+    if (key.tab && !key.shift) { complete(); return; }
 
     // ── Menu / history navigation ──
     if (key.upArrow) {
@@ -76,8 +105,8 @@ export function Composer({ onSubmit, busy, width = 80 }) {
     // ── Cursor movement ──
     if (key.leftArrow) { setCursor((c) => Math.max(0, c - 1)); return; }
     if (key.rightArrow) {
-      // At end of a slash token, Right accepts the highlighted completion.
-      if (menuOpen && cursor >= value.length) { const c = matches[sel].cmd + ' '; setText(c, c.length); return; }
+      // At end of the active token, Right accepts the highlighted completion.
+      if (menuOpen && cursor >= value.length) { complete(); return; }
       setCursor((c) => Math.min(value.length, c + 1));
       return;
     }
@@ -112,13 +141,14 @@ export function Composer({ onSubmit, busy, width = 80 }) {
   const at = value[cursor] ?? ' ';
   const after = value.slice(cursor + 1);
   const empty = value.length === 0;
-  const sug = menuOpen && matches[sel] ? matches[sel].cmd : '';
-  const ghost = sug && sug.startsWith(value) && cursor >= value.length ? sug.slice(value.length) : '';
+  const sugTok = menuOpen && matches[sel] ? (slashMode ? matches[sel].cmd : matches[sel].tag) : '';
+  const ghost = sugTok && sugTok.startsWith(token) && cursor >= value.length ? sugTok.slice(token.length) : '';
 
   return html`
     <${Box} flexDirection="column" width=${width}>
       ${menuOpen
         ? html`<${Box} flexDirection="column" paddingX=${1} marginBottom=${0}>
+            ${slashMode ? null : html`<${Box}><${Text} color=${C.cyan} bold>@ mention <//><${Text} color=${C.gray}>a device, customer or entity<//><//>`}
             ${(() => {
               const MAX = 8;
               let start = 0;
@@ -127,10 +157,11 @@ export function Composer({ onSubmit, busy, width = 80 }) {
               return window.map((s, wi) => {
                 const i = start + wi;
                 const on = i === sel;
-                const label = (s.cmd + (s.hint ? ' ' + s.hint : '')).padEnd(21);
+                const key = slashMode ? (s.cmd + (s.hint ? ' ' + s.hint : '')) : s.tag;
+                const label = key.padEnd(21);
                 return html`<${Box} key=${'m' + i}>
                   <${Text} color=${on ? C.accent : C.gray}>${on ? glyphs.prompt + ' ' : '  '}<//>
-                  <${Text} color=${on ? C.accent : C.white} bold=${on}>${label}<//>
+                  <${Text} color=${on ? C.accent : slashMode ? C.white : C.cyan} bold=${on}>${label}<//>
                   <${Text} color=${C.gray}>${s.desc}<//>
                 <//>`;
               });

package/src/tui/markdown.js

@@ -1,55 +1,145 @@
-// Minimal, dependency-free markdown → Ink renderer. Supports headings,
-// bold, inline code, bullet/numbered lists and fenced code blocks. Ink
+// Small, dependency-free markdown → Ink renderer. Supports headings, bold,
+// italic, strikethrough, inline code, links, bullet/numbered lists,
+// blockquotes, horizontal rules, fenced code blocks and GFM tables. Ink
 // handles wrapping to the available width automatically.
-import { html, React } from './dom.js';
+import { html } from './dom.js';
 import { Box, Text } from 'ink';
-import { C, glyphs } from './theme.js';
+import { C, glyphs, asciiSafe } from './theme.js';
 
 let keyId = 0;
 const k = () => `md${keyId++}`;
 
-/** Parse a single line into styled Ink <Text> spans (bold, `code`). */
+const stripInline = (s) =>
+  String(s)
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/(^|[^*])\*([^*]+)\*/g, '$1$2')
+    .replace(/_([^_]+)_/g, '$1')
+    .replace(/~~([^~]+)~~/g, '$1')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+
+const cellWidth = (s) => stripInline(s).length;
+
+/** Parse a single line into styled Ink <Text> spans. */
 function renderInline(line) {
   const spans = [];
-  // Tokenise on **bold** and `code`.
-  const re = /(\*\*([^*]+)\*\*|`([^`]+)`)/g;
+  // Order matters: links, bold, strike, italic, code.
+  const re = /(\[([^\]]+)\]\(([^)]+)\)|\*\*([^*]+)\*\*|~~([^~]+)~~|`([^`]+)`|\*([^*]+)\*|_([^_]+)_)/g;
   let last = 0;
   let m;
   while ((m = re.exec(line)) !== null) {
     if (m.index > last) spans.push(html`<${Text} key=${k()}>${line.slice(last, m.index)}<//>`);
-    if (m[2] !== undefined) spans.push(html`<${Text} key=${k()} bold>${m[2]}<//>`);
-    else if (m[3] !== undefined) spans.push(html`<${Text} key=${k()} color=${C.cyan}>${m[3]}<//>`);
+    if (m[2] !== undefined) spans.push(html`<${Text} key=${k()} color=${C.blue} underline>${m[2]}<//>`);
+    else if (m[4] !== undefined) spans.push(html`<${Text} key=${k()} bold>${m[4]}<//>`);
+    else if (m[5] !== undefined) spans.push(html`<${Text} key=${k()} strikethrough color=${C.gray}>${m[5]}<//>`);
+    else if (m[6] !== undefined) spans.push(html`<${Text} key=${k()} color=${C.cyan}>${m[6]}<//>`);
+    else if (m[7] !== undefined) spans.push(html`<${Text} key=${k()} italic>${m[7]}<//>`);
+    else if (m[8] !== undefined) spans.push(html`<${Text} key=${k()} italic>${m[8]}<//>`);
     last = m.index + m[0].length;
   }
   if (last < line.length) spans.push(html`<${Text} key=${k()}>${line.slice(last)}<//>`);
   return spans.length ? spans : [html`<${Text} key=${k()}> <//>`];
 }
 
+const isTableRow = (l) => /^\s*\|.*\|\s*$/.test(l);
+const isTableSep = (l) => /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(l);
+
+const splitCells = (l) =>
+  l.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+
+/** Render a parsed GFM table as an aligned, bordered box. */
+function renderTable(header, rows) {
+  const cols = header.length;
+  const widths = header.map((h, i) =>
+    Math.max(cellWidth(h), ...rows.map((r) => cellWidth(r[i] || ''))),
+  );
+  const bar = glyphs.vbar;
+  const pad = (text, w) => {
+    const gap = Math.max(0, w - cellWidth(text));
+    return ' '.repeat(gap);
+  };
+  const rule = (l, mid, r) =>
+    l + widths.map((w) => (asciiSafe() ? '-' : '─').repeat(w + 2)).join(mid) + r;
+  const A = asciiSafe();
+  const [tl, tm, tr] = A ? ['+', '+', '+'] : ['┌', '┬', '┐'];
+  const [ml, mm, mr] = A ? ['+', '+', '+'] : ['├', '┼', '┤'];
+  const [bl, bm, br] = A ? ['+', '+', '+'] : ['└', '┴', '┘'];
+
+  const line = (cells, color, bold) => html`
+    <${Box} key=${k()}>
+      <${Text} color=${C.gray}>${bar}<//>
+      ${cells.map((cell, i) => html`
+        <${Box} key=${k()}>
+          <${Text}> <//>
+          <${Text} color=${color} bold=${bold}>${renderInline(cell || '')}<//><${Text}>${pad(cell || '', widths[i])} <//>
+          <${Text} color=${C.gray}>${bar}<//>
+        <//>`)}
+    <//>`;
+
+  return html`
+    <${Box} flexDirection="column" key=${k()} marginY=${0}>
+      <${Text} color=${C.gray}>${rule(tl, tm, tr)}<//>
+      ${line(header, C.accent, true)}
+      <${Text} color=${C.gray}>${rule(ml, mm, mr)}<//>
+      ${rows.map((r) => line(r, C.white, false))}
+      <${Text} color=${C.gray}>${rule(bl, bm, br)}<//>
+    <//>`;
+}
+
 /** Render a markdown string as a column of Ink lines. */
 export function Markdown({ content = '' }) {
   const rows = [];
   let inCode = false;
   const lines = String(content).replace(/\s+$/, '').split('\n');
 
-  for (const raw of lines) {
-    const line = raw.replace(/\t/g, '  ');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].replace(/\t/g, '  ');
+
+    // Fenced code block.
+    if (line.trim().startsWith('```')) { inCode = !inCode; continue; }
+    if (inCode) { rows.push(html`<${Text} key=${k()} color=${C.green}>  ${line}<//>`); continue; }
 
-    if (line.trim().startsWith('```')) {
-      inCode = !inCode;
+    // GFM table: header row + separator + body rows.
+    if (isTableRow(line) && i + 1 < lines.length && isTableSep(lines[i + 1])) {
+      const header = splitCells(line);
+      const body = [];
+      i += 2;
+      while (i < lines.length && isTableRow(lines[i])) { body.push(splitCells(lines[i])); i++; }
+      i--;
+      rows.push(renderTable(header, body));
       continue;
     }
-    if (inCode) {
-      rows.push(html`<${Text} key=${k()} color=${C.gray}>  ${line}<//>`);
+
+    // Horizontal rule.
+    if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
+      rows.push(html`<${Text} key=${k()} color=${C.gray}>${(asciiSafe() ? '-' : '─').repeat(40)}<//>`);
       continue;
     }
 
-    const h = line.match(/^(#{1,3})\s+(.*)$/);
+    // Headings.
+    const h = line.match(/^(#{1,6})\s+(.*)$/);
     if (h) {
-      rows.push(html`<${Text} key=${k()} bold color=${C.white}>${h[2]}<//>`);
+      const color = h[1].length === 1 ? C.accent : h[1].length === 2 ? C.cyan : C.white;
+      rows.push(html`
+        <${Box} key=${k()} marginTop=${rows.length ? 1 : 0}>
+          <${Text} bold color=${color}>${stripInline(h[2])}<//>
+        <//>`);
+      continue;
+    }
+
+    // Blockquote.
+    const quote = line.match(/^\s*>\s?(.*)$/);
+    if (quote) {
+      rows.push(html`
+        <${Box} key=${k()}>
+          <${Text} color=${C.accent}>${glyphs.vbar} <//>
+          <${Text} color=${C.gray} italic>${renderInline(quote[1])}<//>
+        <//>`);
       continue;
     }
 
-    const bullet = line.match(/^(\s*)[-*]\s+(.*)$/);
+    // Bullet list.
+    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
     if (bullet) {
       rows.push(html`
         <${Box} key=${k()}>
@@ -59,11 +149,12 @@ export function Markdown({ content = '' }) {
       continue;
     }
 
+    // Numbered list.
     const num = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
     if (num) {
       rows.push(html`
         <${Box} key=${k()}>
-          <${Text} color=${C.accent}>${num[1]}${num[2]}. <//>
+          <${Text} color=${C.accent} bold>${num[1]}${num[2]}. <//>
           <${Text}>${renderInline(num[3])}<//>
         <//>`);
       continue;