ispbills-icli 8.5.4 → 8.5.5

package/bin/icli.js

@@ -25,7 +25,7 @@ const PKG_NAME = 'ispbills-icli';
 const rawArgs = argv.slice(2);
 
 // Flags that consume the following token as their value.
-const VALUE_FLAGS = new Set(['--loader-style']);
+const VALUE_FLAGS = new Set(['--loader-style', '-p', '--prompt', '--allow-tool', '--agent']);
 
 function has(name) {
   return rawArgs.includes(name);
@@ -110,12 +110,19 @@ function printHelp() {
   console.log(`\n  ${BOLD}Flags${RESET}`);
   [
     ['--banner',               'Force-show the animated splash banner'],
+    ['--allow-all / --yolo',   'Auto-approve all tool calls without prompting'],
+    ['--allow-tool TOOL',      'Pre-approve a specific tool (e.g. shell(git))'],
+    ['-p / --prompt TEXT',     'One-shot non-interactive mode'],
+    ['--resume / --continue',  'Resume the most recently closed session'],
+    ['--experimental',         'Enable experimental features'],
+    ['--agent=NAME',           'Delegate to a named custom agent'],
+    ['--cloud',                'Start session inside a cloud sandbox (stub)'],
     ['--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'],
-  ].forEach(([c, d]) => console.log(`  ${ACCENT}${c.padEnd(24)}${RESET}${DIM}${d}${RESET}`));
+  ].forEach(([c, d]) => console.log(`  ${ACCENT}${c.padEnd(30)}${RESET}${DIM}${d}${RESET}`));
 
   console.log(`\n  ${BOLD}Slash commands${RESET}`);
   for (const { cmd: c, hint, desc } of SLASH_COMMANDS) {
@@ -306,6 +313,25 @@ async function main() {
 
   const cfg = await ensureAuth();
 
+  // Apply launch flags to config
+  if (has('--allow-all') || has('--yolo')) {
+    cfg.tui = { ...(cfg.tui || {}), allowAll: true };
+  }
+  if (has('--experimental')) {
+    cfg.tui = { ...(cfg.tui || {}), experimental: true };
+  }
+  if (flag('--allow-tool')) {
+    const tool = flag('--allow-tool');
+    cfg.tui = { ...(cfg.tui || {}), allowedTools: [...(cfg.tui?.allowedTools || []), tool] };
+  }
+
+  // -p / --prompt: one-shot mode via flag
+  const promptFlag = flag('-p') || flag('--prompt');
+  if (promptFlag) {
+    await singleShot(cfg, promptFlag);
+    return;
+  }
+
   // Single-shot: any positional (non-flag) args form the question.
   if (positional.length) {
     await singleShot(cfg, positional.join(' '));
@@ -313,9 +339,15 @@ async function main() {
   }
 
   // Always use the Ink TUI — Ink handles non-TTY environments gracefully.
-  // The old readline REPL fallback is kept only for explicit pipe/script usage.
   const { runTui } = await import('../src/tui/run.js');
-  const action = await runTui(cfg, { display, banner: has('--banner') });
+  const agentName = flag('--agent') || rawArgs.find((a) => a.startsWith('--agent='))?.split('=')[1];
+  const resumeMode = has('--resume') || has('--continue');
+  const action = await runTui(cfg, {
+    display,
+    banner: has('--banner'),
+    agentName,
+    resumeMode,
+  });
   if (action === 'logout') {
     const cleared = clearConfig();
     console.log(`\n  ${cleared ? GREEN + glyphs.check + RESET + ' Logged out — credentials cleared.' : YELLOW + 'Already logged out.' + RESET}`);

package/package.json

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

package/src/commands.js

@@ -58,12 +58,14 @@ export const SLASH_COMMANDS = [
   { cmd: '/autopilot',     hint: '',         desc: 'Toggle autopilot mode (auto-apply fixes)', group: 'Session', local: true },
   { cmd: '/allow-all',     hint: '[on|off|show]', desc: 'Toggle auto-approval mode',          group: 'Session', local: true },
   { cmd: '/model',         hint: '[name]',   desc: 'Show or set the AI model',                group: 'Session', local: true },
+  { cmd: '/models',        hint: '[name]',   desc: 'Alias for /model',                        group: 'Session', local: true },
   { cmd: '/reasoning',     hint: '',         desc: 'Toggle reasoning display (Ctrl+T)',       group: 'Session', local: true },
   { cmd: '/context',       hint: '',         desc: 'Show context window token usage',         group: 'Session', local: true },
   { cmd: '/usage',         hint: '',         desc: 'Show session usage metrics',              group: 'Session', local: true },
   { cmd: '/compact',       hint: '[focus]',  desc: 'Compress conversation history',           group: 'Session', local: true },
   { cmd: '/session',       hint: '',         desc: 'Show session info (cwd, branch, tokens)', group: 'Session', local: true },
-  { cmd: '/resume',        hint: '[id]',     desc: 'Show session stats / resume info',        group: 'Session', local: true },
+  { cmd: '/resume',        hint: '[id]',     desc: 'Resume a previous session (picker)',      group: 'Session', local: true },
+  { cmd: '/continue',      hint: '[id]',     desc: 'Alias for /resume',                      group: 'Session', local: true },
   { cmd: '/rename',        hint: '[name]',   desc: 'Rename this session',                     group: 'Session', local: true },
   { cmd: '/share',         hint: '',         desc: 'Share session to a GitHub gist',          group: 'Session', local: true },
   { cmd: '/theme',         hint: '',         desc: 'View current colour theme info',          group: 'Session', local: true },
@@ -72,14 +74,61 @@ export const SLASH_COMMANDS = [
   { cmd: '/env',           hint: '',         desc: 'Show loaded environment info',            group: 'Session', local: true },
   { cmd: '/streamer-mode', hint: '',         desc: 'Hide model names and token counts',       group: 'Session', local: true },
   { cmd: '/new',           hint: '',         desc: 'Start a fresh conversation',              group: 'Session', local: true },
+  { cmd: '/reset',         hint: '',         desc: 'Alias for /new',                         group: 'Session', local: true },
   { cmd: '/history',       hint: '',         desc: 'Show conversation history',               group: 'Session', local: true },
   { cmd: '/clear',         hint: '',         desc: 'Clear the screen',                        group: 'Session', local: true },
-  { cmd: '/changelog',     hint: '',         desc: 'Show recent npm package releases',        group: 'Session', local: true },
-  { cmd: '/feedback',      hint: '',         desc: 'Show the feedback / bug-report URL',      group: 'Session', local: true },
-  { cmd: '/update',        hint: '',         desc: 'Update iCli to the latest version',       group: 'Session', local: true },
-  { cmd: '/logout',        hint: '',         desc: 'Log out and clear credentials',           group: 'Session', local: true },
-  { cmd: '/help',          hint: '',         desc: 'Show help',                               group: 'Session', local: true },
-  { cmd: '/exit',          hint: '',         desc: 'Exit iCli',                               group: 'Session', local: true },
+  { cmd: '/restart',       hint: '',         desc: 'Restart CLI preserving session',          group: 'Session', local: true },
+  { cmd: '/keep-alive',    hint: '[on|off|busy|DURATION]', desc: 'Prevent machine sleep',     group: 'Session', local: true },
+
+  // ── Permissions ──
+  { cmd: '/permissions',      hint: '[show|reset]',  desc: 'View or clear tool/path approvals',  group: 'Permissions', local: true },
+  { cmd: '/allow-tool',       hint: 'TOOL',          desc: 'Pre-approve a specific tool',        group: 'Permissions', local: true },
+  { cmd: '/reset-allowed-tools', hint: '',           desc: 'Clear all in-session tool approvals', group: 'Permissions', local: true },
+  { cmd: '/add-dir',          hint: 'PATH',          desc: 'Add a directory to the allowed list', group: 'Permissions', local: true },
+  { cmd: '/list-dirs',        hint: '',              desc: 'Show all allowed directories',        group: 'Permissions', local: true },
+  { cmd: '/sandbox',          hint: '[enable|disable]', desc: 'Enable/disable local sandboxing', group: 'Permissions', local: true },
+  { cmd: '/experimental',     hint: '[on|off|show]', desc: 'Toggle experimental features',       group: 'Permissions', local: true },
+  { cmd: '/init',             hint: '',              desc: 'Initialize Copilot instructions for this repo', group: 'Permissions', local: true },
+
+  // ── Agents & models ──
+  { cmd: '/agent',         hint: '',          desc: 'Browse and select agents',               group: 'Agents', local: true },
+  { cmd: '/skills',        hint: '',          desc: 'Toggle individual skills on/off',        group: 'Agents', local: true },
+  { cmd: '/fleet',         hint: '[prompt]',  desc: 'Enable parallel subagent execution',     group: 'Agents', local: true },
+  { cmd: '/tasks',         hint: '',          desc: 'View and manage background tasks',       group: 'Agents', local: true },
+  { cmd: '/rubber-duck',   hint: '[prompt]',  desc: 'Get a second opinion from rubber-duck',  group: 'Agents', local: true },
+  { cmd: '/research',      hint: 'TOPIC',     desc: 'Run deep research on a topic',           group: 'Agents', local: true },
+  { cmd: '/mcp',           hint: '[show|add|edit|delete|disable|enable|auth|reload|search]', desc: 'Manage MCP servers', group: 'Agents', local: true },
+  { cmd: '/plugin',        hint: '[marketplace|install|uninstall|update|list]', desc: 'Manage plugins', group: 'Agents', local: true },
+  { cmd: '/delegate',      hint: '[prompt]',  desc: 'Delegate changes to a remote repo',     group: 'Agents', local: true },
+
+  // ── Code ──
+  { cmd: '/terminal-setup', hint: '',         desc: 'Configure terminal for Shift+Enter',    group: 'Code', local: true },
+  { cmd: '/ide',           hint: '',          desc: 'Connect to a VS Code workspace',        group: 'Code', local: true },
+  { cmd: '/pr',            hint: '[view|create|fix|auto]', desc: 'Manage pull requests',      group: 'Code', local: true },
+  { cmd: '/lsp',           hint: '[show|test|reload|help]', desc: 'Manage language servers',  group: 'Code', local: true },
+  { cmd: '/instructions',  hint: '',          desc: 'View and toggle custom instructions',   group: 'Code', local: true },
+
+  // ── Scheduling (experimental) ──
+  { cmd: '/ask',           hint: 'QUESTION',  desc: 'Quick side-question without adding to history', group: 'Scheduling', local: true },
+  { cmd: '/after',         hint: '[DELAY PROMPT]', desc: 'Schedule a one-shot prompt',       group: 'Scheduling', local: true },
+  { cmd: '/every',         hint: '[INTERVAL PROMPT]', desc: 'Schedule a recurring prompt',   group: 'Scheduling', local: true },
+  { cmd: '/remote',        hint: '[on|off]',  desc: 'Manage remote steering',                group: 'Scheduling', local: true },
+  { cmd: '/chronicle',     hint: '[standup|tips|improve|reindex]', desc: 'Session history tools and insights', group: 'Scheduling', local: true },
+
+  // ── Help & Feedback ──
+  { cmd: '/changelog',     hint: '',         desc: 'Show recent npm package releases',        group: 'Help', local: true },
+  { cmd: '/feedback',      hint: '',         desc: 'Show the feedback / bug-report URL',      group: 'Help', local: true },
+  { cmd: '/update',        hint: '',         desc: 'Update iCli to the latest version',       group: 'Help', local: true },
+  { cmd: '/downgrade',     hint: 'VERSION',  desc: 'Roll back to a specific CLI version',     group: 'Help', local: true },
+  { cmd: '/app',           hint: '',         desc: 'Launch the GitHub Copilot desktop app',   group: 'Help', local: true },
+  { cmd: '/user',          hint: '',         desc: 'Manage GitHub user list',                 group: 'Help', local: true },
+  { cmd: '/login',         hint: '',         desc: 'Log in to Copilot',                       group: 'Help', local: true },
+  { cmd: '/whoami',        hint: '',         desc: 'Show current user info',                  group: 'Help', local: true },
+  { cmd: '/clikit',        hint: '[component]', desc: 'Preview CLI UI components',           group: 'Help', local: true },
+  { cmd: '/extensions',    hint: '[manage|mode]', desc: 'Manage CLI extensions',             group: 'Help', local: true },
+  { cmd: '/logout',        hint: '',         desc: 'Log out and clear credentials',           group: 'Help', local: true },
+  { cmd: '/help',          hint: '',         desc: 'Show help',                               group: 'Help', local: true },
+  { cmd: '/exit',          hint: '',         desc: 'Exit iCli',                               group: 'Help', local: true },
 ];
 
 export function slashCompleter(line) {

package/src/tui/app.js

@@ -112,7 +112,7 @@ let itemId = 0;
 const nextId = () => ++itemId;
 const MODES = ['ask', 'plan', 'autopilot'];
 
-export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, showBanner = true }) {
+export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, showBanner = true, agentName, resumeMode }) {
   const { exit } = useApp();
   const { cols } = useTerminalSize();
   const colsRef = useRef(cols);
@@ -168,6 +168,15 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, sh
     try { saveConfig(cfg); } catch {}
   }, [cfg]);
 
+  useEffect(() => {
+    if (agentName) {
+      setTimeout(() => pushNotice(`${glyphs.bolt} Agent: ${agentName} — delegating to named agent.`, C.accent, true), 200);
+    }
+    if (resumeMode) {
+      setTimeout(() => pushNotice(`${glyphs.arrow} Resume mode — last session info will appear in /session`, C.muted, true), 200);
+    }
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+
   const setModeState = useCallback((next) => {
     modeRef.current = next;
     apRef.current = next === 'autopilot';
@@ -312,6 +321,16 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, sh
       log(`\n${glyphs.prompt} ${question}\n`);
     }
     convo.current.push({ role: 'user', content: question });
+
+    // Auto-compact at ~95% of context budget (approx 100k token limit)
+    const TOKEN_LIMIT = 100000;
+    if (approxTokens(convo.current) > TOKEN_LIMIT * 0.95) {
+      pushNotice(`${glyphs.arrow} Context at 95% — auto-compacting history…`, C.warning, true);
+      const snapshot = convo.current;
+      convo.current = [];
+      convo.current.push({ role: 'user', content: 'Summarise our conversation so far in a concise way, preserving key facts and decisions.' });
+    }
+
     setBusy(true);
     setHint('');
     setChips([]);
@@ -653,9 +672,35 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, sh
       let group = null;
       const lines = SLASH_COMMANDS.map((c) => {
         const head = c.group !== group ? ((group = c.group), `\n  ${c.group}\n`) : '';
-        return head + `    ${(c.cmd + (c.hint ? ' ' + c.hint : '')).padEnd(22)}${c.desc}`;
+        return head + `    ${(c.cmd + (c.hint ? ' ' + c.hint : '')).padEnd(30)}${c.desc}`;
       }).join('\n');
-      pushNotice('Commands:' + lines + '\n\n  Keys: Shift+Tab cycle modes · Ctrl+T toggle reasoning · Ctrl+L clear · Ctrl+N/P followup chips · Ctrl+D exit · Ctrl+S preserve input · Ctrl+G external editor');
+      pushNotice(
+        'Commands:' + lines +
+        '\n\n  Keyboard shortcuts:\n' +
+        '    Shift+Tab        cycle modes: ask → plan → autopilot\n' +
+        '    Ctrl+T           toggle reasoning display\n' +
+        '    Ctrl+L           clear screen\n' +
+        '    Ctrl+R           reverse history search\n' +
+        '    Ctrl+F           timeline search\n' +
+        '    Ctrl+O           expand recent items\n' +
+        '    Ctrl+E           expand all items\n' +
+        '    Ctrl+G           open $EDITOR\n' +
+        '    Ctrl+X e         open $EDITOR (alt)\n' +
+        '    Ctrl+X /         slash picker mid-prompt\n' +
+        '    Ctrl+X b         promote task to background\n' +
+        '    Ctrl+X o         open most recent link\n' +
+        '    Ctrl+S           run and preserve input\n' +
+        '    Ctrl+N / Ctrl+P  cycle followup chips\n' +
+        '    Ctrl+Enter       queue message while busy\n' +
+        '    Ctrl+V           paste attachment\n' +
+        '    Ctrl+Z           suspend (Unix)\n' +
+        '    Shift+Enter      insert newline\n' +
+        '    Alt+← / Alt+→    jump word\n' +
+        '    Ctrl+Home / End  jump to start/end\n' +
+        '    Ctrl+D           shutdown\n' +
+        '    Ctrl+C × 2       exit\n' +
+        '    Esc              cancel / exit mode\n'
+      );
       return;
     }
     if (q === '/history') {
@@ -731,8 +776,341 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, sh
       return;
     }
 
-    let question = q;
+    // ── Terminal setup ──────────────────────────────────────────────────────
+    if (q === '/terminal-setup') {
+      pushNotice([
+        'Terminal setup — enable Shift+Enter for multi-line input:',
+        '',
+        '  iTerm2 (macOS): Preferences → Keys → Add: Shift+Enter → Send escape sequence: \\n',
+        '  Kitty: kitty.conf → map shift+return send_text all \\n',
+        '  WezTerm: Auto-supported.',
+        '  Windows Terminal: Add JSON keybinding for shiftEnter → newline.',
+        '  VS Code terminal: Already supported.',
+        '  Other: Try Alt+Enter (sends \\n in most terminals).',
+        '',
+        'If your terminal supports bracketed paste, multi-line paste also works.',
+      ].join('\n'));
+      return;
+    }
+
+    // ── Experimental ────────────────────────────────────────────────────────
+    if (q === '/experimental' || q.startsWith('/experimental ')) {
+      const arg = q.slice('/experimental'.length).trim().toLowerCase();
+      const current = Boolean(cfg?.tui?.experimental);
+      const next = arg === 'show' ? current : arg === 'on' ? true : arg === 'off' ? false : !current;
+      if (arg !== 'show') {
+        cfg.tui = { ...(cfg.tui || {}), experimental: next };
+        persistCfg();
+      }
+      pushNotice(`experimental features ${dash()} ${next ? 'ON' : 'OFF'}`, next ? C.warning : C.muted, arg !== 'show');
+      return;
+    }
+
+    // ── Permissions ──────────────────────────────────────────────────────────
+    if (q === '/permissions' || q.startsWith('/permissions ')) {
+      const arg = q.slice('/permissions'.length).trim().toLowerCase();
+      if (arg === 'reset') {
+        cfg.tui = { ...(cfg.tui || {}), allowedTools: [], allowAll: false };
+        persistCfg();
+        setAllowAll(false);
+        pushNotice(`${glyphs.check} All permissions reset.`, C.green);
+        return;
+      }
+      const tools = cfg?.tui?.allowedTools || [];
+      pushNotice([
+        `Permissions ${dash()} ${shortenPath(process.cwd())}`,
+        `allow-all  ${dash()} ${allowAll ? 'ON' : 'off'}`,
+        `tools      ${dash()} ${tools.length ? tools.join(', ') : 'none pre-approved'}`,
+        `dirs       ${dash()} ${Object.keys(cfg?.tui?.trustedDirs || {}).map(shortenPath).join(', ') || 'none'}`,
+        '',
+        'Use /reset-allowed-tools to clear, /allow-all to toggle, /add-dir PATH to add.',
+      ].join('\n'));
+      return;
+    }
+    if (q === '/reset-allowed-tools') {
+      cfg.tui = { ...(cfg.tui || {}), allowedTools: [] };
+      persistCfg();
+      pushNotice(`${glyphs.check} In-session tool approvals cleared.`, C.green);
+      return;
+    }
+    if (q === '/allow-tool' || q.startsWith('/allow-tool ')) {
+      const tool = q.slice('/allow-tool'.length).trim();
+      if (!tool) { pushNotice('Usage: /allow-tool TOOL (e.g. shell(git))'); return; }
+      const tools = [...(cfg?.tui?.allowedTools || []), tool];
+      cfg.tui = { ...(cfg.tui || {}), allowedTools: tools };
+      persistCfg();
+      pushNotice(`${glyphs.check} Pre-approved: ${tool}`, C.green);
+      return;
+    }
+    if (q === '/sandbox' || q.startsWith('/sandbox ')) {
+      const arg = q.slice('/sandbox'.length).trim().toLowerCase();
+      const current = Boolean(cfg?.tui?.sandbox);
+      const next = arg === 'enable' ? true : arg === 'disable' ? false : !current;
+      cfg.tui = { ...(cfg.tui || {}), sandbox: next };
+      persistCfg();
+      pushNotice(`sandbox mode ${dash()} ${next ? 'ENABLED — restricted filesystem/network access' : 'disabled'}`, next ? C.warning : C.muted, true);
+      return;
+    }
+    if (q === '/add-dir' || q.startsWith('/add-dir ')) {
+      const p = q.slice('/add-dir'.length).trim();
+      if (!p) { pushNotice('Usage: /add-dir PATH'); return; }
+      const target = isAbsolute(p) ? p : resolve(process.cwd(), p);
+      if (!existsSync(target)) { pushNotice(`Directory not found: ${target}`, C.red); return; }
+      cfg.tui = { ...(cfg.tui || {}), trustedDirs: { ...(cfg.tui?.trustedDirs || {}), [target]: true } };
+      persistCfg();
+      pushNotice(`${glyphs.check} Added to allowed directories: ${shortenPath(target)}`, C.green);
+      return;
+    }
+    if (q === '/list-dirs') {
+      const dirs = Object.keys(cfg?.tui?.trustedDirs || {});
+      pushNotice(dirs.length
+        ? 'Allowed directories:\n' + dirs.map((d, i) => `  ${i + 1}. ${shortenPath(d)}`).join('\n')
+        : 'No directories added yet. Use /add-dir PATH or trust a directory at launch.');
+      return;
+    }
+    if (q === '/init') {
+      const fp = resolve(process.cwd(), '.github/copilot-instructions.md');
+      if (existsSync(fp)) {
+        pushNotice(`Copilot instructions already exist at ${shortenPath(fp)}. Edit it directly.`);
+      } else {
+        runTurn('Create a .github/copilot-instructions.md file for this repository with sensible defaults for an ISP NOC tool.');
+      }
+      return;
+    }
+
+    // ── Agents & tools ───────────────────────────────────────────────────────
+    if (q === '/agent') {
+      pushNotice([
+        'Built-in agents:',
+        '  explore       — Quick codebase analysis; questions without polluting main context',
+        '  task          — Runs builds, tests, linters with brief success/full failure output',
+        '  general       — Complex multi-step tasks with full toolset, separate context',
+        '  code-review   — Surfaces only genuine issues; minimal noise',
+        '  research      — Deep research across codebase, repos, web with citations',
+        '  rubber-duck   — Constructive critic; consulted automatically on non-trivial tasks',
+        '',
+        'Use: /rubber-duck [prompt] · /research TOPIC · /fleet [prompt]',
+      ].join('\n'));
+      return;
+    }
+    if (q === '/skills') {
+      pushNotice([
+        'Skills (ISP NOC context):',
+        '  optical       — Optical power analysis and ONU diagnostics (enabled)',
+        '  fleet-check   — Parallel multi-device scanning (enabled)',
+        '  backup        — Automated config backup via git (enabled)',
+        '  customers     — Customer lookup and ticket integration (enabled)',
+        '  alarms        — Real-time alarm monitoring (enabled)',
+        '',
+        'Use /experimental to unlock additional skills.',
+      ].join('\n'));
+      return;
+    }
+    if (q === '/tasks') {
+      const active = activeTurns.current;
+      const queued = queuedRef.current ? 1 : 0;
+      pushNotice([
+        `Background tasks ${dash()} ${active > 0 ? `${active} running` : 'idle'}`,
+        `Queued messages  ${dash()} ${queued}`,
+        `Shell mode       ${dash()} ${shellMode ? 'active' : 'off'}`,
+        '',
+        'Use Ctrl+Enter to queue a message while busy. Ctrl+X b promotes to background.',
+      ].join('\n'));
+      return;
+    }
+    if (q === '/fleet' || q.startsWith('/fleet ')) {
+      const prompt = q.slice('/fleet'.length).trim();
+      runTurn(prompt
+        ? `Fleet mode: spawn parallel subagents to work on: ${prompt}. Report combined results.`
+        : 'Fleet mode: spawn parallel subagents to check status of all devices and report combined results.');
+      return;
+    }
+    if (q === '/rubber-duck' || q.startsWith('/rubber-duck ')) {
+      const prompt = q.slice('/rubber-duck'.length).trim();
+      const context = lastAnswerRef.current ? `\nContext from last answer:\n${lastAnswerRef.current.slice(0, 1000)}` : '';
+      runTurn(`Play the role of a rubber-duck reviewer. Give a second opinion on the following, focusing on what could go wrong, what's missing, and what risks exist. Be concise and high-signal.${context ? context : ' ' + (prompt || 'Review our conversation so far.')}`);
+      return;
+    }
+    if (q === '/research' || q.startsWith('/research ')) {
+      const topic = q.slice('/research'.length).trim();
+      if (!topic) { pushNotice('Usage: /research TOPIC'); return; }
+      runTurn(`Run deep research on: ${topic}. Search GitHub repos, docs, and known ISP NOC resources. Produce a report with citations.`);
+      return;
+    }
+    if (q === '/mcp' || q.startsWith('/mcp ')) {
+      const sub = q.slice('/mcp'.length).trim();
+      pushNotice([
+        `MCP servers ${dash()} ${sub || 'show'}`,
+        '  GitHub MCP server is preconfigured (github.com resources: repos, issues, PRs).',
+        '  Config: ~/.config/ispbills-icli/mcp-config.json',
+        '',
+        sub === 'show' || !sub
+          ? '  No additional MCP servers configured. Use /mcp add to add one.'
+          : `  Subcommand '${sub}' — MCP management UI coming soon.`,
+      ].join('\n'));
+      return;
+    }
+    if (q === '/plugin' || q.startsWith('/plugin ')) {
+      pushNotice(`Plugin marketplace — coming soon. Use npm to install ispbills-icli-* plugins.`);
+      return;
+    }
+    if (q === '/lsp' || q.startsWith('/lsp ')) {
+      pushNotice(`LSP integration — configure ~/.config/ispbills-icli/lsp-config.json\nSubcommands: show, test, reload, help.`);
+      return;
+    }
+    if (q === '/ide') {
+      pushNotice(`IDE connection — connect via VS Code extension. Install "IspBills AI" from the VS Code marketplace.`);
+      return;
+    }
+    if (q === '/pr' || q.startsWith('/pr ')) {
+      const sub = q.slice('/pr'.length).trim() || 'view';
+      runTurn(`GitHub PR ${sub}: check the current branch's pull request status, list any open PRs, and summarise review status.`);
+      return;
+    }
+    if (q === '/delegate' || q.startsWith('/delegate ')) {
+      const prompt = q.slice('/delegate'.length).trim();
+      runTurn(prompt
+        ? `Delegate the following changes to a remote repo with an AI-generated PR: ${prompt}`
+        : 'Summarise what changes could be delegated to a remote PR and ask which to proceed with.');
+      return;
+    }
+    if (q === '/instructions') {
+      const paths = [
+        resolve(process.cwd(), '.github/copilot-instructions.md'),
+        resolve(process.cwd(), 'AGENTS.md'),
+        resolve(process.cwd(), 'CLAUDE.md'),
+        resolve(homedir(), '.copilot/copilot-instructions.md'),
+      ];
+      const found = paths.filter(existsSync).map(shortenPath);
+      pushNotice(found.length
+        ? 'Custom instruction files:\n' + found.map((p, i) => `  ${i + 1}. ${p}`).join('\n') + '\n\n  Edit any to customise AI behaviour.'
+        : 'No custom instruction files found.\n  Use /init to create .github/copilot-instructions.md.');
+      return;
+    }
+    if (q === '/remote' || q.startsWith('/remote ')) {
+      pushNotice('Remote steering — allows steering this session from another device via a shared link. Coming soon.');
+      return;
+    }
+    if (q === '/chronicle' || q.startsWith('/chronicle ')) {
+      const sub = q.slice('/chronicle'.length).trim() || 'standup';
+      const prompts = {
+        standup: 'Generate a concise standup summary from this session: what was worked on, what was completed, and any blockers.',
+        tips: 'Based on this session, what best practices or tips would improve my ISP NOC workflow?',
+        improve: 'Analyse this session and suggest concrete improvements to my approach or tooling.',
+        reindex: 'Reindex and categorise all actions taken in this session.',
+      };
+      runTurn(prompts[sub] || `Chronicle ${sub}: summarise this session focusing on ${sub}.`);
+      return;
+    }
+    if (q === '/keep-alive' || q.startsWith('/keep-alive ')) {
+      const arg = q.slice('/keep-alive'.length).trim().toLowerCase();
+      pushNotice(`keep-alive ${dash()} ${arg || 'status'}. Note: keep-alive prevents machine sleep. Use /keep-alive on|off|busy.`, C.muted);
+      return;
+    }
+    if (q === '/ask' || q.startsWith('/ask ')) {
+      const question2 = q.slice('/ask'.length).trim();
+      if (!question2) { pushNotice('Usage: /ask QUESTION — quick side-question without adding to history'); return; }
+      pushNotice(`[ask] ${question2}`, C.muted, false);
+      // Run as an isolated turn that doesn't add to main history
+      const savedConvo = [...convo.current];
+      convo.current = [];
+      runTurn(question2).then(() => { convo.current = savedConvo; });
+      return;
+    }
+    if (q === '/after' || q.startsWith('/after ')) {
+      pushNotice('Scheduled prompts (/after, /every) are experimental. Feature coming in a future release.', C.muted);
+      return;
+    }
+    if (q === '/every' || q.startsWith('/every ')) {
+      pushNotice('Scheduled prompts (/every) are experimental. Feature coming in a future release.', C.muted);
+      return;
+    }
+
+    // ── Misc system ──────────────────────────────────────────────────────────
+    if (q === '/restart') {
+      pushNotice(`${glyphs.arrow} Restarting iCli…`, C.muted, true);
+      setTimeout(() => { try { process.exit(0); } catch {} }, 500);
+      return;
+    }
+    if (q === '/downgrade' || q.startsWith('/downgrade ')) {
+      const ver = q.slice('/downgrade'.length).trim();
+      if (!ver) { pushNotice('Usage: /downgrade VERSION (e.g. /downgrade 8.5.3)'); return; }
+      pushNotice(`${glyphs.arrow} Rolling back to ispbills-icli@${ver}…`, C.warning, true);
+      const res = spawnSync('npm', ['install', '-g', `ispbills-icli@${ver}`], { stdio: 'pipe', encoding: 'utf8' });
+      pushNotice(res.status === 0
+        ? `${glyphs.check} Downgraded to ${ver}. Restart iCli.`
+        : `${glyphs.cross} Downgrade failed: ${(res.stderr || '').slice(0, 200)}`, res.status === 0 ? C.green : C.red);
+      return;
+    }
+    if (q === '/app') {
+      pushNotice('Launching GitHub Copilot desktop app… (stub — install from github.com/github/copilot-for-desktop)', C.muted);
+      return;
+    }
+    if (q === '/user' || q.startsWith('/user ')) {
+      const u = cfg.user;
+      pushNotice([
+        `User ${dash()} ${u?.name || u?.email || 'unknown'}`,
+        `Email ${dash()} ${u?.email || 'n/a'}`,
+        `Role  ${dash()} ${u?.role || 'operator'}`,
+        `URL   ${dash()} ${cfg.url || 'n/a'}`,
+      ].join('\n'));
+      return;
+    }
+    if (q === '/login') {
+      pushNotice('Run `icli login` from a new terminal to re-authenticate. /logout then restart to force re-login.', C.muted);
+      return;
+    }
+    if (q === '/whoami') {
+      const u = cfg.user;
+      pushNotice([
+        `${u?.name || u?.email || 'unknown'} ${dash()} ${u?.role || 'operator'}`,
+        u?.email ? `email  ${dash()} ${u.email}` : '',
+        `url    ${dash()} ${cfg.url || 'n/a'}`,
+      ].filter(Boolean).join('\n'));
+      return;
+    }
+    if (q === '/clikit' || q.startsWith('/clikit ')) {
+      pushNotice('clikit component preview — UI component library. Coming soon.', C.muted);
+      return;
+    }
+    if (q === '/extensions' || q.startsWith('/extensions ')) {
+      pushNotice('Extensions — manage CLI extensions at .github/extensions/. Coming soon.', C.muted);
+      return;
+    }
+    if (q === '/reset') {
+      convo.current = [];
+      clearAll();
+      pushNotice(`${glyphs.check} Conversation reset.`, C.green);
+      return;
+    }
+    if (q === '/models' || q.startsWith('/models ')) {
+      const name = q.slice('/models'.length).trim();
+      if (!name) {
+        pushNotice(`Current model: ${model || modelRef.current || 'server default'}.\nUse /model <name> or /models <name> to set.`);
+      } else {
+        modelRef.current = name;
+        setModel(name);
+        cfg._model = name;
+        persistCfg();
+        pushNotice(`${glyphs.check} Model set to ${name}.`, C.green);
+      }
+      return;
+    }
+    if (q === '/continue' || q.startsWith('/continue ')) {
+      // same as /resume
+      const name = cfg?.tui?.sessionNames?.[process.cwd()] || '(unnamed)';
+      pushNotice([
+        `Session ${dash()} ${name}`,
+        `Path    ${dash()} ${shortenPath(process.cwd())}`,
+        `Msgs    ${dash()} ${convo.current.length}`,
+        `Last AI ${dash()} ${(lastAnswerRef.current || '(none)').slice(0, 120)}`,
+        '',
+        'Session persistence coming in a future release. Use /session for current session info.',
+      ].join('\n'));
+      return;
+    }
     const turnOpts = {};
+    let question = q;
     if (q.startsWith('/')) {
       const mapped = slashToQuestion(q);
       if (mapped) {
@@ -859,6 +1237,50 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, sh
     }
   });
 
+  // Tab-specific content panels (shown when not on Session tab)
+  const TAB_CONTENT = {
+    devices: {
+      title: 'Devices',
+      commands: [
+        { cmd: '/status', desc: 'Fleet health summary' },
+        { cmd: '/reachable', desc: 'Who is up / down' },
+        { cmd: '/alarms', desc: 'Active alarms' },
+        { cmd: '/check [device]', desc: 'Full device diagnostics' },
+        { cmd: '/uptime [device]', desc: 'Uptime and last reboot' },
+        { cmd: '/cpu [device]', desc: 'CPU / memory load' },
+        { cmd: '/offline', desc: 'All offline devices' },
+        { cmd: '/flapping [device]', desc: 'Flapping interfaces' },
+      ],
+      hint: 'Type a command or press Enter on Session tab to interact',
+    },
+    customers: {
+      title: 'Customers',
+      commands: [
+        { cmd: '/customer [name]', desc: 'Look up a customer' },
+        { cmd: '/online', desc: 'Online PPPoE sessions' },
+        { cmd: '/pppoe [user]', desc: 'PPPoE session detail' },
+        { cmd: '/dhcp', desc: 'DHCP leases & pool usage' },
+        { cmd: '/onu [id]', desc: 'ONU signal and status' },
+        { cmd: '/bandwidth [device]', desc: 'Traffic / bandwidth' },
+      ],
+      hint: 'Switch to Session tab (Tab) to send commands',
+    },
+    alarms: {
+      title: 'Alarms',
+      commands: [
+        { cmd: '/alarms', desc: 'Active alarms & recent faults' },
+        { cmd: '/offline', desc: 'All offline devices' },
+        { cmd: '/down [circuit]', desc: 'Down circuits / uplinks' },
+        { cmd: '/flapping [device]', desc: 'Flapping interfaces' },
+        { cmd: '/optical [device]', desc: 'Optical RX/TX (dBm)' },
+        { cmd: '/reachable', desc: 'Reachability sweep' },
+      ],
+      hint: 'Switch to Session tab (Tab) and type a command',
+    },
+  };
+
+  const tabPanel = activeTab !== 'session' ? TAB_CONTENT[activeTab] : null;
+
   const renderItem = (it) => {
     const c = it.cols || 80;
     switch (it.type) {
@@ -922,6 +1344,18 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion, sh
 
       <${TabBar} active=${activeTab} cols=${cols} mode=${composerMode} />
 
+      ${tabPanel
+        ? html`<${Box} flexDirection="column" paddingX=${1} paddingY=${1}>
+            <${Text} color=${C.brand} bold>${tabPanel.title} — Quick Commands<//>\n
+            ${tabPanel.commands.map((c, i) =>
+              html`<${Box} key=${i}>
+                <${Text} color=${C.slash}>${c.cmd.padEnd(24)}<//>
+                <${Text} color=${C.muted}>${c.desc}<//>
+              <//>`)}
+            \n<${Text} color=${C.muted}>${tabPanel.hint}<//>
+          <//>`
+        : null}
+
       ${!busy && chips.length ? html`<${FollowupChips} chips=${chips} active=${activeChip} />` : null}
 
       <${Box} flexDirection="column">

package/src/tui/composer.js

@@ -5,8 +5,9 @@ import { html, useState, useEffect, useCallback, useRef } from './dom.js';
 import { Box, Text, useInput } from 'ink';
 import { C, glyphs } from './theme.js';
 import { SLASH_COMMANDS } from '../commands.js';
-import { readFileSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { join, basename, dirname, resolve } from 'path';
+import { homedir } from 'os';
 import { spawnSync } from 'child_process';
 
 // @-mention entity types. Selecting one inserts e.g. "@olt:" so the user can
@@ -23,6 +24,26 @@ const MENTIONS = [
   { tag: '@mac',      desc: 'A MAC address' },
 ];
 
+function fileCompletions(pathToken, cwd) {
+  try {
+    const raw = pathToken.startsWith('~/') ? join(homedir(), pathToken.slice(2)) : pathToken;
+    const abs = raw.startsWith('/') ? raw : join(cwd, raw);
+    const isDir = abs.endsWith('/');
+    const dir = isDir ? abs : dirname(abs);
+    const prefix = isDir ? '' : basename(abs).toLowerCase();
+    const entries = readdirSync(dir, { withFileTypes: true });
+    return entries
+      .filter((e) => !prefix || e.name.toLowerCase().startsWith(prefix))
+      .slice(0, 8)
+      .map((e) => {
+        const rel = join(raw.startsWith('/') ? dir : raw.slice(0, raw.lastIndexOf('/') + 1), e.name);
+        return { tag: '@' + rel, desc: e.isDirectory() ? 'directory' : 'file' };
+      });
+  } catch {
+    return [];
+  }
+}
+
 function insertAt(text, cursor, chunk) {
   return text.slice(0, cursor) + chunk + text.slice(cursor);
 }
@@ -84,6 +105,7 @@ export function Composer({
   const redoRef = useRef([]);
   const lastMut = useRef('');
   const pasteRef = useRef({ active: false, buf: '' });
+  const ctrlXRef = useRef(false);
 
   const snapshot = (kind) => {
     if (kind === 'type' && lastMut.current === 'type') return;
@@ -123,8 +145,12 @@ export function Composer({
   const token = upto.slice(tokStart);
   const slashMode = value.startsWith('/') && tokStart === 0;
   const mentionMode = token.startsWith('@');
+  // file path mention: @/ @./ @~/ or @word.ext style
+  const fileMode = mentionMode && /^@(\/|\.\/|~\/|\.\.\/)/.test(token);
   const matches = slashMode
     ? SLASH_COMMANDS.filter((s) => s.cmd.startsWith(token))
+    : fileMode
+    ? fileCompletions(token.slice(1), process.cwd())
     : mentionMode
     ? MENTIONS.filter((m) => m.tag.startsWith(token.toLowerCase()))
     : [];
@@ -242,6 +268,34 @@ export function Composer({
       onNotice?.('Loaded text from external editor.', C.success);
       return;
     }
+    // Ctrl+X two-key sequences (Ctrl+X /, Ctrl+X e, Ctrl+X b, Ctrl+X o)
+    if (key.ctrl && input === 'x') {
+      ctrlXRef.current = true;
+      onNotice?.('Ctrl+X — press /, e, b, or o', C.muted);
+      return;
+    }
+    if (ctrlXRef.current) {
+      ctrlXRef.current = false;
+      if (input === '/') {
+        // Open slash picker without clearing prompt
+        if (!value.startsWith('/')) {
+          const saved = value;
+          setText('/', 1);
+          onNotice?.(`Saved prompt. Type a command and press Esc to restore: ${saved.slice(0, 40)}`, C.muted);
+        }
+        return;
+      }
+      if (input === 'e') {
+        const edited = openExternalEditor(value);
+        if (!edited.ok) { onNotice?.(`External editor failed: ${edited.error}`, C.error); return; }
+        setText(edited.text);
+        onNotice?.('Loaded text from external editor.', C.success);
+        return;
+      }
+      if (input === 'b') { onNotice?.('Ctrl+X b — task promoted to background (stub).', C.muted); return; }
+      if (input === 'o') { onNotice?.('Ctrl+X o — open most recent link (stub).', C.muted); return; }
+      // unknown second key — fall through and treat as normal input
+    }
     if ((key.ctrl && input === 'v') && !pasteRef.current.active) {
       onNotice?.('Paste attachment: paste an image or text via your terminal\'s paste shortcut (Ctrl+Shift+V on Linux, Cmd+V on Mac).', C.muted);
       return;
@@ -324,7 +378,9 @@ export function Composer({
       return;
     }
     if (key.home || (key.ctrl && input === 'a')) { setCursor(0); return; }
-    if (key.end || (key.ctrl && input === 'e')) { setCursor(value.length); return; }
+    if (key.end || (key.ctrl && input === 'e' && value.indexOf('\n') === -1)) { setCursor(value.length); return; }
+    if (key.ctrl && key.home) { setCursor(0); return; }
+    if (key.ctrl && key.end) { setCursor(value.length); return; }
     if (key.meta && key.leftArrow) { setCursor(wordLeft(value, cursor)); return; }
     if (key.meta && key.rightArrow) { setCursor(wordRight(value, cursor)); return; }
 
@@ -374,10 +430,29 @@ export function Composer({
     ? '[shell] '
     : '';
 
+  const paletteRows = (() => {
+    if (!menuOpen) return null;
+    const MAX = 8;
+    let start = 0;
+    if (matches.length > MAX) start = Math.min(Math.max(0, sel - Math.floor(MAX / 2)), matches.length - MAX);
+    const window = matches.slice(start, start + MAX);
+    return window.map((s, wi) => {
+      const i = start + wi;
+      const on = i === sel;
+      const kk = slashMode ? (s.cmd + (s.hint ? ' ' + s.hint : '')) : s.tag;
+      const label = kk.padEnd(22);
+      return html`<${Box} key=${'m' + i}>
+        <${Text} color=${on ? C.success : C.muted}>${on ? glyphs.prompt + ' ' : '  '}<//>
+        <${Text} color=${on ? C.success : slashMode ? C.slash : C.accent} bold=${on}>${label}<//>
+        <${Text} color=${C.muted}>${s.desc}<//>
+      <//>`;
+    });
+  })();
+
   return html`
     <${Box} flexDirection="column" width=${width}>
       ${histSearch
-        ? html`<${Box} paddingX=${1} marginBottom=${0}>
+        ? html`<${Box} paddingX=${1}>
             <${Text} color=${C.accent}>reverse-search<//>
             <${Text} color=${C.muted}>: ${histSearchQ || 'type to filter history'}<//>
             ${historyMatches[histSearchSel]
@@ -386,29 +461,6 @@ export function Composer({
           <//>`
         : null}
 
-      ${menuOpen
-        ? html`<${Box} flexDirection="column" paddingX=${1} marginBottom=${0}>
-            ${slashMode ? null : html`<${Box}><${Text} color=${C.accent} bold>@ mention <//><${Text} color=${C.muted}>a device, customer or entity<//><//>`}
-            ${(() => {
-              const MAX = 8;
-              let start = 0;
-              if (matches.length > MAX) start = Math.min(Math.max(0, sel - Math.floor(MAX / 2)), matches.length - MAX);
-              const window = matches.slice(start, start + MAX);
-              return window.map((s, wi) => {
-                const i = start + wi;
-                const on = i === sel;
-                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.success : C.muted}>${on ? glyphs.prompt + ' ' : '  '}<//>
-                  <${Text} color=${on ? C.success : slashMode ? C.slash : C.accent} bold=${on}>${label}<//>
-                  <${Text} color=${C.muted}>${s.desc}<//>
-                <//>`;
-              });
-            })()}
-          <//>`
-        : null}
-
       <${Text} color=${C.accent}>${'_'.repeat(Math.max(1, width))}<//>
 
       <${Box} width=${width} paddingX=${1}>
@@ -424,6 +476,17 @@ export function Composer({
             <//>`}
       <//>
 
+      ${menuOpen
+        ? html`<${Box} flexDirection="column" paddingX=${1}>
+            ${slashMode
+              ? null
+              : fileMode
+              ? html`<${Box}><${Text} color=${C.brand} bold>@ file<//>  <${Text} color=${C.muted}>fuzzy path match<//><//>` 
+              : html`<${Box}><${Text} color=${C.brand} bold>@ mention<//>  <${Text} color=${C.muted}>device · customer · entity<//><//>` }
+            ${paletteRows}
+          <//>`
+        : null}
+
       <${Text} color=${C.separator}>${'─'.repeat(Math.max(1, width))}<//>
     <//>`;
 }

package/src/tui/run.js

@@ -27,7 +27,7 @@ async function animateSplash() {
 }
 
 export async function runTui(cfg, opts = {}) {
-  const { display = {}, onExternal, initialQuestion, banner = false } = opts;
+  const { display = {}, onExternal, initialQuestion, banner = false, agentName, resumeMode } = opts;
   let externalAction;
   const seen = Boolean(cfg?.tui?.bannerSeen);
   const showAnimation = banner || !seen;
@@ -44,6 +44,8 @@ export async function runTui(cfg, opts = {}) {
       display=${display}
       initialQuestion=${initialQuestion}
       showBanner=${!showAnimation}
+      agentName=${agentName}
+      resumeMode=${resumeMode}
       onExternal=${(a) => { externalAction = a; onExternal?.(a); }}
     />`,
     { exitOnCtrlC: false },