jaitus 0.3.0

package/src/index.js

@@ -0,0 +1,2503 @@
+// ─── jaitus ─────────────────────────────────────────────────────────────────────
+//
+// `jaitus` with a prompt runs one task and exits. `jaitus` on its own opens a session.
+// Both drive the same agent loop; the only difference is whether the conversation
+// survives the turn. Everything else here is the shape of a command-line tool: one
+// registry of commands that feeds help, completion and dispatch alike, so a command
+// cannot exist without being documented or completable.
+
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { createClient, NotSignedIn } from './api.js';
+import { fromResponse, isJaitusError } from './errors.js';
+import { signedIn } from './session.js';
+import {
+  loadCredentials, clearCredentials, loadSettings, saveSettings,
+  endpoints, version, HOME, HISTORY,
+} from './config.js';
+import { runAgent } from './agent/loop.js';
+import { createPermissions } from './agent/permissions.js';
+import { forgetIgnoreCache, imageBlock } from './agent/tools.js';
+import { loadContext, CONTEXT_FILE } from './project.js';
+import { discoverSkills, skillCatalog } from './skills.js';
+import { runHook, configuredHookEvents } from './hooks.js';
+import { newSession, saveSession, loadSession, latestSession, listSessions, sessionSummary, replaySession } from './sessions.js';
+import { createJournal, displayPath } from './rewind.js';
+import { createLedger } from './ledger.js';
+import { listMcpServers, addMcpServer, removeMcpServer } from './mcp.js';
+import { banner, wordmark, renderHomeLogo, startupTip } from './brand.js';
+import {
+  c, out, err, ok, fail, info, warn, table, present,
+  promptLine, useHistoryFile, watchEsc, setTuiSink, askKey, colorLevel,
+  unicode, glyph, columns,
+} from './ui.js';
+import { createTui as createClassicTui } from './tui.js';
+import { createTui as createInkTui } from './tui-ink.js';
+
+// The interactive surface is Node-only. The classic renderer remains an
+// explicit escape hatch for terminals that cannot support fullscreen Ink.
+const createTui = process.env.JAITUS_RENDERER === 'classic' ? createClassicTui : createInkTui;
+import login from './commands/login.js';
+import logout from './commands/logout.js';
+import doctor from './commands/doctor.js';
+import update from './commands/update.js';
+import init from './commands/init.js';
+import research from './commands/research.js';
+import explain from './commands/explain.js';
+import testCmd from './commands/test.js';
+import commitCmd from './commands/commit.js';
+import codeReview from './commands/code-review.js';
+import securityReview from './commands/security-review.js';
+import simplify from './commands/simplify.js';
+import completion, { SHELLS } from './commands/completion.js';
+
+const VERSION = version();
+
+// ─── Options ────────────────────────────────────────────────────────────────────
+
+const OPTIONS = [
+  ['--print, -p', 'run one prompt non-interactively and exit'],
+  ['--continue, -c', 'continue the most recent session in this directory'],
+  ['--resume, -r <id>', 'resume a session by id'],
+  ['--output-format <format>', 'print, json or stream-json in print mode'],
+  ['--max-turns <n>', 'limit agent turns in non-interactive mode'],
+  ['--permission-mode <mode>', 'default, acceptEdits, plan or bypassPermissions'],
+  ['--dangerously-skip-permissions', 'alias for bypassPermissions; trusted workspaces only'],
+  ['--system-prompt <text>', 'replace the model system prompt in print mode'],
+  ['--append-system-prompt <text>', 'add instructions to the system prompt'],
+  ['--model <id>', 'use this model for this run'],
+  ['--cwd <dir>', 'work in another directory'],
+  ['--yes, -y', 'do not ask before writing files or running commands'],
+  ['--json', 'machine-readable output, where a command reports something'],
+  ['--no-color', 'plain text, no escape codes'],
+  ['--no-banner', 'skip the logo'],
+  ['--help, -h', 'this help, or help for a command'],
+  ['--version, -v', 'print the version'],
+];
+
+const FLAG_NAMES = ['--print', '-p', '--continue', '-c', '--resume', '-r', '--output-format', '--max-turns', '--permission-mode', '--dangerously-skip-permissions', '--system-prompt', '--append-system-prompt', '--model', '--cwd', '--yes', '-y', '--json', '--no-color', '--no-banner', '--help', '-h', '--version', '-v', '--force', '--ascii'];
+
+function parseArgs(argv) {
+  const flags = {
+    model: null, yes: false, cwd: process.cwd(), json: false, help: false, version: false,
+    print: false, continue: false, resume: null, outputFormat: 'text', maxTurns: 40,
+    permissionMode: 'default', systemPrompt: '', appendSystemPrompt: '',
+  };
+  const rest = [];
+  const passthrough = [];
+  let literal = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (literal) { rest.push(a); continue; }
+
+    if (a === '--') { literal = true; continue; }
+    else if (a === '--print' || a === '-p') flags.print = true;
+    else if (a === '--continue' || a === '-c') flags.continue = true;
+    else if (a === '--resume' || a === '-r') flags.resume = argv[++i];
+    else if (a === '--output-format') flags.outputFormat = argv[++i] || 'text';
+    else if (a === '--max-turns') flags.maxTurns = Math.max(1, Number(argv[++i]) || 40);
+    else if (a === '--permission-mode') flags.permissionMode = argv[++i] || 'default';
+    else if (a === '--dangerously-skip-permissions') flags.permissionMode = 'bypassPermissions';
+    else if (a === '--system-prompt') flags.systemPrompt = argv[++i] || '';
+    else if (a === '--append-system-prompt') flags.appendSystemPrompt = argv[++i] || '';
+    else if (a === '--model') flags.model = argv[++i];
+    else if (a === '--cwd') flags.cwd = path.resolve(argv[++i] || '.');
+    else if (a === '--yes' || a === '-y') flags.yes = true;
+    else if (a === '--json') flags.json = true;
+    else if (a === '--help' || a === '-h') flags.help = true;
+    else if (a === '--version' || a === '-v') flags.version = true;
+    // Applied to the environment rather than carried around, because ui.js reads these
+    // per call and a dozen call sites should not each have to be told.
+    else if (a === '--no-color') process.env.JAITUS_NO_COLOR = '1';
+    else if (a === '--no-banner') process.env.JAITUS_NO_BANNER = '1';
+    else if (a === '--ascii') process.env.JAITUS_ASCII = '1';
+    else if (a.startsWith('-') && a.length > 1) passthrough.push(a);
+    else rest.push(a);
+  }
+  return { flags, rest, passthrough };
+}
+
+// ─── Help ───────────────────────────────────────────────────────────────────────
+
+function helpText() {
+  const lines = [];
+  lines.push(`  ${c.bold('USAGE')}`);
+  lines.push(`    jaitus                          start a session in this directory`);
+  lines.push(`    jaitus "<task>"                 run one task and exit`);
+  lines.push(`    cat error.log | jaitus "why?"   pipe something in as context`);
+  lines.push('');
+  lines.push(`  ${c.bold('COMMANDS')}`);
+  for (const [name, cmd] of Object.entries(commands)) {
+    if (cmd.hidden) continue;
+    lines.push(`    ${name.padEnd(32)}${c.dim(cmd.summary)}`);
+  }
+  lines.push('');
+  lines.push(`  ${c.bold('OPTIONS')}`);
+  for (const [flag, description] of OPTIONS) {
+    lines.push(`    ${flag.padEnd(32)}${c.dim(description)}`);
+  }
+  lines.push('');
+  lines.push(`  ${c.bold('IN A SESSION')}`);
+  for (const [name, s] of Object.entries(SLASH)) {
+    if (s.hidden) continue;
+    lines.push(`    ${name.padEnd(32)}${c.dim(s.summary)}`);
+  }
+  lines.push('');
+  lines.push(`  ${c.dim(`jaitus help <command>  for detail on one command`)}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+function commandHelp(name) {
+  const cmd = commands[name];
+  if (!cmd) {
+    fail(`No such command: ${name}`);
+    info(`Run ${c.bold('jaitus --help')} to see them all.`);
+    return 1;
+  }
+  out('');
+  out(`  ${c.bold(`jaitus ${name}`)} ${c.dim('— ' + cmd.summary)}`);
+  if (cmd.usage) {
+    out('');
+    for (const line of cmd.usage) out(`    ${line}`);
+  }
+  if (cmd.detail) {
+    out('');
+    for (const line of cmd.detail) out(`  ${line}`);
+  }
+  out('');
+  return 0;
+}
+
+// ─── Shared plumbing ────────────────────────────────────────────────────────────
+
+/** Anything piped in becomes context for the task. */
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString('utf8').trim();
+}
+
+class NoModel extends Error {}
+
+async function resolveModel(client, preferred) {
+  if (preferred) return preferred;
+  const saved = loadSettings().model;
+  if (saved) return saved;
+  const available = await client.models();
+  // The gateway maps whatever it advertises onto the model that actually serves it, so
+  // the first advertised id is always a valid choice. There is deliberately no hardcoded
+  // fallback: an id baked in here would be a second, stale source of truth, and sending
+  // one the gateway does not list produces a confusing rejection instead of this.
+  if (!available.length) {
+    throw new NoModel(
+      'The gateway did not advertise any models, so there is nothing to run against. '
+      + 'Run `jaitus doctor` to see where it stopped, or `jaitus --model <id>` if you know one.'
+    );
+  }
+  return available[0];
+}
+
+/** Rough token estimate for /context and /status — ~4 characters per token of English. */
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    if (typeof m.content === 'string') chars += m.content.length;
+    else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === 'text') chars += (b.text || '').length;
+        else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length;
+        else if (b.type === 'tool_result') chars += (b.content || '').length;
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+/** Clipboard write that degrades honestly: returns false when no path exists. */
+async function copyToClipboard(text) {
+  const { spawn } = await import('node:child_process');
+  const { promisify } = await import('node:util');
+  const platforms = process.platform === 'win32' ? [['clip']]
+    : process.platform === 'darwin' ? [['pbcopy']]
+    : [['wl-copy'], ['xclip', ['-selection', 'clipboard']], ['xsel', ['--clipboard', '--input']]];
+  for (const [cmd, args = []] of platforms) {
+    try {
+      const child = spawn(cmd, args, { stdio: ['pipe', 'ignore', 'ignore'] });
+      const done = promisify((cb) => {
+        child.on('close', (code) => cb(null, code === 0));
+        child.on('error', () => cb(null, false));
+      });
+      child.stdin.write(text);
+      child.stdin.end();
+      if (await done()) return true;
+    } catch { /* next candidate */ }
+  }
+  return false;
+}
+
+function requireAuth() {
+  try {
+    return createClient();
+  } catch (e) {
+    if (e instanceof NotSignedIn) {
+      fail(e.message);
+      info(`Run ${c.bold('jaitus login')} — it opens your browser, no key to copy.`);
+      process.exit(1);
+    }
+    throw e;
+  }
+}
+
+/**
+ * The one place a failure becomes something the user can see and act on.
+ *
+ * Inside the app view this hands the error object — status, message, stack and all —
+ * to the transcript, which renders it as a red-barred block with a hint and a folded
+ * stack. Outside it, the same facts go to stderr where a pipeline can read them.
+ *
+ * `activeTui` is module-level rather than threaded through because the process-level
+ * handlers installed by `session()` have no other way to reach the renderer, and an
+ * uncaught error in the alternate screen is otherwise written to a stderr that nothing
+ * is showing — which is precisely how a hard crash came to look like a hung session.
+ */
+let activeTui = null;
+
+function reportAgentError(e, context = {}) {
+  const error = e instanceof Error ? e : new Error(String(e?.message ?? e ?? 'Unknown error'));
+  if (activeTui?.error) {
+    activeTui.error(error, context);
+    return 1;
+  }
+  // Only a JaitusError carries text we wrote for the user. Anything else is a fault in
+  // this CLI, and its message — a TypeError, a path — is for debugging, not the user.
+  if (isJaitusError(error)) {
+    fail(error.message);
+    if (error.hint) info(error.hint);
+    if (error.code === 'free_limit_reached' || error.code === 'free_request_too_large') info('Subscribe at ' + endpoints().siteUrl + '/billing');
+    if (error.requestId) info(c.dim(`request id ${error.requestId}`));
+  } else if (error instanceof NotSignedIn) {
+    fail(error.message);
+  } else {
+    fail('Something went wrong in Jaitus.');
+    info('Try again; run with JAITUS_DEBUG=1 to see the details.');
+    if (process.env.JAITUS_DEBUG && error.stack) err(c.dim(error.stack));
+  }
+  return 1;
+}
+
+/** The current branch, for the header. Absent outside a repo, which is fine. */
+function gitBranch(cwd) {
+  try {
+    const r = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, encoding: 'utf8', timeout: 1500 });
+    const name = r.status === 0 ? String(r.stdout || '').trim() : '';
+    return name && name !== 'HEAD' ? name : '';
+  } catch {
+    return '';
+  }
+}
+
+// Used only to fill the context meter. The real ceiling is the model's, which the
+// gateway does not advertise; this is the conservative floor of what any model it
+// serves accepts, so the bar reads "getting full" before anything actually breaks.
+const CONTEXT_BUDGET = 180_000;
+
+// Compact at this fraction of the budget. Low enough that the summarisation request
+// itself still fits comfortably, high enough that a normal session never sees it.
+const AUTO_COMPACT_AT = 0.78;
+
+// An expanded @mention is capped: pulling a 4 MB lockfile into the prompt because
+// someone typed `@package-lock.json` would blow the context it is meant to save.
+const MENTION_MAX_BYTES = 48_000;
+
+/**
+ * One summarisation call. Shared by /compact and auto-compaction so the two cannot
+ * drift into producing different kinds of summary from the same conversation.
+ */
+async function summarise(client, model, messages, focus) {
+  const res = await client.messages({
+    model,
+    max_tokens: 2048,
+    messages: [
+      ...messages,
+      {
+        role: 'user',
+        content: 'Summarize this conversation compactly for a successor agent: what was asked, '
+          + 'what was done (files changed, commands run, outcomes), what remains. Be specific and terse.'
+          + (focus ? ` Focus on: ${focus}.` : ''),
+      },
+    ],
+    stream: false,
+  });
+  if (!res.ok) throw await fromResponse(res);
+  const body = await res.json();
+  const text = (body.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n');
+  if (!text) throw new Error('the summary came back empty');
+  return text;
+}
+
+/**
+ * `@path` in a message → the file's contents as a content block.
+ *
+ * Directories list instead of reading, which is what someone typing `@src/` means.
+ * Anything unreadable is reported rather than skipped: silently dropping a mention
+ * would let the agent answer confidently about a file it never saw.
+ */
+function expandMentions(input, cwd) {
+  const blocks = [];
+  const notes = [];
+  const seen = new Set();
+  for (const match of String(input).matchAll(/(?:^|\s)@([^\s@]+)/g)) {
+    const ref = match[1].replace(/[.,;:)]+$/, '');
+    if (!ref || seen.has(ref)) continue;
+    seen.add(ref);
+    const full = path.resolve(cwd, ref);
+    if (!full.startsWith(path.resolve(cwd))) { notes.push(`@${ref} is outside the working directory — not attached.`); continue; }
+    try {
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) {
+        const entries = fs.readdirSync(full, { withFileTypes: true })
+          .filter((e) => !e.name.startsWith('.'))
+          .slice(0, 200)
+          .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+        blocks.push({ type: 'text', text: `<mentioned path="${ref}" kind="directory">\n${entries.join('\n')}\n</mentioned>` });
+        notes.push(`@${ref} — ${entries.length} entries attached`);
+        continue;
+      }
+      if (stat.size > MENTION_MAX_BYTES) {
+        notes.push(`@${ref} is ${Math.round(stat.size / 1024)} kB — too large to attach; the agent can read it if it needs to.`);
+        continue;
+      }
+      const text = fs.readFileSync(full, 'utf8');
+      blocks.push({ type: 'text', text: `<mentioned path="${ref}">\n${text}\n</mentioned>` });
+      notes.push(`@${ref} — ${text.split('\n').length} lines attached`);
+    } catch {
+      notes.push(`@${ref} could not be read — not attached.`);
+    }
+  }
+  return { blocks, notes };
+}
+
+/** Saved allow/deny rules for one project directory. */
+function projectRules(cwd) {
+  const saved = loadSettings().permissionRules?.[cwd] || {};
+  return { allow: Array.isArray(saved.allow) ? saved.allow : [], deny: Array.isArray(saved.deny) ? saved.deny : [] };
+}
+
+/** 18400 → "18.4k". Header space is scarce and the exact digit never mattered. */
+const format = (n) => (n >= 1000 ? `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k` : String(n));
+
+async function oneShot(task, { flags }) {
+  const client = requireAuth();
+  const model = await resolveModel(client, flags.model);
+  const messages = [{ role: 'user', content: task }];
+  const permissions = createPermissions({ autoApprove: flags.yes, mode: flags.permissionMode });
+  const format = ['text', 'json', 'stream-json'].includes(flags.outputFormat) ? flags.outputFormat : 'text';
+  let answer = '';
+
+  try {
+    const result = await runAgent({
+      client, messages, model, cwd: flags.cwd, permissions,
+      maxIterations: flags.maxTurns,
+      silent: true,
+      systemOverride: flags.systemPrompt || null,
+      extraSystem: flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : '',
+      onText: (text) => {
+        answer += text;
+        if (format === 'stream-json') out(JSON.stringify({ type: 'content_block_delta', delta: { text } }));
+      },
+    });
+    if (format === 'json') {
+      out(JSON.stringify({ type: 'result', result: answer, model, stop_reason: result.stopReason, usage: result }));
+    } else if (format === 'stream-json') {
+      out(JSON.stringify({ type: 'message_stop', stop_reason: result.stopReason, usage: result }));
+    } else {
+      out(answer);
+    }
+    return 0;
+  } catch (e) {
+    if (format !== 'text') out(JSON.stringify({ type: 'error', error: e.message, status: e.status || 500 }));
+    if (format !== 'text') return 1;
+    return reportAgentError(e);
+  }
+}
+
+// ─── The session ────────────────────────────────────────────────────────────────
+
+const SLASH = {
+  '/help': { summary: 'these commands' },
+  '/model [id]': { summary: 'show or change the model for this session' },
+  '/models': { summary: 'model ids Jaitus accepts', hidden: true },  // duplicate of /model, which lists them and lets you pick
+  '/status': { summary: 'model, mode, account, directory, context usage' },
+  '/cost': { summary: 'tokens used so far this session' },
+  '/context': { summary: 'what the model sees this turn (messages, project notes)' },
+  '/cwd': { summary: 'which directory the agent is working in', hidden: true },  // already in the header and in /status
+  '/clear': { summary: 'start the conversation over' },
+  '/undo': { summary: 'drop the last exchange' },
+  '/compact [focus]': { summary: 'summarize the conversation to free context' },
+  '/export [file]': { summary: 'write the conversation to a file (txt/md/json)' },
+  '/copy': { summary: 'copy the last response to the clipboard' },
+  '/diff': { summary: 'what changed on disk since the session started' },
+  '/tasks': { summary: 'review tool activity from this session' },
+  '/image <path>': { summary: 'attach an image (png/jpg/gif/webp) the model will see with your next message' },
+  '/memory [text]': { summary: 'show or append to JAITUS.md (# does this inline)' },
+  '/permissions [mode|rules]': { summary: 'permission mode, and the allow/deny rules for this project' },
+  '/skills': { summary: 'list project workflows' },
+  '/sessions': { summary: 'list saved sessions in this directory' },
+  '/session': { summary: 'show this session id', hidden: true },  // the id is already in /status
+  '/resume <id>': { summary: 'load another saved session' },
+  '/rename <title>': { summary: 'name this session' },
+  '/hooks': { summary: 'show configured lifecycle hooks' },
+  '/tui [fullscreen|default]': { summary: 'switch renderer, relaunching with this conversation intact' },
+  '/fork': { summary: 'copy this conversation into a brand-new session id', hidden: true },  // duplicate of /branch
+  '/theme [name]': { summary: 'show or set the color theme (dark, light, daltonized, ocean, plain, auto)' },
+  '/scroll-speed [n]': { summary: 'show or set mouse-wheel scroll speed (0.25-10)', hidden: true },  // belongs in /config
+  '/vim': { summary: 'toggle Vim modal editing for the prompt' },
+  '/attach <id>': { summary: 'watch a background job log live (Esc stops watching)' },
+  '/stop <id>': { summary: 'stop a running background job' },
+  '/debug': { summary: 'terminal + renderer diagnostics for bug reports' },
+  '/agent <task>': { summary: 'run an isolated read-only side task' },
+  '/btw <question>': { summary: 'side question, answered without touching history' },
+  '/research [--deep] <q>': { summary: 'agentic web research with sources (read-only)' },
+  '/deep-research <question>': { summary: 'deeper web research, more rounds, cited report', hidden: true },  // use /research --deep
+  '/ask <question>': { summary: 'read-only explanation mode; never edits files' },
+  '/architect <task>': { summary: 'read-only architecture mode; compare designs and risks' },
+  '/code': { summary: 'implementation mode; keep the current approval policy' },
+  '/explain <topic>': { summary: 'explain a file, symbol, error or concept from this project' },
+  '/test [args]': { summary: 'run the project tests; --fix lets the agent repair failures' },
+  '/code-review [--fix]': { summary: 'review the diff for bugs; --fix applies findings', hidden: true },  // same command as /review
+  '/review [--fix]': { summary: 'review the diff for bugs; --fix applies the findings' },
+  '/security-review [--fix]': { summary: 'review the diff for vulnerabilities' },
+  '/simplify [--fix]': { summary: 'readability-only pass over the change' },
+  '/commit': { summary: 'review the diff, write a real message, commit (push is separate)' },
+  '/plan [task]': { summary: 'read-only plan mode, optionally for one task' },
+  '/branch [name]': { summary: 'branch the conversation, return with /resume' },
+  '/rewind [turn]': { summary: 'restore conversation and files to an earlier turn' },
+  '/feedback [text]': { summary: 'send feedback with session context' },
+  '/version': { summary: 'print the running version', hidden: true },  // already in /status
+  '/animations [on|off]': { summary: 'motion: shimmer, sweeps, stagger (or stillness)', hidden: true },  // belongs in /config
+  '/login': { summary: 'sign in as a different account' },
+  '/logout': { summary: 'sign this device out and leave' },
+  '/doctor': { summary: 'diagnose setup problems' },
+  '/whoami': { summary: 'who you are signed in as' },
+  '/usage': { summary: 'your usage and remaining free prompts' },
+  '/init': { summary: 'create JAITUS.md and .jaitusignore here' },
+  '/mcp [list|add|remove]': { summary: 'list or configure MCP tool servers' },
+  '/config [key] [value]': { summary: 'show or change CLI settings' },
+  '/update': { summary: 'check whether a newer version is published' },
+  '/banner': { summary: 'draw the Jaitus mark', hidden: true },  // draws a logo into a session that already shows one
+  '/exit': { summary: 'leave (the only way out — Ctrl+C never exits)' },
+};
+
+// Hidden commands still WORK — nothing has been taken away from anyone's fingers. They
+// are kept out of the menu, the palette, completion and /help because each one either
+// duplicates a listed command or is a setting that belongs in /config, and a list of
+// sixty where twenty would do is a list nobody reads.
+const SLASH_NAMES = Object.keys(SLASH).filter((key) => !SLASH[key].hidden).map((s) => s.split(' ')[0]);
+const SLASH_ALL = Object.keys(SLASH).map((s) => s.split(' ')[0]);
+
+/**
+ * Best-effort UTF-8 upgrade for classic conhost: read the active codepage,
+ * switch to 65001 when it is anything else, verify. All stdio ignored —
+ * this either quietly fixes mojibake or quietly declines. Returns whether
+ * the console now speaks UTF-8.
+ */
+export function ensureUtf8Codepage() {
+  try {
+    const current = spawnSync('chcp.com', [], { encoding: 'buffer', timeout: 3000 });
+    const text = Buffer.concat([current.stdout || Buffer.alloc(0), current.stderr || Buffer.alloc(0)]).toString('latin1');
+    const m = /:\s*(\d+)/.exec(text);
+    if (m && m[1] === '65001') return true;
+    spawnSync('chcp.com', ['65001'], { stdio: 'ignore', timeout: 3000 });
+    const again = spawnSync('chcp.com', [], { encoding: 'buffer', timeout: 3000 });
+    const text2 = Buffer.concat([again.stdout || Buffer.alloc(0), again.stderr || Buffer.alloc(0)]).toString('latin1');
+    const m2 = /:\s*(\d+)/.exec(text2);
+    return !!m2 && m2[1] === '65001';
+  } catch {
+    return false;
+  }
+}
+
+async function session({ flags }) {
+  const client = requireAuth();
+  // Classic conhost speaks an OEM codepage by default, so every ›•─│ the CLI
+  // paints arrives as mojibake (the whole UI looks broken, not old). One
+  // silent `chcp 65001` upgrades the window to UTF-8 in place — same window,
+  // nothing for the user to configure. If the console refuses, the session
+  // falls back to the classic renderer with ASCII twins instead.
+  const classicConhost = process.platform === 'win32' && process.stdout.isTTY
+    && !process.env.WT_SESSION && !process.env.TERM_PROGRAM;
+  let utf8Console = !classicConhost;
+  if (classicConhost) utf8Console = ensureUtf8Codepage();
+  // Ask the terminal what it can do while the gateway answers: a DA reply
+  // proves escape processing (colors, alt-screen, mouse); silence means a
+  // legacy console, and the session degrades honestly instead of painting
+  // codes that render as nothing.
+  const { probeDevice } = await import('./terminal.js');
+  // `let`, not `const`: /model reassigns it via setModel (a const here throws
+  // "Assignment to constant variable" on every model switch).
+  let [model, device] = await Promise.all([
+    resolveModel(client, flags.model),
+    probeDevice({}).catch(() => ({ vt: !!process.stdout.isTTY, sixel: false })),
+  ]);
+  // Degrade on EVIDENCE, not on silence.
+  //
+  // This used to read "the device probe did not answer within 300ms, therefore this
+  // terminal cannot do escape sequences" and set JAITUS_ASCII + JAITUS_NO_COLOR. A
+  // terminal that is merely slow to reply — or one that buffers the reply behind
+  // something else on stdin — would then draw the whole UI in ASCII twins, which is
+  // where the stray `|` characters people were seeing came from: they are the
+  // fallbacks for │ ▌ ▏ ▐ appearing in a terminal that renders those glyphs perfectly.
+  //
+  // A missing reply is now only believed when something else agrees with it: a Windows
+  // console that is not Windows Terminal or a known terminal program, whose codepage
+  // could not be moved to UTF-8. Anywhere else, absence of evidence is not evidence.
+  const knownGoodTerminal = !!(process.env.WT_SESSION || process.env.TERM_PROGRAM
+    || process.env.COLORTERM || /256color|xterm|screen|tmux|alacritty|kitty/i.test(process.env.TERM || ''));
+  const legacyConsole = !knownGoodTerminal && !device.vt && (classicConhost ? !utf8Console : true);
+  if (legacyConsole && process.stdout.isTTY && !process.env.JAITUS_NO_COLOR) {
+    process.env.JAITUS_NO_COLOR = '1';
+    process.env.JAITUS_ASCII = '1';
+  }
+  // UTF-8 is the other half of it: conhost with an OEM codepage really does render
+  // box-drawing as mojibake, and that is worth the twins even when VT works.
+  if (classicConhost && !utf8Console && !process.env.JAITUS_ASCII) process.env.JAITUS_ASCII = '1';
+  currentCwd = flags.cwd;
+  const skills = discoverSkills(flags.cwd);
+  const loaded = flags.resume ? loadSession(flags.resume) : flags.continue ? latestSession({ cwd: flags.cwd }) : null;
+  if (flags.resume && !loaded) {
+    fail(`No saved session found for ${flags.resume}. Run ${c.bold('jaitus sessions')} to list them.`);
+    return 1;
+  }
+  if (loaded?.model && !flags.model) model = loaded.model;
+  const sessionState = loaded || newSession({ cwd: flags.cwd, model });
+  sessionState.model = model;
+  const creds = loadCredentials();
+  let tui = null;
+  const permissions = createPermissions({
+    autoApprove: flags.yes,
+    mode: flags.permissionMode,
+    // Saved rules are per project, keyed by directory, because "always allow npm test"
+    // in one repo says nothing about what is safe in another.
+    ...projectRules(flags.cwd),
+    onRulesChange: ({ allow, deny }) => {
+      const settings = loadSettings();
+      saveSettings({
+        ...settings,
+        permissionRules: { ...(settings.permissionRules || {}), [flags.cwd]: { allow, deny } },
+      });
+    },
+    onModeChange: (m) => {
+      saveSettings({ ...loadSettings(), lastMode: m });
+      tui?.setMeta({ mode: m });
+    },
+  });
+  if (loadSettings().lastMode && !flags.yes) permissions.setMode(loadSettings().lastMode);
+  // Starting straight into bypass gets one explicit confirmation (§11) when a
+  // human is present; headless runs just get the warning on stderr.
+  if (permissions.mode === 'bypassPermissions' && !flags.yes) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      out(`\n  ${c.red(c.bold('● BYPASS'))} ${c.red('requested — writes and shell commands would run with no permission checks.')}`);
+      const answer = await askKey(`  ${c.dim(`Enable bypass mode for this session? [y/N] ${glyph('›', '>')}`)} `, ['y', 'n', '\r', ' ']);
+      out('');
+      if (answer !== 'y') {
+        permissions.setMode('default');
+        info('Starting in default mode. Shift+Tab changes it later (bypass asks first).');
+      }
+    } else {
+      err(`  ${c.red('●')} bypassPermissions active: permission checks are off for this run.`);
+    }
+  }
+  const messages = sessionState.messages;
+  // Totals for this conversation. Saved with the session, so a resumed conversation
+  // continues its count instead of starting again from zero.
+  const saved = sessionState.spent || {};
+  const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+  const spent = { input: num(saved.input), cached: num(saved.cached), output: num(saved.output), tools: num(saved.tools), turns: num(saved.turns) };
+  sessionState.spent = spent;
+  // The real size of the last prompt, as the provider counted it; 0 until one is known.
+  let lastContext = num(sessionState.lastContext);
+  const sessionStart = Date.now();
+
+  // Scripted status line (§13): pipe a JSON blob to the user's command and
+  // render its first stdout line verbatim above the hint footer.
+  let statusTimer = null;
+  const refreshStatusLine = (reason) => {
+    const cmd = loadSettings().statusLine;
+    if (!cmd || !tui) return;
+    if (statusTimer) clearTimeout(statusTimer);
+    statusTimer = setTimeout(() => {
+      try {
+        let branch = '';
+        try {
+          const r = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: flags.cwd, encoding: 'utf8', timeout: 2000 });
+          if (r.status === 0) branch = String(r.stdout || '').trim();
+        } catch { /* not a repo */ }
+        const blob = {
+          model, cwd: flags.cwd, branch,
+          ctxTokens: estimateTokens(messages), turns: spent.turns, tools: spent.tools,
+          mode: permissions.mode, intent: intentMode, session: sessionState.id,
+          elapsedMs: Date.now() - sessionStart, reason,
+        };
+        const r = spawnSync(cmd, { input: JSON.stringify(blob), shell: true, cwd: flags.cwd, encoding: 'utf8', timeout: 2000 });
+        if (r.status === 0 && r.stdout.trim()) tui.setStatusLine(r.stdout.split('\n')[0]);
+      } catch { /* a status script never breaks the session */ }
+    }, 300);
+  };
+
+  // The header's context meter. The provider's own count of the last prompt when there
+  // is one — it is exact, and it includes what the character estimate cannot see (the
+  // system prompt, tool schemas). Before any turn in this process, and after anything
+  // that rewrites the history, the estimate stands in.
+  const showContext = ({ estimate = false } = {}) => {
+    const used = !estimate && lastContext ? lastContext : estimateTokens(messages);
+    tui?.setMeta?.({ ctx: `${format(used)}/${format(CONTEXT_BUDGET)}`, ctxUsed: used, ctxMax: CONTEXT_BUDGET });
+  };
+
+  const resetContext = () => {
+    lastContext = 0;
+    sessionState.lastContext = 0;
+    showContext();
+  };
+
+  // ── The fullscreen interface ──
+  // The alternate-screen app owns a fixed composer and a scrolling transcript. out()
+  // routes transcript events through it so command output cannot disturb the composer.
+  tui = await createTui({
+    // Names AND summaries: the composer menu and the palette both show what a command
+    // does beside its name, which is the difference between a list you scan and a list
+    // you have to already know.
+    slashCommands: [
+      ...Object.entries(SLASH)
+        .filter(([, value]) => !value.hidden)
+        .map(([key, value]) => ({ name: key.split(' ')[0], summary: value.summary })),
+      ...Object.entries(skills).map(([name, skill]) => ({ name: `/${name}`, summary: skill.summary || 'project workflow' })),
+    ],
+    fileProvider: (frag) => completeFiles(frag),
+    settings: loadSettings(),
+    meta: {
+      version: VERSION, cwd: flags.cwd, model, mode: permissions.mode, intent: 'build',
+      session: sessionState.id, branch: gitBranch(flags.cwd),
+      ctxUsed: 0, ctxMax: CONTEXT_BUDGET,
+    },
+    onModeCycle: async () => {
+      // Bypass is opt-in with both eyes open (§11): stepping into it from the
+      // cycle asks first, and declining keeps the current mode.
+      const order = ['default', 'acceptEdits', 'plan', 'bypassPermissions'];
+      const next = order[(order.indexOf(permissions.mode) + 1) % order.length];
+      if (next === 'bypassPermissions') {
+        const ans = await tui.askDialog('Enable bypass mode?', [
+          { label: 'Yes, skip all checks', value: 'y' },
+          { label: 'No, stay put', value: 'n' },
+        ], [
+          'Writes and shell commands will run with NO permission prompts.',
+          'Use only in a trusted workspace you can afford to rebuild.',
+        ]);
+        if (dialogValue(ans) !== 'y') return permissions.mode;
+      }
+      const m = permissions.cycleMode();
+      refreshStatusLine('mode');
+      return m;
+    },
+  });
+  setTuiSink(tui);
+  activeTui = tui;
+
+  // Last line of defence. An uncaught exception or an unhandled rejection under the
+  // alternate screen goes to a stderr that is not being displayed — the process either
+  // dies with no explanation or limps on looking frozen. Both now land in the
+  // transcript with their stack, and the session stays usable.
+  const onUncaught = (error, origin) => {
+    try {
+      reportAgentError(error, {
+        title: origin === 'unhandledRejection' ? 'Unhandled promise rejection' : 'Uncaught error',
+        detail: 'This is a bug in Jaitus, not in your project. Ctrl+D expands the stack; /feedback sends it.',
+      });
+      tui.setBusy(false);
+    } catch {
+      // The renderer itself is the thing that failed: leave the screen and say so
+      // plainly, because a silent exit here is the worst possible outcome.
+      try { tui.stop(); } catch { /* already down */ }
+      process.stderr.write(`\n${error?.stack || error}\n`);
+      process.exitCode = 1;
+    }
+  };
+  process.on('uncaughtException', (error) => onUncaught(error, 'uncaughtException'));
+  process.on('unhandledRejection', (reason) => onUncaught(reason, 'unhandledRejection'));
+
+  const runTurn = async (signal) => {
+    const result = await runAgent({ client, messages, model, cwd: flags.cwd, permissions, signal, tui });
+    return result;
+  };
+
+  // Rewind journal: conversation checkpoints per prompt, file snapshots per write.
+  const journal = createJournal();
+  // Everything that fails outside a tool call. Drained into the next request so the
+  // model knows what happened rather than starting each turn as though the session had
+  // been uneventful.
+  const ledger = createLedger();
+
+  // Images queued by /image — sent as content blocks with the next user message.
+  const pendingImages = [];
+  let intentMode = 'build';
+  const intentGuidance = {
+    build: 'Work as an implementation agent. Inspect the repository, make the requested changes, and verify them within the active permission policy.',
+    ask: 'Work in explanation mode. Do not edit files, run mutating commands, or claim a change was made. Explain findings with exact file paths and evidence.',
+    architect: 'Work in architecture mode. Do not edit files or run mutating commands. Compare viable designs, interfaces, migration steps, risks, and verification criteria before recommending one.',
+  };
+  const setIntent = (next) => {
+    intentMode = intentGuidance[next] ? next : 'build';
+    tui?.setMeta?.({ intent: intentMode });
+  };
+
+  // Esc/Ctrl+C while busy aborts the current run; the loop below notices via the
+  // rejected signal and reports the interruption.
+  let activeAbort = null;
+  tui.onEscape(() => { if (activeAbort) activeAbort.abort(); });
+
+  /** One agent run with abort wiring, error accounting, and queue draining after. */
+  const runManaged = async (messages) => {
+    const ctrl = new AbortController();
+    activeAbort = ctrl;
+    const turnStarted = Date.now();
+    try {
+      const result = await runAgent({
+        client, messages, model, cwd: flags.cwd, permissions, signal: ctrl.signal, tui, journal,
+        extraSystem: `${skillCatalog(skills)}\n\nCurrent intent: ${intentMode}. ${intentGuidance[intentMode]}${flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : ''}`,
+        systemOverride: flags.systemPrompt || null,
+      });
+      // An interrupted turn still spent what it spent before Esc — count it.
+      if (result && !result.__error) {
+        spent.input += result.input || 0;
+        spent.cached += result.cached || 0;
+        spent.output += result.output || 0;
+        spent.tools += result.tools || 0;
+        if (result.context) { lastContext = result.context; sessionState.lastContext = lastContext; }
+      }
+      if (result?.stopReason === 'interrupted') {
+        ledger.note('interrupted', 'The user interrupted the previous turn with Esc before it finished. Whatever it was doing did not complete.');
+        // Keep the partial assistant turn out of history if it never completed.
+        const last = messages[messages.length - 1];
+        if (last?.role === 'assistant' && !Array.isArray(last.content)) messages.pop();
+      } else if (result && !result.__error) {
+        spent.turns += 1;
+        // opencode assistant metadata: ▣ Mode · model · duration.
+        const secs = ((Date.now() - turnStarted) / 1000).toFixed(1);
+        const posture = permissions.mode === 'plan' ? 'Read-only'
+          : permissions.mode === 'acceptEdits' ? 'Auto-edit'
+          : permissions.mode === 'bypassPermissions' ? 'Off' : 'Ask';
+        const meta = `  ${c.brand(glyph('▣', '*'))} ${posture} ${c.dim(`· ${model} · ${secs}s`)}`;
+        if (tui) tui.print(meta);
+        else out(meta);
+      }
+    } catch (e) {
+      reportAgentError(e);
+      // The failed turn is dropped so the next message is not sent on top of a broken
+      // conversation the API will reject — but the model is told it happened. Without
+      // that, its next turn begins as though nothing went wrong and it re-attempts the
+      // thing that just failed.
+      ledger.note('turn-failed', `A request to the gateway failed${e.status ? ` with HTTP ${e.status}` : ''}: ${e.message}. That turn was discarded and the user's message was not answered.`);
+      if (messages[messages.length - 1]?.role === 'user') messages.pop();
+    } finally {
+      activeAbort = null;
+      sessionState.messages = messages;
+      sessionState.model = model;
+      saveSession(sessionState);
+      // Live context meter for the header: the bar fills, and the numbers beside it
+      // say how close the conversation is to needing /compact.
+      try {
+        showContext();
+        tui?.setSpent?.(spent);
+      } catch { /* header keeps last value */ }
+      refreshStatusLine('turn');
+    }
+  };
+
+  /**
+   * Nothing thrown while handling a line may escape.
+   *
+   * The TUI calls this and does not await it, so an escaping rejection is unhandled —
+   * and an unhandled rejection under the alternate screen is written to a stderr
+   * nobody can see. The session looks like it swallowed the message. Every failure
+   * gets reported into the transcript instead, and the prompt comes back.
+   */
+  const handleLine = async (rawLine) => {
+    try {
+      await handleLineInner(rawLine);
+    } catch (error) {
+      reportAgentError(error, { title: 'That message could not be handled' });
+      try { tui.setBusy(false); } catch { /* the renderer may already be down */ }
+    }
+  };
+
+  /**
+   * Summarise the conversation before it runs out of room.
+   *
+   * Triggered at a fraction of the budget rather than at the wall, because the
+   * compaction call itself needs the conversation to still fit. Silent when it is not
+   * needed and loud when it happens: a summarised history is a materially different
+   * thing to talk to, and finding that out by noticing the agent forgot something is
+   * worse than being told.
+   */
+  const autoCompactIfNeeded = async () => {
+    if (loadSettings().autoCompact === false) return;
+    const used = estimateTokens(messages);
+    if (used < CONTEXT_BUDGET * AUTO_COMPACT_AT) return;
+    if (messages.length < 4) return;
+
+    tui.setStatus?.(`Compacting — ${format(used)} of ${format(CONTEXT_BUDGET)} context used`);
+    try {
+      const summary = await summarise(client, model, messages, '');
+      const dropped = messages.length;
+      messages.length = 0;
+      messages.push({ role: 'user', content: `[Earlier conversation, summarized:]\n${summary}\n\n[Continue from here.]` });
+      tui.notice?.(`Context was ${format(used)}; ${dropped} messages summarised into one. /rewind still has the originals.`, 'info');
+      ledger.note('compacted', `The conversation was automatically summarised to free context: ${dropped} messages became one summary. Detail you are not shown above is genuinely gone — ask or re-read rather than assuming.`);
+    } catch (error) {
+      // Not fatal: the turn can still run, it just runs closer to the ceiling.
+      tui.notice?.(`Auto-compaction failed (${error.message}) — continuing without it. /compact retries.`, 'warn');
+      ledger.note('compact-failed', `Automatic context compaction failed (${error.message}); the conversation is close to the context limit.`);
+    } finally {
+      tui.clearStatus?.();
+    }
+  };
+
+  const handleLineInner = async (rawLine) => {
+    const input = rawLine.trim();
+    if (!input) return;
+    // First submit leaves home: the composer goes full session width.
+    tui.setHome?.(false);
+
+    // Echo the submission as a first-class entry rather than two pre-formatted lines,
+    // so it wraps, re-wraps on resize, and carries its attachments.
+    if (tui.user) tui.user(input, pendingImages.map((i) => i.name).filter(Boolean));
+    else {
+      const bar = c.brand(glyph('│', '|'));
+      tui.print(`\n  ${bar}  ${c.bold(input.replace(/\n/g, ' '))}`, 'user');
+      tui.print(`  ${bar}`, 'user');
+    }
+
+    // Conversation checkpoint for Esc+Esc rewind — before the turn that can change it.
+    if (!input.startsWith('/') && !input.startsWith('#') && !input.startsWith('!')) {
+      journal.checkpoint(messages);
+    }
+
+    if (input.startsWith('/')) {
+      const [verb, ...args] = input.split(/\s+/);
+      let result;
+      try {
+        result = await slashCommand(verb, args, {
+          client, messages, permissions, flags, spent, resetContext,
+          model, setModel: (m) => {
+            model = m;
+            sessionState.model = m;
+            tui?.setMeta?.({ model: m });
+          },
+          skills, sessionState, runManaged, tui, pendingImages, journal, setIntent,
+        });
+      } catch (error) {
+        // Slash commands run inside the fullscreen app. Letting this escape to the
+        // process-level handler prints to stderr outside the alternate screen and
+        // makes a real failure look like nothing happened.
+        reportAgentError(error);
+      }
+      if (result === 'exit') { setTuiSink(null); tui.stop(); process.exit(0); }
+      return;
+    }
+
+    // # <text> appends to the project's JAITUS.md — a memory note, not a prompt.
+    if (input.startsWith('#')) {
+      const note = input.slice(1).trim();
+      if (note) {
+        appendMemory(flags.cwd, note);
+        ok(`Remembered in ${CONTEXT_FILE}: ${c.bold(note.slice(0, 60))}${note.length > 60 ? '…' : ''}`);
+      } else {
+        const existing = loadContext(flags.cwd);
+        out(existing ? existing : c.dim(`(no ${CONTEXT_FILE} yet — type "# note text" to add one)`));
+      }
+      return;
+    }
+
+    tui.setBusy(true);
+    try {
+      const hook = await runHook(flags.cwd, 'beforePrompt', { prompt: input, sessionId: sessionState.id });
+      if (!hook.ok) {
+        fail(`beforePrompt hook stopped the request (exit ${hook.code}).`);
+        ledger.note('hook', `The project's beforePrompt hook blocked a request (exit ${hook.code}). The user's message was never sent.`);
+        return;
+      }
+      // ! <command> runs a shell command directly and feeds the output to the model.
+      // A trailing `&` detaches it into a background job instead (§16).
+      if (input.startsWith('!')) {
+        let command = input.slice(1).trim();
+        if (!command) { warn('Give a command: ! git status'); return; }
+        if (/\s&\s*$/.test(command)) {
+          command = command.replace(/\s&\s*$/, '');
+          const { startBackground } = await import('./background.js');
+          const job = startBackground(command, flags.cwd);
+          ok(`Background job ${c.bold(job.id)} started: ${c.dim(command.slice(0, 80))} — output streams to its log; /tasks lists it.`);
+          info(`Read it with the background_read tool ("job ${job.id}") or stop it with background_stop.`);
+          return;
+        }
+        const started = Date.now();
+        const code = await runShell(command, flags.cwd);
+        if (code === 0) {
+          messages.push({ role: 'user', content: `I ran \`${command}\` myself; its output is above. Comment on it briefly.` });
+          await runManaged(messages);
+        } else {
+          info(`exit ${code} in ${((Date.now() - started) / 1000).toFixed(1)}s — output above, not sent to the model.`);
+          // The output is deliberately not sent (it may be huge, and the user ran it
+          // for themselves), but the fact that it failed is context the model needs —
+          // otherwise it will suggest running the very command that just failed.
+          ledger.note('shell', `The user ran \`${command}\` themselves and it exited ${code}. The output was not shared with you; ask for it if it matters.`);
+        }
+        return;
+      }
+
+      // Context is finite and running out of it mid-task is the worst moment to find
+      // out. Compacting a turn early costs one cheap summarisation call; compacting a
+      // turn late costs the turn, and sometimes the thread of what was being done.
+      await autoCompactIfNeeded();
+
+      // @path in a message is expanded to the file's contents here rather than left
+      // for the agent to fetch. The agent CAN read it, but that is a whole round trip
+      // to learn something the user already told it, and on a metered gateway the
+      // round trip is the expensive part.
+      const mentioned = expandMentions(input, flags.cwd);
+      if (mentioned.blocks.length) {
+        for (const note of mentioned.notes) tui.notice?.(note, 'dim');
+      }
+
+      // Image chips pasted with Ctrl+V ride first, then the text.
+      const pasted = tui.drainAttachments ? tui.drainAttachments(input) : [];
+      const queuedImages = [...pendingImages.splice(0), ...pasted];
+      if (queuedImages.length || mentioned.blocks.length) {
+        messages.push({ role: 'user', content: [...queuedImages, ...mentioned.blocks, { type: 'text', text: input }] });
+      } else {
+        messages.push({ role: 'user', content: input });
+      }
+      await runManaged(messages);
+    } catch (error) {
+      // There was no catch here, only a finally. Anything thrown between setBusy(true)
+      // and the end of the block — a hook, a background spawn, an attachment read —
+      // escaped `handleLine`, and because nothing awaits it, became an unhandled
+      // rejection printed to a stderr the alternate screen was covering. The session
+      // simply appeared to ignore the message.
+      reportAgentError(error, { title: 'That turn did not run' });
+    } finally {
+      tui.setBusy(false);
+      // While the agent was running, Enter queued whatever was typed — send those
+      // now, one at a time, each itself interruptible.
+      for (;;) {
+        const queued = tui.takeQueued()[0];
+        if (queued === undefined) break;
+        messages.push({ role: 'user', content: queued });
+        // Through the same entry type as a typed message. This was two pre-formatted
+        // lines each carrying a `│`, pushed in as raw text — which is where the doubled
+        // bar people saw after interrupting came from: the queue drains in the `finally`
+        // of an interrupted turn, so that is exactly when it showed up.
+        if (tui.user) tui.user(queued);
+        else tui.print(`\n  ${c.brand(glyph('│', '|'))}  ${c.bold(queued.replace(/\n/g, ' '))}`, 'user');
+        tui.setBusy(true);
+        await runManaged(messages);
+        tui.setBusy(false);
+      }
+      await runHook(flags.cwd, 'afterTurn', { prompt: input, sessionId: sessionState.id });
+    }
+  };
+
+  useHistoryFile(HISTORY);
+  // ── Which renderer ──
+  //
+  // This used to read: if the device-attributes probe did not answer, do not use the
+  // app view. A probe that goes unanswered is common — a terminal under a multiplexer,
+  // over SSH, or with anything else queued on stdin — and the consequence was total:
+  // no app view, no logo, no mouse, no transcript. Just a readline prompt. The whole
+  // interface silently did not exist, and nothing said why.
+  //
+  // The test is now for positive evidence AGAINST the app view rather than for the
+  // absence of evidence for it. A real terminal gets the real interface; only a console
+  // that has actually shown it cannot cope falls back.
+  const savedTui = loadSettings().tui;
+  const forcedFullscreen = process.env.JAITUS_FULLSCREEN === '1' || process.env.JAITUS_NO_FLICKER === '1'
+    || savedTui === 'fullscreen';
+  const wantFullscreen = process.env.JAITUS_NO_FULLSCREEN ? false
+    : forcedFullscreen ? true
+    : savedTui === 'default' ? false
+    // The one case that genuinely cannot render it: a classic Windows console whose
+    // codepage could not be moved to UTF-8, where every box-drawing character lands as
+    // mojibake. JAITUS_FULLSCREEN=1 still forces it for the brave.
+    : classicConhost && !utf8Console ? false
+    // A console that answered nothing AND looks like nothing — no WT_SESSION, no
+    // TERM_PROGRAM, no COLORTERM, no recognisable TERM — is the legacy case. Anywhere
+    // else, silence from the probe means the probe was not heard, not that the terminal
+    // is incapable.
+    : !device.vt && !knownGoodTerminal && process.stdout.isTTY ? false
+    : true;
+  if (process.stdout.isTTY && wantFullscreen) {
+    tui.start({ onLine: handleLine, history: sessionHistory() });
+    // Fresh sessions open on the home moment, opencode-style: the centered
+    // two-tone mark, then a tip — the composer below is the whole welcome.
+    // The mark is vertically centered in the free space above the pinned
+    // composer, the way home centers it; it scrolls away on first send.
+    // Resumed sessions replay their conversation instead (below).
+    if (!loaded && !process.env.JAITUS_NO_BANNER) {
+      // The app view owns its own welcome: it draws the wordmark through a real
+      // per-character gradient and centres it against the live window height, neither
+      // of which can be done by pushing pre-coloured strings into the transcript —
+      // the escape codes would have to be shredded mid-frame, and the padding would
+      // be wrong the moment the terminal was resized.
+      tui.setHome?.(true);
+      if (!tui.user) {
+        const logo = renderHomeLogo({ version: VERSION, width: columns() });
+        for (const line of logo) tui.print(line);
+        tui.print(c.dim(`  Tip: ${startupTip()} · /help lists everything`));
+      }
+    }
+    // (There used to be a notice here saying the wheel could not reach the app on a
+    // classic Windows console. The app requests mouse reporting itself now, so it can;
+    // and the line was landing in the transcript, which suppressed the whole welcome
+    // screen — it is how the logo came to be invisible. The status bar already carries
+    // the keys that scroll.)
+    // The cascade already announced fresh sessions; resumed ones (and
+    // --no-banner runs) still need their one status line.
+    if (loaded || process.env.JAITUS_NO_BANNER) {
+      const line = `Session ${sessionState.id.slice(0, 8)}${loaded ? ' resumed' : ' ready'} · ${flags.cwd}`;
+      if (tui.notice) tui.notice(line); else tui.print(c.dim(`  ${line}`));
+    }
+    // A resumed session replays its old conversation onto the screen, so the
+    // user lands inside the same session they left — not a blank transcript.
+    if (loaded && messages.length) replaySession(tui, messages);
+    // A resumed conversation already has a size and a history of spend. Showing 0 until
+    // the first new turn finished made both look broken.
+    showContext();
+    tui.setSpent?.(spent);
+    refreshStatusLine('start');
+
+    /** Esc+Esc: pick a checkpoint, restore the conversation and the files. */
+    const doRewind = async () => {
+      const points = journal.list().reverse(); // newest first for the dialog
+      if (!points.length) { tui.print(c.yellow('  Nothing to rewind — send a message first.')); return; }
+      const options = points.slice(0, 9).map((p) => ({
+        value: p.index,
+        label: `Turn ${p.index + 1}: ${(p.prompt || '(no prompt)').slice(0, 60)}${p.files ? c.dim(`  · ${p.files} file change${p.files === 1 ? '' : 's'} after`) : ''}`,
+      }));
+      const answer = await tui.askDialog(
+        `${c.bold('Rewind to an earlier turn?')} ${c.dim('(restores messages and files)')}`,
+        [...options, { value: null, label: c.dim('Keep current state') }],
+        [c.dim('Files the agent changed after the chosen turn are restored to their earlier contents.')],
+      );
+      const chosen = dialogValue(answer);
+      if (chosen === null || chosen === undefined) { tui.print(c.dim('  ↩ Still on the current timeline.')); return; }
+      const outcome = journal.restore(chosen, messages);
+      if (!outcome.ok) { tui.print(c.red(`  ✗ Rewind failed: ${outcome.error}`)); return; }
+      sessionState.messages = messages;
+      resetContext();
+      saveSession(sessionState);
+      ledger.note('rewind', `The user rewound the session to turn ${chosen + 1}. ${outcome.restored.length} file(s) were reverted on disk${outcome.deleted.length ? ` and ${outcome.deleted.length} removed` : ''} — anything you believed about their contents after that turn is no longer true.`);
+      tui.print(c.green(`  ↩ Rewound to turn ${chosen + 1} — ${outcome.messageCount} message${outcome.messageCount === 1 ? '' : 's'} restored`)
+        + (outcome.restored.length || outcome.deleted.length
+          ? c.dim(`  · ${outcome.restored.length} file${outcome.restored.length === 1 ? '' : 's'} reverted${outcome.deleted.length ? `, ${outcome.deleted.length} removed` : ''}`)
+          : ''));
+      for (const f of [...outcome.restored, ...outcome.deleted].slice(0, 5)) {
+        tui.print(c.dim(`      ${displayPath(f)}`));
+      }
+    };
+    tui.onRewind(doRewind);
+    // Clicking an indicator runs the command that indicator is about. It goes through
+    // handleLine rather than straight to slashCommand so a clicked command is
+    // indistinguishable from a typed one — same echo, same error handling, same history.
+    tui.onCommand?.((command) => { void handleLine(command); });
+    // Drag-to-select copies through the same clipboard path as /copy, so there is one
+    // place that knows how to reach a clipboard on each platform.
+    tui.onCopy?.((text) => copyToClipboard(text));
+  } else if (!unicode() && !process.env.JAITUS_NO_BANNER) {
+    // Plain-console open, codex-style session header: lowercase wordmark,
+    // model, approval posture, directory, account — one compact block,
+    // instant, nothing repeated.
+    const { renderClassicOpen } = await import('./brand.js');
+    const { columns: termColumns } = await import('./ui.js');
+    const approval = permissions.mode === 'plan' ? 'read-only'
+      : permissions.mode === 'acceptEdits' ? 'auto-edit'
+      : permissions.mode === 'bypassPermissions' ? 'off' : 'ask';
+    for (const line of renderClassicOpen({
+      version: VERSION, model, approval, cwd: flags.cwd,
+      account: creds?.user?.email ? `${creds.user.email}${creds.user.isPaid ? '' : ' (free plan)'}` : null,
+      session: `${sessionState.id.slice(0, 8)}${loaded ? ' resumed' : ''}`,
+      narrow: termColumns() < 60,
+    })) out(line);
+    out('');
+    if (loaded && messages.length) replaySession(tui, messages);
+    refreshStatusLine('start');
+    for (;;) {
+      const line = await promptLine(`${c.brand(glyph('›', '>'))} `, {
+        completions: SLASH_NAMES,
+        fileComplete: true,
+        onShiftTab: () => {
+          const mode = permissions.cycleMode();
+          info(`Permission mode: ${c.bold(mode)}` + (mode === 'plan' ? ' — writes and commands are blocked' : mode === 'bypassPermissions' ? ' — everything allowed' : ''));
+          return mode;
+        },
+      });
+      if (line === null) { out(''); return 0; }
+      await handleLine(line);
+      if (tui.exited) break;
+    }
+    return 0;
+  } else {
+    await banner({ version: VERSION });
+    // The probe heard nothing back: this console ignores escape sequences,
+    // so colors and the app view are off and plain text is the honest UI.
+    // Said once ever (flagged in settings), then never again.
+    if (!device.vt && process.stdout.isTTY && !savedTui && !loadSettings().legacyNoted) {
+      out('  Plain-text console: for colors, mouse and fullscreen, use Windows Terminal.');
+      try { saveSettings({ ...loadSettings(), legacyNoted: true }); } catch { /* notice is courtesy, not contract */ }
+    }
+    const projectNotes = loadContext(flags.cwd);
+    table([
+      [`  ${c.dim('directory')}`, flags.cwd],
+      [`  ${c.dim('model')}`, model],
+      [`  ${c.dim('session')}`, `${sessionState.id}${loaded ? ' · resumed' : ''}`],
+      ...(creds?.user?.email ? [[`  ${c.dim('account')}`, `${creds.user.email}${creds.user.isPaid ? '' : c.dim(' · free plan')}`]] : []),
+      ...(projectNotes ? [[`  ${c.dim('context')}`, `${CONTEXT_FILE} (${projectNotes.length} characters)`]] : []),
+    ]);
+    out('');
+    out(`  ${c.dim('/help for commands · Shift+Tab cycles modes · \\+Enter newline · /exit to leave')}`);
+
+    // Inline fallback: same handling, one promptLine at a time.
+    for (;;) {
+      const modeTag = permissions.mode === 'default' ? ''
+        : permissions.mode === 'bypassPermissions' ? c.red(` [${permissions.mode}] `)
+        : c.yellow(` [${permissions.mode}] `);
+      const line = await promptLine(`${c.brand(glyph('›', '>'))} ${modeTag}`, {
+        completions: SLASH_NAMES,
+        fileComplete: true,
+        onShiftTab: () => {
+          const mode = permissions.cycleMode();
+          info(`Permission mode: ${c.bold(mode)}` + (mode === 'plan' ? ' — writes and commands are blocked' : mode === 'bypassPermissions' ? ' — everything allowed' : ''));
+          return mode;
+        },
+      });
+      // Ctrl+D / closed input never leaves either: only /exit does. A real
+      // EOF (piped stdin ending) still ends the loop.
+      if (line === null) {
+        if (process.stdin.isTTY) { out(`  ${c.dim('Type /exit to leave')}`); continue; }
+        out(''); return 0;
+      }
+      await handleLine(line);
+      if (tui.exited) break;
+    }
+    return 0;
+  }
+
+  // TUI mode runs until the key handler sets shouldExit (Ctrl+C/Ctrl+D on empty).
+  await new Promise((resolve) => {
+    const iv = setInterval(() => {
+      if (tui.exited) { clearInterval(iv); resolve(); }
+    }, 120);
+    const cleanup = () => { clearInterval(iv); resolve(); };
+    process.once('SIGINT', cleanup);
+  });
+  setTuiSink(null);
+  tui.stop();
+  out('');
+  return 0;
+}
+
+/** Files and directories matching an '@' fragment — same as the inline completer. */
+function completeFiles(frag) {
+  try {
+    const dir = frag.includes('/') ? frag.slice(0, frag.lastIndexOf('/') + 1) : '';
+    const base = frag.slice(dir.length);
+    const entries = fs.readdirSync(path.resolve(currentCwd, dir || '.'), { withFileTypes: true });
+    return entries
+      .filter((e) => e.name.startsWith(base) && !e.name.startsWith('.'))
+      .map((e) => dir + e.name + (e.isDirectory() ? '/' : ''))
+      .slice(0, 12);
+  } catch {
+    return [];
+  }
+}
+
+// The cwd the @-completer reads from; set when a session starts.
+let currentCwd = process.cwd();
+
+/** Prior prompts for Up-arrow recall: this session first, then earlier ones. */
+function sessionHistory() {
+  try {
+    const file = path.join(HOME, 'history');
+    if (!fs.existsSync(file)) return [];
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return Array.isArray(parsed) ? parsed.slice(-50).reverse() : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Append one line to the project memory file, creating it with a header if needed. */
+function appendMemory(cwd, note) {
+  const file = path.join(cwd, CONTEXT_FILE);
+  try {
+    if (!fs.existsSync(file)) fs.writeFileSync(file, `# ${CONTEXT_FILE}\n\nNotes for the Jaitus agent working in this directory.\n\n`, 'utf8');
+    fs.appendFileSync(file, `- ${note}\n`, 'utf8');
+  } catch (e) {
+    fail(`Could not write ${CONTEXT_FILE}: ${e.message}`);
+  }
+}
+
+/** Run a shell command with output streaming to the terminal. Returns the exit code. */
+function runShell(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.stdout.on('data', (d) => process.stdout.write(d));
+    child.stderr.on('data', (d) => process.stderr.write(d));
+    child.on('error', (e) => { fail(e.message); resolve(1); });
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+/** Capture a fixed executable invocation for an in-app panel; no shell interpolation. */
+function captureProcess(command, args, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { cwd, shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = ''; let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+    child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+    child.on('error', (error) => resolve({ stdout, stderr, error }));
+    child.on('close', (code) => resolve({ stdout, stderr, code, error: code === 0 ? null : new Error(stderr || `exit ${code}`) }));
+  });
+}
+
+/**
+ * Switch renderers in place (§2): persist the choice, checkpoint the
+ * conversation to disk, leave the alternate screen cleanly, and exec the CLI
+ * again resumed on the same session — the user loses nothing but a blink.
+ */
+async function relaunchRenderer(ctx, want) {
+  const { saveSettings, loadSettings } = await import('./config.js');
+  const { saveSession } = await import('./sessions.js');
+  const { spawnSync } = await import('node:child_process');
+  const { fileURLToPath } = await import('node:url');
+  saveSettings({ ...loadSettings(), tui: want });
+  ctx.sessionState.messages = ctx.messages;
+  ctx.sessionState.model = ctx.model;
+  saveSession(ctx.sessionState);
+  setTuiSink(null);
+  ctx.tui.stop();
+  const bin = fileURLToPath(new URL('../bin/jaitus.js', import.meta.url));
+  const argv = process.argv.slice(2).filter((a) => a !== '--resume' && a !== '-r' && a !== '--continue' && a !== '-c');
+  // Drop the value that followed --resume/-r, if any.
+  const cleaned = [];
+  for (let i = 0; i < argv.length; i++) {
+    if ((argv[i] === '--resume' || argv[i] === '-r')) { i++; continue; }
+    cleaned.push(argv[i]);
+  }
+  out(c.dim(`  Relaunching in ${want} mode — conversation continues where it left off…`));
+  const res = spawnSync(process.execPath, [bin, ...cleaned, '--resume', ctx.sessionState.id], { stdio: 'inherit', cwd: ctx.flags.cwd });
+  process.exit(res.status ?? 0);
+}
+
+/**
+ * Single-select picker for anything listable (sessions, models, modes, jobs):
+ * arrows + Enter, 1-9 jump, Esc cancels. Returns the value or undefined.
+ */
+async function pickOption(tui, title, question, options, preview = []) {
+  if (!options.length) return undefined;
+  const r = await tui.askDialog(question, options.slice(0, 9), preview, { title, hideComment: true });
+  const value = r && typeof r === 'object' ? r.value : r;
+  return value == null ? undefined : value;
+}
+function dialogValue(answer) {
+  return answer && typeof answer === 'object' ? answer.value : answer;
+}
+
+async function slashCommand(verb, args, ctx) {
+  const { client, messages, flags, spent } = ctx;
+
+  switch (verb) {
+    case '/exit':
+    case '/quit':
+      return 'exit';
+
+    case '/help':
+      out('');
+      for (const [name, s] of Object.entries(SLASH)) out(`  ${name.padEnd(18)}${c.dim(s.summary)}`);
+      out('');
+      info(`${c.dim('Prefixes:')} ${c.bold('# note')} ${c.dim('→ project memory ·')} ${c.bold('! cmd')} ${c.dim('→ run a shell command ·')} ${c.bold('@file')} ${c.dim('→ mention a file ·')} ${c.bold('\\+Enter')} ${c.dim('→ newline')}`);
+      return null;
+
+    case '/status': {
+      const creds = loadCredentials();
+      table([
+        [`  ${c.dim('model')}`, ctx.model],
+        [`  ${c.dim('mode')}`, ctx.permissions.mode],
+        [`  ${c.dim('account')}`, creds?.user?.email || 'not signed in'],
+        [`  ${c.dim('directory')}`, ctx.flags.cwd],
+        [`  ${c.dim('context')}`, `${ctx.messages.length} messages · ~${estimateTokens(ctx.messages).toLocaleString()} tokens`],
+        [`  ${c.dim('session')}`, `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls`],
+      ]);
+      return null;
+    }
+
+    case '/context': {
+      const tokens = estimateTokens(ctx.messages);
+      table([
+        [`  ${c.dim('messages')}`, String(ctx.messages.length)],
+        [`  ${c.dim('user messages')}`, String(ctx.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length)],
+        [`  ${c.dim('assistant turns')}`, String(ctx.messages.filter((m) => m.role === 'assistant').length)],
+        [`  ${c.dim('tool results')}`, String(ctx.messages.reduce((n, m) => n + (Array.isArray(m.content) ? m.content.filter((b) => b.type === 'tool_result').length : 0), 0))],
+        [`  ${c.dim('estimated tokens')}`, tokens.toLocaleString()],
+        ...(loadContext(ctx.flags.cwd) ? [[`  ${c.dim('project notes')}`, `${CONTEXT_FILE} (loaded)`]] : []),
+      ]);
+      info(`${c.dim('Run')} ${c.bold('/compact')} ${c.dim('to summarize and free context when this grows.')}`);
+      return null;
+    }
+
+    case '/compact': {
+      if (!ctx.messages.length) { info('Nothing to compact — the conversation is empty.'); return null; }
+      // In fullscreen the shared spinner would scribble over the frame —
+      // report through the app status row instead.
+      const spin = ctx.tui
+        ? { stop: () => ctx.tui.clearStatus(), update: () => {} }
+        : (await import('./ui.js')).spinner('Summarizing…');
+      if (ctx.tui) ctx.tui.setStatus(`${c.brand(glyph('◆', '*'))} ${c.brand(glyph('Summarizing…', 'Summarizing...'))}`);
+      try {
+        const text = await summarise(ctx.client, ctx.model, ctx.messages, args.join(' '));
+        ctx.messages.length = 0;
+        ctx.messages.push({ role: 'user', content: `[Earlier conversation, summarized:]\n${text}\n\n[Continue from here.]` });
+        ok('Conversation compacted. Context freed.');
+        try { ctx.resetContext?.(); } catch { /* header keeps last value */ }
+      } catch (e) {
+        fail(`Compact failed: ${e.message}`);
+      } finally {
+        spin.stop();
+      }
+      return null;
+    }
+
+    case '/export': {
+      const target = args[0] || `jaitus-session-${new Date().toISOString().slice(0, 16).replace(/[:T]/g, '-')}.md`;
+      try {
+        const lines = [`# Jaitus session — ${new Date().toISOString()}`, ''];
+        for (const m of ctx.messages) {
+          if (m.role === 'user' && typeof m.content === 'string') lines.push(`## You\n\n${m.content}\n`);
+          else if (m.role === 'assistant') {
+            const text = (Array.isArray(m.content) ? m.content : [])
+              .filter((b) => b.type === 'text').map((b) => b.text).join('\n');
+            const tools = (Array.isArray(m.content) ? m.content : []).filter((b) => b.type === 'tool_use');
+            if (text) lines.push(`## Jaitus\n\n${text}\n`);
+            for (const t of tools) lines.push(`> ${c.grey('')}\`${t.name} ${JSON.stringify(t.input).slice(1, 120)}\``);
+          }
+        }
+        fs.writeFileSync(path.resolve(ctx.flags.cwd, target), lines.join('\n'), 'utf8');
+        ok(`Exported to ${c.bold(target)}`);
+      } catch (e) {
+        fail(`Export failed: ${e.message}`);
+      }
+      return null;
+    }
+
+    case '/copy': {
+      const last = [...ctx.messages].reverse().find((m) => m.role === 'assistant'
+        && Array.isArray(m.content) && m.content.some((b) => b.type === 'text' && b.text.trim()));
+      const text = last ? last.content.filter((b) => b.type === 'text').map((b) => b.text).join('\n') : '';
+      if (!text) { warn('No response to copy yet.'); return null; }
+      const copied = await copyToClipboard(text);
+      if (copied) ok('Last response copied to the clipboard.');
+      else warn('Clipboard not available — run /export to save the conversation instead.');
+      return null;
+    }
+
+    case '/image': {
+      const [p] = args;
+      if (!p) { warn('Give an image path: /image screenshot.png (png, jpg, gif, webp — max ~3 MB).'); return null; }
+      const abs = path.isAbsolute(p) ? p : path.join(ctx.flags.cwd, p);
+      const block = await imageBlock(abs);
+      if (!block) { warn(`Cannot attach ${p} — not a supported image (png/jpg/jpeg/gif/webp), too big, or unreadable.`); return null; }
+      ctx.pendingImages.push(block);
+      ok(`Image attached (${Math.round((block.source.data.length * 3) / 4 / 1024)} KB). It is sent with your next message.`);
+      return null;
+    }
+
+    case '/diff': {
+      const [stat, diff] = await Promise.all([
+        captureProcess('git', ['diff', '--stat'], ctx.flags.cwd),
+        captureProcess('git', ['diff', '--no-ext-diff', '--unified=3'], ctx.flags.cwd),
+      ]);
+      if (stat.error || diff.error) { warn('Not a git repository, or git is not installed.'); return null; }
+      const body = `${stat.stdout}${stat.stdout && diff.stdout ? '\n\n' : ''}${diff.stdout}`.trim()
+        || 'No uncommitted changes.';
+      if (ctx.tui) await ctx.tui.showPanel('Changes', body.split('\n'));
+      else out(body);
+      return null;
+    }
+
+    case '/tasks': {
+      const activity = ctx.tui?.activitySnapshot?.() || [];
+      const { listBackground } = await import('./background.js');
+      const jobs = listBackground();
+      if (!activity.length && !jobs.length) { info('No agent tool activity in this session yet.'); return null; }
+      const lines = activity.flatMap((item) => [
+        `${item.status === 'ok' ? '✓' : item.status === 'failed' ? '✗' : '…'} ${item.label}`,
+        ...(item.detail ? item.detail.split('\n').slice(0, 12).map((line) => `  ${line}`) : []),
+        '',
+      ]);
+      if (jobs.length) {
+        lines.push(c.bold('Background jobs'), ...jobs.map((j) => `  ${j.running ? '…' : j.exit === 0 ? '✓' : '✗'} ${j.id}  ${j.command}  (pid ${j.pid ?? '?'})`), '');
+      }
+      if (ctx.tui) await ctx.tui.showPanel('Session activity', lines);
+      else out(lines.join('\n'));
+      return null;
+    }
+
+    case '/memory': {
+      const note = args.join(' ').trim();
+      if (note) { appendMemory(ctx.flags.cwd, note); ok(`Remembered in ${CONTEXT_FILE}.`); return null; }
+      const existing = loadContext(ctx.flags.cwd);
+      out(existing ? existing : c.dim(`(no ${CONTEXT_FILE} yet — /memory <text> creates one)`));
+      return null;
+    }
+
+    case '/permissions': {
+      const MODES = {
+        default: 'ask before every write and command',
+        acceptEdits: 'file edits auto-approved, commands still ask',
+        plan: 'read-only: inspect and propose, change nothing',
+        bypassPermissions: 'no checks at all — trusted workspaces only',
+      };
+      const applyMode = async (next) => {
+        const real = next === 'auto' ? 'bypassPermissions' : next;
+        if ((real === 'bypassPermissions') && ctx.tui && ctx.permissions.mode !== 'bypassPermissions') {
+          const ans = await ctx.tui.askDialog('Enable bypass mode?', [
+            { label: 'Yes, skip all checks', value: 'y' },
+            { label: 'No, stay put', value: 'n' },
+          ], [
+            'Writes and shell commands will run with NO permission prompts.',
+            'Use only in a trusted workspace you can afford to rebuild.',
+          ], { title: 'Bypass mode', hideComment: true });
+          if (dialogValue(ans) !== 'y') { info(`Staying in ${c.bold(ctx.permissions.mode)}.`); return; }
+        }
+        ctx.permissions.setMode(real);
+        ok(`Permission mode: ${c.bold(next)}`);
+        if (real === 'bypassPermissions') warn('The agent will not ask before writing files or running commands.');
+        if (next === 'plan') info('The agent can read and think, but nothing runs until you switch out of plan mode.');
+      };
+      // ── rules ──
+      // The mode is a blunt instrument; rules are the fine one. `/permissions rules`
+      // shows what has accumulated, which matters because "always allow" writes to
+      // disk and a list nobody can read is a list nobody can revoke.
+      const next = args[0];
+      if (next === 'rules' || next === 'allow' || next === 'deny' || next === 'forget') {
+        const { parseRule } = await import('./agent/rules.js');
+        if (next === 'rules') {
+          const { allow, deny, session } = ctx.permissions.rules;
+          if (!allow.length && !deny.length && !session.length) {
+            info('No permission rules yet. "Always allow" in a prompt writes one, or use /permissions allow <rule>.');
+            info(`${c.dim('Rules look like')} ${c.bold('run_command(npm test:*)')} ${c.dim('or')} ${c.bold('edit_file(src/**)')}.`);
+            return null;
+          }
+          table([
+            ...deny.map((r) => [`  ${c.red('deny')}`, r]),
+            ...allow.map((r) => [`  ${c.accent('allow')}`, r]),
+            ...session.map((r) => [`  ${c.dim('session')}`, c.dim(r)]),
+          ]);
+          info(`${c.dim('Deny always wins. Saved rules apply to')} ${ctx.flags.cwd}${c.dim('; remove one with /permissions forget <rule>.')}`);
+          return null;
+        }
+        const rule = args.slice(1).join(' ').trim();
+        if (!rule) { warn(`Give a rule: /permissions ${next} run_command(npm test:*)`); return null; }
+        if (next === 'forget') { ctx.permissions.removeRule(rule); ok(`Forgot ${c.bold(rule)}.`); return null; }
+        if (!parseRule(rule)) { warn(`That is not a rule. Try ${c.bold('run_command(npm test:*)')} or ${c.bold('edit_file(src/**)')}.`); return null; }
+        ctx.permissions.addRule(rule, { persist: true, kind: next });
+        ok(`${next === 'deny' ? 'Denied' : 'Allowed'}: ${c.bold(rule)} — saved for this project.`);
+        return null;
+      }
+
+      if (next) {
+        if (!Object.keys(MODES).concat('auto').includes(next)) { warn(`Unknown mode: ${next}. Try a mode, or ${c.bold('/permissions rules')}.`); return null; }
+        await applyMode(next);
+        return null;
+      }
+      if (!ctx.tui) {
+        table([
+          [`  ${c.dim('mode')}`, ctx.permissions.mode],
+          [`  ${c.dim('modes')}`, 'default · acceptEdits · plan · bypassPermissions (Shift+Tab cycles)'],
+        ]);
+        return null;
+      }
+      const picked = await pickOption(ctx.tui, 'Permission mode', 'How much may the agent do unasked?',
+        Object.entries(MODES).map(([value, hint]) => ({
+          value,
+          label: `${value === ctx.permissions.mode ? '●' : '○'}  ${value}  ${hint}`.slice(0, 88),
+        })));
+      if (!picked) return null;
+      await applyMode(picked);
+      return null;
+    }
+
+    case '/skills': {
+      const entries = Object.values(ctx.skills || {});
+      if (!entries.length) { info('No skills found. Add .jaitus/skills/<name>/SKILL.md to this project.'); return null; }
+      for (const skill of entries) out(`  ${c.brand('/' + skill.name).padEnd(26)}${c.dim(skill.description)}`);
+      return null;
+    }
+
+    case '/sessions': {
+      const sessions = listSessions({ cwd: ctx.flags.cwd });
+      if (!sessions.length) { info('No saved sessions in this directory yet.'); return null; }
+      for (const item of sessions.slice(0, 20)) {
+        const marker = item.id === ctx.sessionState.id ? c.brand('●') : c.grey('○');
+        out(`  ${marker} ${item.id.slice(0, 8)}  ${c.bold(sessionSummary(item).title)}  ${c.dim(item.updatedAt)}`);
+      }
+      info(`Pick one with ${c.bold('/resume')} (no id needed) or ${c.bold('jaitus --resume <id>')}.`);
+      return null;
+    }
+
+    case '/session':
+      table([
+        [`  ${c.dim('id')}`, ctx.sessionState.id],
+        [`  ${c.dim('created')}`, ctx.sessionState.createdAt],
+        [`  ${c.dim('updated')}`, ctx.sessionState.updatedAt],
+        [`  ${c.dim('messages')}`, String(ctx.messages.length)],
+      ]);
+      return null;
+
+    case '/rename': {
+      const title = args.join(' ').trim();
+      if (!title) { info(`Current title: ${ctx.sessionState.title || '(untitled)'}`); return null; }
+      ctx.sessionState.title = title.slice(0, 120);
+      saveSession(ctx.sessionState);
+      ok(`Session renamed to ${c.bold(ctx.sessionState.title)}.`);
+      return null;
+    }
+
+    case '/resume': {
+      const applyResume = (target) => {
+        ctx.messages.splice(0, ctx.messages.length, ...target.messages);
+        ctx.sessionState.id = target.id;
+        ctx.sessionState.createdAt = target.createdAt;
+        ctx.sessionState.updatedAt = target.updatedAt;
+        ctx.sessionState.title = target.title;
+        ctx.sessionState.model = target.model || ctx.model;
+        if (target.model) ctx.setModel(target.model);
+        // The resumed conversation's own totals, not the one being left. Mutated in place:
+        // sessionState.spent and every reader hold this same object.
+        const t = target.spent || {};
+        const n = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+        Object.assign(ctx.spent, { input: n(t.input), cached: n(t.cached), output: n(t.output), tools: n(t.tools), turns: n(t.turns) });
+        ctx.resetContext?.();
+        ctx.tui?.setSpent?.(ctx.spent);
+        if (ctx.tui) replaySession(ctx.tui, target.messages);
+        ok(`Resumed ${c.bold(target.id.slice(0, 8))} — ${c.dim(sessionSummary(target).title)}.`);
+      };
+      if (args[0]) {
+        const target = loadSession(args[0]);
+        if (!target) { warn('That session does not exist. /resume with no id lists them.'); return null; }
+        applyResume(target);
+        return null;
+      }
+      // No id: pick from this directory's sessions instead of typing one.
+      if (!ctx.tui) {
+        const all = listSessions({ cwd: ctx.flags.cwd });
+        if (!all.length) { info('No saved sessions in this directory yet.'); return null; }
+        info(`Pick one: ${c.bold('/resume <id>')} — ${all.slice(0, 9).map((s) => s.id.slice(0, 8)).join('  ')}`);
+        return null;
+      }
+      const all = listSessions({ cwd: ctx.flags.cwd }).slice(0, 9);
+      if (!all.length) { info('No saved sessions in this directory yet.'); return null; }
+      const chosen = await pickOption(ctx.tui, 'Resume session',
+        'Load a saved session from this directory?',
+        all.map((s) => ({
+          value: s.id,
+          label: `${s.id === ctx.sessionState.id ? '● ' : '○ '}${s.id.slice(0, 8)}  ${sessionSummary(s).title}  ${s.updatedAt || ''}`.slice(0, 90),
+        })),
+        [c.dim('The current conversation is saved first — nothing is lost.')]);
+      if (!chosen) { info('Kept the current session.'); return null; }
+      applyResume(loadSession(chosen));
+      return null;
+    }
+
+    case '/hooks': {
+      const events = configuredHookEvents(ctx.flags.cwd);
+      info(events.length ? `Configured lifecycle hooks: ${events.join(', ')}` : 'No hooks configured. Add .jaitus/hooks.json to this project.');
+      return null;
+    }
+
+    case '/tui': {
+      const want = (args[0] || '').toLowerCase();
+      const { loadSettings: loadS, saveSettings: saveS } = await import('./config.js');
+      if (!want) {
+        const saved = loadS().tui || '(auto)';
+        const active = ctx.tui ? 'fullscreen' : 'classic';
+        info(`Renderer: ${c.bold(active)} · saved: ${c.bold(saved)} · /tui fullscreen | /tui default`);
+        return null;
+      }
+      if (!['fullscreen', 'default'].includes(want)) { warn('Use /tui fullscreen or /tui default.'); return null; }
+      await relaunchRenderer(ctx, want);
+      return null;
+    }
+
+    case '/fork': {
+      const { newSession: mkSession, saveSession: persist } = await import('./sessions.js');
+      const forked = mkSession({ cwd: ctx.flags.cwd, model: ctx.model });
+      forked.messages = JSON.parse(JSON.stringify(ctx.messages));
+      forked.title = `${ctx.sessionState.title || 'Untitled'} (fork)`;
+      persist(forked);
+      ctx.sessionState.id = forked.id;
+      ctx.sessionState.createdAt = forked.createdAt;
+      ctx.sessionState.updatedAt = forked.updatedAt;
+      ctx.sessionState.title = forked.title;
+      ok(`Forked into session ${c.bold(forked.id.slice(0, 8))} — the original is untouched.`);
+      return null;
+    }
+
+    case '/theme': {
+      const { THEMES, reloadTheme } = await import('./ui.js');
+      const { loadSettings: loadS2, saveSettings: saveS2 } = await import('./config.js');
+      const names = Object.keys(THEMES);
+      const applyTheme = (name) => {
+        saveS2({ ...loadS2(), theme: name });
+        reloadTheme();
+        // Rows are rendered once and cached with their colours baked in, so a redraw
+        // alone would repaint the chrome and leave the whole transcript in the old
+        // palette. reskin() drops every cached row so they rebuild in the new one.
+        ctx.tui?.reskin ? ctx.tui.reskin() : ctx.tui?.redraw();
+        ok(`Theme: ${c.bold(name)}. Custom overrides live in ~/.jaitus/theme.json.`);
+      };
+      if (args[0]) {
+        if (!names.includes(args[0])) { warn(`Unknown theme: ${args[0]}. Try ${names.join(', ')}.`); return null; }
+        applyTheme(args[0]);
+        return null;
+      }
+      if (!ctx.tui) { info(`Theme: ${c.bold(loadS2().theme || 'auto')} (${names.join(', ')})`); return null; }
+      const picked = await pickOption(ctx.tui, 'Theme', 'Which theme should the CLI wear?', names.map((n) => ({
+        value: n,
+        label: `${n === (loadS2().theme || 'auto') ? '●' : '○'}  ${n}${n === 'auto' ? '  (follows the terminal)' : ''}${n === 'daltonized' ? '  (colorblind-safe)' : ''}`,
+      })));
+      if (!picked) return null;
+      applyTheme(picked);
+      return null;
+    }
+
+    case '/vim': {
+      const { loadSettings: loadSv, saveSettings: saveSv } = await import('./config.js');
+      const on = loadSv().editorMode !== 'vim';
+      saveSv({ ...loadSv(), editorMode: on ? 'vim' : 'emacs' });
+      if (on) ok(`Vim editing on — ${c.bold('Esc')} for normal mode (${c.dim('h j k l w e b · d x · v visual · i insert')}). /vim again for readline keys.`);
+      else ok('Vim editing off — readline keys.');
+      return null;
+    }
+
+    case '/attach': {
+      const { readBackground, listBackground } = await import('./background.js');
+      let id = args[0];
+      if (!id && ctx.tui) {
+        const jobs = listBackground().slice(0, 9);
+        if (!jobs.length) { info('No background jobs — start one with ! <command> &.'); return null; }
+        id = await pickOption(ctx.tui, 'Attach', 'Watch which job live?',
+          jobs.map((j) => ({ value: j.id, label: `${j.running ? '…' : '○'}  ${j.id.slice(0, 12)}  ${j.command.slice(0, 60)}` })));
+        if (!id) return null;
+      }
+      if (!id) { warn('Give a job id — /tasks lists them.'); return null; }
+      const first = readBackground(id, 120);
+      if (!first) { warn(`No background job ${id}.`); return null; }
+      if (!ctx.tui) { out(first.tail); return null; }
+      const fmt = (j) => [
+        `${j.running ? '… live' : `Finished (exit ${j.exit})`} — ${j.command}`,
+        ...String(j.tail || '(no output yet)').split('\n'),
+      ];
+      const iv = setInterval(() => {
+        import('./background.js').then(({ readBackground: rb }) => {
+          const j = rb(id, 120);
+          if (j) ctx.tui.updatePanel(fmt(j));
+        }).catch(() => {});
+      }, 600);
+      try {
+        await ctx.tui.showPanel(`Job ${first.id}`, fmt(first));
+      } finally {
+        clearInterval(iv);
+      }
+      return null;
+    }
+
+    case '/stop': {
+      const { stopBackground, readBackground, listBackground } = await import('./background.js');
+      let id = args[0];
+      if (!id && ctx.tui) {
+        const running = listBackground().filter((j) => j.running).slice(0, 9);
+        if (!running.length) { info('No running background jobs.'); return null; }
+        id = await pickOption(ctx.tui, 'Stop job', 'Stop which job?',
+          running.map((j) => ({ value: j.id, label: `…  ${j.id.slice(0, 12)}  ${j.command.slice(0, 60)}` })));
+        if (!id) return null;
+      }
+      if (!id) { warn('Give a job id — /tasks lists them.'); return null; }
+      if (!stopBackground(id)) { warn(`No background job ${id}.`); return null; }
+      const j = readBackground(id, 5);
+      ok(`Stopped ${c.bold(id)}${j && j.exit !== null && j.exit !== 0 ? c.dim(` (exit ${j.exit})`) : ''}.`);
+      return null;
+    }
+
+    case '/debug': {
+      const st = ctx.tui?.state;
+      const { sixelSupported, probeDone } = await import('./terminal.js');
+      table([
+        [`  ${c.dim('terminal')}`, `${process.env.TERM || '?'} · ${process.stdout.columns || '?'}x${process.stdout.rows || '?'} · TTY ${String(!!process.stdout.isTTY)} · VT ${probeDone() ? 'probed' : 'unprobed'} · sixel ${sixelSupported() ? 'yes' : 'no'}`],
+        [`  ${c.dim('renderer')}`, ctx.tui ? 'fullscreen (alt screen)' : 'classic (scrollback)'],
+        [`  ${c.dim('transcript')}`, st ? `${st.transcript.length} lines · offset ${st.transcriptOffset} · ${st.viewingTranscript ? 'in transcript view' : 'live'}` : 'n/a'],
+        // Requesting reporting and RECEIVING reports are different facts, and only the
+        // second means the wheel and drag-select work. A terminal that ignores the
+        // request looks, from in here, exactly like one nobody has touched the mouse in.
+        [`  ${c.dim('mouse')}`, (() => {
+          const m = ctx.tui?.mouseReport?.();
+          if (!m) return 'n/a (classic renderer)';
+          if (!m.requested) return 'not requested (disabled in settings, or not a TTY)';
+          return m.reportsSeen
+            ? `working — ${m.reportsSeen} report${m.reportsSeen === 1 ? '' : 's'} received`
+            : 'requested (?1000h ?1002h ?1006h) but NO reports received — this terminal may not support SGR mouse reporting';
+        })()],
+        [`  ${c.dim('theme')}`, `${loadSettings().theme || 'auto'} · colors ${process.env.JAITUS_ASCII ? 'ascii' : 'on'}`],
+        [`  ${c.dim('input')}`, st ? `${st.input.length} chars · cursor ${st.cursor}${st.vim && st.vim !== 'insert' ? ` · vim ${st.vim}` : ''}${st.selection ? ' · selecting' : ''}` : 'n/a'],
+        [`  ${c.dim('env')}`, `NO_FLICKER=${process.env.JAITUS_NO_FLICKER || '0'} SCROLL=${process.env.JAITUS_SCROLL_SPEED || '1'}`],
+      ]);
+      info('Paste this with bug reports — it names the terminal instead of guessing.');
+      return null;
+    }
+
+    case '/scroll-speed': {
+      const { loadSettings: loadS3, saveSettings: saveS3 } = await import('./config.js');
+      const SPEEDS = ['0.25', '0.5', '1', '2', '3', '5', '8', '10'];
+      const applySpeed = (n) => {
+        saveS3({ ...loadS3(), scrollSpeed: n });
+        ok(`Wheel speed ${c.bold(String(n))} saved. Wheel acceleration: ${loadS3().wheelAccel !== false ? 'on' : 'off'} (settings wheelAccel).`);
+      };
+      if (args[0]) {
+        const n = Number(args[0]);
+        if (!Number.isFinite(n) || n < 0.25 || n > 10) { warn('Give a number 0.25–10.'); return null; }
+        applySpeed(n);
+        return null;
+      }
+      if (!ctx.tui) { info(`Wheel speed: ${c.bold(String(loadS3().scrollSpeed ?? process.env.JAITUS_SCROLL_SPEED ?? 1))} (0.25–10, or JAITUS_SCROLL_SPEED)`); return null; }
+      const cur = String(loadS3().scrollSpeed ?? process.env.JAITUS_SCROLL_SPEED ?? 1);
+      const picked = await pickOption(ctx.tui, 'Scroll speed', 'How far should one wheel notch travel?',
+        SPEEDS.map((s) => ({ value: s, label: `${s === cur ? '●' : '○'}  ${s}${s === '3' ? '  (vim-like)' : ''}` })));
+      if (!picked) return null;
+      applySpeed(Number(picked));
+      return null;
+    }
+
+    case '/agent': {
+      const prompt = args.join(' ').trim();
+      if (!prompt) { info('Usage: /agent inspect the authentication flow'); return null; }
+      const sideMessages = [{ role: 'user', content: prompt }];
+      const sidePermissions = createPermissions({ mode: 'plan' });
+      const side = await runAgent({
+        client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd,
+        permissions: sidePermissions, extraSystem: `${skillCatalog(ctx.skills)}\n\nYou are a focused Jaitus side-agent. Return a concise finding; never edit files or run commands.`,
+      });
+      info(`Side-agent finished (${side.tools || 0} read/tool calls).`);
+      return null;
+    }
+
+    case '/research':
+      await research(args, ctx);
+      return null;
+
+    case '/ask': {
+      const question = args.join(' ').trim();
+      if (!question) { info('Usage: /ask why does this request fail?'); return null; }
+      ctx.setIntent('ask');
+      ctx.permissions.setMode('plan');
+      ctx.messages.push({ role: 'user', content: question });
+      await ctx.runManaged(ctx.messages);
+      return null;
+    }
+
+    case '/architect': {
+      const task = args.join(' ').trim();
+      if (!task) { info('Usage: /architect design a multi-provider quota service'); return null; }
+      ctx.setIntent('architect');
+      ctx.permissions.setMode('plan');
+      ctx.messages.push({ role: 'user', content: task });
+      await ctx.runManaged(ctx.messages);
+      return null;
+    }
+
+    case '/code':
+      ctx.setIntent('build');
+      ok('Implementation intent — approval policy remains unchanged.');
+      return null;
+
+    case '/explain':
+      await explain(args, ctx);
+      return null;
+
+    case '/test':
+      await testCmd(args, ctx);
+      return null;
+
+    case '/commit':
+      await commitCmd(args, ctx);
+      return null;
+
+    case '/code-review':
+    case '/review':
+      await codeReview(args, ctx);
+      return null;
+
+    case '/security-review':
+      await securityReview(args, ctx);
+      return null;
+
+    case '/simplify':
+      await simplify(args, ctx);
+      return null;
+
+    case '/deep-research': {
+      const rounds = args[0] === '--rounds' ? args : ['--rounds', '5', ...args];
+      await research(rounds, ctx);
+      return null;
+    }
+
+    case '/btw': {
+      // A side question: full tools, zero footprint — the main conversation
+      // never sees it, so asides stop polluting the context (/agent is the
+      // read-only twin for inspection tasks).
+      const question = args.join(' ').trim();
+      if (!question) { info('Usage: /btw <quick question> — answered off the record.'); return null; }
+      const sideMessages = [{ role: 'user', content: question }];
+      await runAgent({
+        client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd,
+        permissions: createPermissions({ mode: ctx.permissions?.mode || 'default' }),
+        extraSystem: `${skillCatalog(ctx.skills)}\n\nYou are answering a quick side question. Be brief; this answer is shown once and never stored.`,
+      });
+      info(c.dim('Off the record — the conversation above is untouched.'));
+      return null;
+    }
+
+    case '/plan': {
+      // Plan mode on demand: the agent reads, proposes, and waits — nothing
+      // runs until you leave plan mode. With a task, it starts proposing now.
+      ctx.permissions.setMode('plan');
+      ok('Plan mode — the agent can read and think, but nothing runs until you switch out of it.');
+      const task = args.join(' ').trim();
+      if (task) {
+        ctx.messages.push({ role: 'user', content: task });
+        await ctx.runManaged(ctx.messages);
+      } else {
+        info(`Give it work: ${c.bold('/plan add auth to the settings page')} — or Shift+Tab back out.`);
+      }
+      return null;
+    }
+
+    case '/branch': {
+      // /fork's twin that says what it is: the original session stays saved
+      // under its id, and /resume walks back to it — a branch, not a copy.
+      const { newSession: mkSession, saveSession: persist } = await import('./sessions.js');
+      const name = args.join(' ').trim().slice(0, 60);
+      const forked = mkSession({ cwd: ctx.flags.cwd, model: ctx.model });
+      forked.messages = JSON.parse(JSON.stringify(ctx.messages));
+      forked.title = name ? `${name} (branch)` : `${ctx.sessionState.title || 'Untitled'} (branch)`;
+      persist(forked);
+      ctx.sessionState.id = forked.id;
+      ctx.sessionState.createdAt = forked.createdAt;
+      ctx.sessionState.updatedAt = forked.updatedAt;
+      ctx.sessionState.title = forked.title;
+      ok(`Branched into session ${c.bold(forked.id.slice(0, 8))} — ${c.bold('/resume')} walks back to the original.`);
+      return null;
+    }
+
+    case '/rewind': {
+      // The Esc+Esc flow, typed: pick a checkpoint (or name a turn number)
+      // and restore messages and files to it.
+      const points = ctx.journal.list().reverse();
+      if (!points.length) { info('Nothing to rewind — send a message first.'); return null; }
+      const applyRewind = (index) => {
+        const outcome = ctx.journal.restore(index, ctx.messages);
+        if (!outcome.ok) { fail(`Rewind failed: ${outcome.error}`); return null; }
+        ctx.sessionState.messages = ctx.messages;
+        saveSession(ctx.sessionState);
+        ok(`Rewound to turn ${index + 1} — ${outcome.messageCount} message${outcome.messageCount === 1 ? '' : 's'} restored`
+          + (outcome.restored.length || outcome.deleted.length
+            ? c.dim(`  · ${outcome.restored.length} file${outcome.restored.length === 1 ? '' : 's'} reverted${outcome.deleted.length ? `, ${outcome.deleted.length} removed` : ''}`)
+            : ''));
+        for (const f of [...outcome.restored, ...outcome.deleted].slice(0, 5)) {
+          out(c.dim(`      ${displayPath(f)}`));
+        }
+        return null;
+      };
+      const n = Number(args[0]);
+      if (args[0] && Number.isInteger(n) && n >= 1) {
+        const found = points.find((p) => p.index + 1 === n);
+        if (!found) { warn(`No checkpoint for turn ${n} — ${points.length} checkpoint${points.length === 1 ? '' : 's'} available.`); return null; }
+        return applyRewind(found.index);
+      }
+      if (!ctx.tui) {
+        for (const p of points.slice(0, 9)) {
+          out(`  Turn ${p.index + 1}: ${(p.prompt || '(no prompt)').slice(0, 60)}${p.files ? c.dim(`  · ${p.files} file change${p.files === 1 ? '' : 's'} after`) : ''}`);
+        }
+        info(`Restore one with ${c.bold('/rewind <turn>')}.`);
+        return null;
+      }
+      const options = points.slice(0, 9).map((p) => ({
+        value: p.index,
+        label: `Turn ${p.index + 1}: ${(p.prompt || '(no prompt)').slice(0, 60)}${p.files ? c.dim(`  · ${p.files} file change${p.files === 1 ? '' : 's'} after`) : ''}`,
+      }));
+      const answer = await ctx.tui.askDialog(
+        `${c.bold('Rewind to an earlier turn?')} ${c.dim('(restores messages and files)')}`,
+        [...options, { value: null, label: c.dim('Keep current state') }],
+        [c.dim('Files the agent changed after the chosen turn are restored to their earlier contents.')],
+      );
+      const chosen = dialogValue(answer);
+      if (chosen === null || chosen === undefined) { info('Still on the current timeline.'); return null; }
+      return applyRewind(chosen);
+    }
+
+    case '/version':
+      out(`  jaitus ${c.bold(`v${VERSION}`)}`);
+      return null;
+
+    case '/feedback': {
+      // No backend involved: the report lands in ~/.jaitus/feedback.log with
+      // the session facts attached, ready to paste into an issue.
+      const text = args.join(' ').trim();
+      if (!text) { info(`Usage: ${c.bold('/feedback')} <what happened> — saved locally with session context.`); return null; }
+      try {
+        const line = `[${new Date().toISOString()}] session=${ctx.sessionState.id} model=${ctx.model} cwd=${ctx.flags.cwd} turns=${spent.turns}\n  ${text.replace(/\n/g, '\n  ')}\n`;
+        fs.appendFileSync(path.join(HOME, 'feedback.log'), line, 'utf8');
+        ok(`Noted in ${c.bold('~/.jaitus/feedback.log')} — thank you. ${c.dim('/export sends the full conversation with it.')}`);
+      } catch (e) {
+        fail(`Could not save feedback: ${e.message}`);
+      }
+      return null;
+    }
+
+    case '/animations': {
+      const { loadSettings: loadSa, saveSettings: saveSa } = await import('./config.js');
+      const want = (args[0] || '').toLowerCase();
+      if (!want) {
+        const on = loadSa().animations !== false && !process.env.JAITUS_NO_ANIMATION;
+        info(`Animations: ${c.bold(on ? 'on' : 'off')} — shimmer, sweeps, stagger. ${c.bold('/animations on|off')} to change.`);
+        return null;
+      }
+      if (!['on', 'off'].includes(want)) { warn('Use /animations on or /animations off.'); return null; }
+      saveSa({ ...loadSa(), animations: want === 'on' });
+      ok(`Animations ${c.bold(want)}.`);
+      return null;
+    }
+
+    case '/login':
+      await login(['--force']);
+      return null;
+
+    case '/logout': {
+      const { default: logout } = await import('./commands/logout.js');
+      await logout();
+      return 'exit';
+    }
+
+    case '/doctor': {
+      const { default: doctor } = await import('./commands/doctor.js');
+      await doctor([], {});
+      return null;
+    }
+
+    // Shell commands, usable without leaving the session. Output routes
+    // through the transcript like everything else in fullscreen.
+    case '/whoami':
+      await commands.whoami.run([], {});
+      return null;
+
+    case '/usage':
+      await commands.usage.run([], {});
+      return null;
+
+    case '/init':
+      await commands.init.run([], { flags: ctx.flags });
+      return null;
+
+    case '/mcp':
+      await commands.mcp.run(args, { json: false, flags: ctx.flags });
+      return null;
+
+    case '/config':
+      await commands.config.run(args, { json: false });
+      return null;
+
+    case '/update':
+      await commands.update.run([], { json: false });
+      return null;
+
+    case '/banner': {
+      // Session header on demand, codex-style.
+      const modeApproval = ctx.permissions.mode === 'plan' ? 'read-only'
+        : ctx.permissions.mode === 'acceptEdits' ? 'auto-edit'
+        : ctx.permissions.mode === 'bypassPermissions' ? 'off' : 'ask';
+      ctx.tui.print(`  ${c.dim(`jaitus v${VERSION}`)}`);
+      ctx.tui.print(`  ${c.dim(`model ${ctx.model} · approval ${modeApproval} · ${ctx.flags.cwd}`)}`);
+      return null;
+    }
+
+    case '/clear':
+      ctx.messages.length = 0;
+      // A cleared conversation is also the natural moment to pick up an edited
+      // .jaitusignore, rather than making people restart the session for it.
+      forgetIgnoreCache();
+      ctx.tui?.clearTranscript();
+      ctx.resetContext?.();
+      ok('Conversation cleared.');
+      return null;
+
+    case '/undo': {
+      // A turn is the user message plus everything the assistant added after it.
+      let i = messages.length - 1;
+      while (i >= 0 && !(messages[i].role === 'user' && typeof messages[i].content === 'string')) i--;
+      if (i >= 0) { messages.length = i; ctx.resetContext?.(); ok('Dropped the last exchange.'); }
+      else warn('Nothing to undo.');
+      return null;
+    }
+
+    case '/model': {
+      const available = await client.models();
+      const applyModel = (id) => {
+        ctx.setModel(id);
+        ok(`Model for this session: ${c.bold(id)}`);
+        info(`${c.dim(`jaitus config model ${id}`)} makes it the default.`);
+      };
+      if (args[0]) {
+        if (available.length && !available.includes(args[0])) {
+          warn(`The gateway does not advertise ${args[0]}. It lists: ${available.join(', ')}`);
+          return null;
+        }
+        applyModel(args[0]);
+        return null;
+      }
+      if (!available.length) { warn('The gateway returned no models.'); return null; }
+      if (!ctx.tui) { info(`Model: ${c.bold(ctx.model)}`); return null; }
+      const picked = await pickOption(ctx.tui, 'Model', 'Which model serves this session?',
+        available.slice(0, 9).map((m) => ({ value: m, label: `${m === ctx.model ? '●' : '○'}  ${m}` })));
+      if (!picked) return null;
+      applyModel(picked);
+      return null;
+    }
+
+    case '/models': {
+      const list = await client.models();
+      if (!list.length) { warn('The gateway returned no models.'); return null; }
+      list.forEach((m) => out(`  ${m === ctx.model ? c.brand('●') : c.grey('○')} ${m}`));
+      return null;
+    }
+
+    case '/cost':
+      table([
+        ['  Turns', String(spent.turns)],
+        ['  Tool calls', String(spent.tools)],
+        ['  Input tokens', spent.input.toLocaleString()],
+        ['  Cached input tokens', (spent.cached || 0).toLocaleString()],
+        ['  Output tokens', spent.output.toLocaleString()],
+      ]);
+      info(`${c.dim('Billed usage is what your account records — see')} ${c.bold('jaitus usage')}.`);
+      return null;
+
+    case '/cwd':
+      info(flags.cwd);
+      return null;
+
+    default:
+      if (ctx.skills?.[verb.slice(1)]) {
+        const skill = ctx.skills[verb.slice(1)];
+        ctx.messages.push({ role: 'user', content: `${skill.content}\n\nUser request for this workflow: ${args.join(' ') || 'Run the workflow.'}` });
+        await ctx.runManaged(ctx.messages);
+        return null;
+      }
+      warn(`Unknown command: ${verb}. Try /help.`);
+      return null;
+  }
+}
+
+// ─── Commands ───────────────────────────────────────────────────────────────────
+
+// How an account's plan reads in whoami and usage: the tier, and where this period stands.
+function fmtTokens(n) {
+  const v = Number(n) || 0;
+  if (v >= 1e9) return `${+(v / 1e9).toFixed(1)}B`;
+  if (v >= 1e6) return `${+(v / 1e6).toFixed(1)}M`;
+  if (v >= 1e3) return `${Math.round(v / 1e3)}K`;
+  return String(Math.round(v));
+}
+function planRows(u) {
+  const st = u.planStatus || null;
+  if (!u.isPaid) return [['Plan', 'Free'], ['Free prompts', `${u.freeRequestsUsed ?? 0} of ${u.freeRequestLimit ?? '?'} used`]];
+  const rows = [['Plan', st?.name || 'Paid']];
+  if (st?.monthlyTokens) {
+    const resets = st.periodResetsAt ? ` · resets ${new Date(st.periodResetsAt).toLocaleDateString()}` : '';
+    rows.push(['This period', `${fmtTokens(st.periodTokens)} of ${fmtTokens(st.monthlyTokens)} tokens${resets}`]);
+  }
+  if (u.planExpiresAt) rows.push(['Renews by', new Date(u.planExpiresAt).toLocaleDateString()]);
+  return rows;
+}
+
+const commands = {
+  login: {
+    summary: 'sign in through your browser',
+    usage: ['jaitus login [--force]'],
+    detail: [
+      'Opens the Jaitus website; you approve there, and this terminal is signed in',
+      'over a loopback connection with PKCE. No credential ever travels in a URL.',
+      'The session is kept in ~/.jaitus/credentials.json and renews itself; signing',
+      'in again on this machine replaces its previous session.',
+    ],
+    run: (argv) => login(argv),
+  },
+
+  logout: {
+    summary: 'sign this device out',
+    usage: ['jaitus logout'],
+    detail: ['Ends this device\'s session on the server, then removes it from this machine.'],
+    run: async () => logout(),
+  },
+
+  whoami: {
+    summary: 'who you are signed in as',
+    usage: ['jaitus whoami [--json]'],
+    run: async (argv, { json }) => {
+      if (!signedIn()) {
+        info('Not signed in. Run `jaitus login`.');
+        return 1;
+      }
+      const client = requireAuth();
+      const { ok: good, body } = await client.api('/auth/me');
+      if (!good) { fail(body?.message || 'Could not reach your account.'); return 1; }
+      const u = body.user || body.data || {};
+      present(json, u, () => table([
+        ['Account', u.email || '—'],
+        ...planRows(u),
+        ['Gateway', endpoints().baseUrl],
+      ]));
+      return 0;
+    },
+  },
+
+  usage: {
+    summary: 'your usage and remaining free prompts',
+    usage: ['jaitus usage [--json]'],
+    run: async (argv, { json }) => {
+      const client = requireAuth();
+      const [{ ok: good, body }, me] = await Promise.all([client.api('/usage/summary'), client.api('/auth/me').catch(() => ({}))]);
+      if (!good) { fail(body?.message || 'Could not load usage.'); return 1; }
+      const d = body.data || {};
+      const u = me?.body?.user || me?.body?.data || null;
+      present(json, { ...d, planStatus: u?.planStatus || null }, () => table([
+        ...(u ? planRows(u) : []),
+        ['Today', `${d.today?.requests ?? 0} requests`],
+        ['This month', `${d.month?.requests ?? 0} requests`],
+        ['Tokens used', `${(d.totalTokensConsumed ?? 0).toLocaleString()}`],
+      ]));
+      return 0;
+    },
+  },
+
+  models: {
+    summary: 'model ids this gateway accepts',
+    usage: ['jaitus models [--json]'],
+    run: async (argv, { json }) => {
+      const client = requireAuth();
+      const list = await client.models();
+      if (!list.length) { warn('The gateway returned no models.'); return 1; }
+      const current = loadSettings().model;
+      present(json, { models: list, default: current || list[0] }, () => {
+        list.forEach((m) => out(`  ${m === current ? c.brand('●') : c.grey('○')} ${m}`));
+        out('');
+        info(`Set one with ${c.bold('jaitus config model <id>')}`);
+      });
+      return 0;
+    },
+  },
+
+  sessions: {
+    summary: 'list saved sessions for this directory',
+    usage: ['jaitus sessions [--json]'],
+    detail: ['Sessions are stored locally under ~/.jaitus/sessions and never sent to the gateway until resumed.'],
+    run: (argv, { json, flags }) => {
+      const data = listSessions({ cwd: flags.cwd }).map(sessionSummary);
+      present(json, { sessions: data }, () => {
+        if (!data.length) { info('No saved sessions in this directory yet.'); return; }
+        data.forEach((item) => out(`  ${item.id.slice(0, 8)}  ${c.bold(item.title)}  ${c.dim(item.updatedAt)}`));
+      });
+      return 0;
+    },
+  },
+
+  mcp: {
+    summary: 'list or configure MCP tool servers',
+    usage: [
+      'jaitus mcp list',
+      'jaitus mcp add <name> <command> [args...]',
+      'jaitus mcp remove <name>',
+    ],
+    detail: ['Local stdio servers are read from .mcp.json and exposed to the agent as permission-gated tools.'],
+    run: (argv, { json, flags }) => {
+      const [action = 'list', name, command, ...args] = argv;
+      if (action === 'list') {
+        const servers = listMcpServers(flags.cwd);
+        present(json, { servers }, () => {
+          if (!servers.length) { info('No MCP servers configured.'); return; }
+          servers.forEach((server) => out(`  ${c.brand(server.name)}  ${server.transport}  ${server.command}`));
+        });
+        return 0;
+      }
+      if (action === 'add' && name && command) {
+        addMcpServer(flags.cwd, name, { type: 'stdio', command, args });
+        ok(`Added MCP server ${c.bold(name)}.`);
+        return 0;
+      }
+      if (action === 'remove' && name) {
+        if (!removeMcpServer(flags.cwd, name)) { warn(`No MCP server named ${name}.`); return 1; }
+        ok(`Removed MCP server ${c.bold(name)}.`);
+        return 0;
+      }
+      fail('Usage: jaitus mcp list | add <name> <command> [args...] | remove <name>');
+      return 1;
+    },
+  },
+
+  config: {
+    summary: 'show or change where the CLI is pointed',
+    usage: [
+      'jaitus config                    show everything',
+      'jaitus config model              show one value',
+      'jaitus config model <id>         set it',
+      'jaitus config theme <name>       dark, light, daltonized, plain, auto',
+      'jaitus config copyOnSelect <on|off>   auto-copy mouse selection',
+    ],
+    detail: [
+      'Settable: model, baseUrl, siteUrl, theme, copyOnSelect, scrollSpeed, wheelAccel, autoScroll, animations, autoCompact, mouse, statusLine,',
+      'braveSearchKey, tavilyKey, serperKey. Stored in ~/.jaitus/settings.json.',
+      '',
+      'A search API key is the single biggest improvement available to web_search: the free',
+      'engines are scraped HTML and their quality varies by network and by day. Brave and',
+      'Tavily both have free tiers. Without one, Jaitus still queries npm, GitHub, MDN and',
+      'Stack Overflow directly, which covers most of what a coding agent asks.',
+    ],
+    run: (argv, { json }) => {
+      const [key, value] = argv;
+      const settings = loadSettings();
+      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'mouse'];
+      const SECRET = ['braveSearchKey', 'tavilyKey', 'serperKey'];
+      if (!key) {
+        const e = endpoints();
+        const data = {
+          gateway: e.baseUrl,
+          website: e.siteUrl,
+          model: settings.model || null,
+          theme: settings.theme || 'auto',
+          statusLine: settings.statusLine || null,
+          copyOnSelect: settings.copyOnSelect !== false,
+          scrollSpeed: settings.scrollSpeed ?? 1,
+          wheelAccel: settings.wheelAccel !== false,
+          autoScroll: settings.autoScroll !== false,
+          animations: settings.animations !== false,
+          autoCompact: settings.autoCompact !== false,
+          mouse: settings.mouse !== false,
+          // Presence and length only. A key echoed into a transcript is a key that has
+          // been published, and the transcript is on disk.
+          searchApi: SECRET.find((k) => settings[k]) || null,
+          configDir: HOME,
+        };
+        present(json, data, () => table([
+          ['Gateway', data.gateway],
+          ['Website', data.website],
+          ['Model', data.model || 'whatever the gateway lists first'],
+          ['Theme', `${data.theme} (dark, light, daltonized, plain, auto)`],
+          ['Copy on select', data.copyOnSelect ? 'on (drag selects, auto-copies)' : 'off (Ctrl+Shift+C copies)'],
+          ['Scroll speed', String(data.scrollSpeed)],
+          ['Wheel accel', data.wheelAccel ? 'on' : 'off'],
+          ['Auto-scroll', data.autoScroll ? 'on' : 'off'],
+          ['Animations', data.animations ? 'on' : 'off'],
+          ['Auto-compact', data.autoCompact ? 'on (summarises near the context limit)' : 'off'],
+          ['Mouse', data.mouse ? 'on (wheel scrolls, clicks act; shift+drag selects)' : 'off'],
+          ['Search API', data.searchApi ? `${data.searchApi} (set)` : 'none — using free engines + npm/GitHub/MDN/Stack Overflow'],
+          ['Status line', data.statusLine || '(unset — set a command to render one)'],
+          ['Config', data.configDir],
+        ]));
+        return 0;
+      }
+      if (!['model', 'baseUrl', 'siteUrl', 'theme', 'statusLine', ...ONOFF, ...SECRET, 'scrollSpeed'].includes(key)) {
+        fail(`Unknown setting: ${key}. Try model, baseUrl, siteUrl, theme, statusLine, ${ONOFF.join(', ')}, ${SECRET.join(', ')} or scrollSpeed.`);
+        return 1;
+      }
+      if (!value) {
+        // Never print a key back. Whether it is set, and how long it is, answers every
+        // question anyone actually has about it.
+        if (SECRET.includes(key)) { out(settings[key] ? `set (${String(settings[key]).length} characters)` : ''); return 0; }
+        if (key === 'theme') { out(settings.theme || 'auto'); return 0; }
+        if (key === 'statusLine') { out(settings.statusLine || ''); return 0; }
+        if (ONOFF.includes(key)) { out(settings[key] !== false ? 'on' : 'off'); return 0; }
+        if (key === 'scrollSpeed') { out(String(settings.scrollSpeed ?? 1)); return 0; }
+        out(String(settings[key] ?? '')); return 0;
+      }
+      if (key === 'theme') {
+        if (!['dark', 'light', 'daltonized', 'plain', 'auto'].includes(value)) { fail('Use dark, light, daltonized, plain or auto.'); return 1; }
+        settings.theme = value;
+        saveSettings(settings);
+        ok(`theme = ${value}`);
+        return 0;
+      }
+      if (ONOFF.includes(key)) {
+        const on = /^(on|true|1|yes)$/i.test(value);
+        const off = /^(off|false|0|no)$/i.test(value);
+        if (!on && !off) { fail(`Use jaitus config ${key} on|off`); return 1; }
+        settings[key] = on;
+        saveSettings(settings);
+        ok(`${key} = ${on ? 'on' : 'off'}`);
+        return 0;
+      }
+      if (key === 'scrollSpeed') {
+        const n = Number(value);
+        if (!Number.isFinite(n) || n < 0.25 || n > 20) { fail('Use 0.25–20.'); return 1; }
+        settings.scrollSpeed = n;
+        saveSettings(settings);
+        ok(`scrollSpeed = ${n}`);
+        return 0;
+      }
+      settings[key] = value;
+      saveSettings(settings);
+      ok(`${key} = ${value}`);
+      return 0;
+    },
+  },
+
+  init: {
+    summary: `create ${CONTEXT_FILE} and .jaitusignore here`,
+    usage: ['jaitus init [--force]'],
+    detail: [
+      `${CONTEXT_FILE} is sent to the agent with every request in this project.`,
+      '.jaitusignore lists paths it must not list, search, read or write.',
+      'Both are meant to be committed, so everyone gets the same behaviour.',
+    ],
+    run: (argv, { flags }) => init(argv, { cwd: flags.cwd }),
+  },
+
+  doctor: {
+    summary: 'check everything that can stop this working',
+    usage: ['jaitus doctor [--json]'],
+    detail: [
+      'Node version, config directory, sign-in, gateway reachability, the account',
+      'and whether an update is out. Never prints your key — only whether one is set.',
+    ],
+    run: (argv, { json }) => doctor(argv, { json }),
+  },
+
+  update: {
+    summary: 'check whether a newer version is published',
+    usage: ['jaitus update [--json]'],
+    detail: ['Reports; does not install. How this CLI was installed is yours to decide.'],
+    run: (argv, { json }) => update(argv, { json }),
+  },
+
+  completion: {
+    summary: `print a completion script (${SHELLS.join(', ')})`,
+    usage: ['jaitus completion <shell>'],
+    detail: ['Each script carries its own one-line install instruction at the top.'],
+    run: (argv) => completion(argv, {
+      commands: Object.keys(commands),
+      flags: FLAG_NAMES.filter((f) => f.startsWith('--')),
+    }),
+  },
+
+  banner: {
+    summary: 'draw the logo',
+    hidden: true,
+    usage: ['jaitus banner [--image]'],
+    run: async (argv, { flags = {} } = {}) => {
+      const image = flags?.image === true || argv.includes('--image');
+      // Probe sixel support first so --image draws real pixels when possible.
+      try {
+        const { probeAsync } = await import('./terminal.js');
+        await probeAsync({ timeoutMs: 350 });
+      } catch { /* quiet fallback below */ }
+      await banner({ version: VERSION, force: true, image });
+      return 0;
+    },
+  },
+
+  version: {
+    summary: 'print the version',
+    hidden: true,
+    run: () => { out(VERSION); return 0; },
+  },
+
+  help: {
+    summary: 'help for a command',
+    usage: ['jaitus help [command]'],
+    run: async (argv) => {
+      if (!argv[0]) { await showHelp(); return 0; }
+      return commandHelp(argv[0]);
+    },
+  },
+};
+
+async function showHelp() {
+  await banner({ version: VERSION });
+  if (!process.stdout.isTTY || process.env.JAITUS_NO_BANNER) out(`\n  ${wordmark(VERSION)}\n`);
+  out(helpText());
+}
+
+// ─── Entry point ────────────────────────────────────────────────────────────────
+
+export default async function main(argv) {
+  const { flags, rest, passthrough } = parseArgs(argv);
+
+  if (flags.version) { out(VERSION); return 0; }
+
+  const [first, ...others] = rest;
+  const cmd = commands[first];
+
+  if (flags.help) {
+    if (cmd) return commandHelp(first);
+    await showHelp();
+    return 0;
+  }
+
+  if (cmd) return cmd.run([...others, ...passthrough], { json: flags.json, flags });
+
+  // An unrecognised option is a mistake, not part of the task. Silently folding it into
+  // the prompt is how `jaitus --moddel x "fix this"` ends up asking the model to fix
+  // something while quietly ignoring the flag the user thought they set.
+  if (passthrough.length) {
+    fail(`Unknown option: ${passthrough[0]}`);
+    info(`Run ${c.bold('jaitus --help')} to see the options, or put your task in quotes.`);
+    return 1;
+  }
+
+  if (first && first.startsWith('/')) {
+    fail(`${first} only works inside a session. Run ${c.bold('jaitus')} first.`);
+    return 1;
+  }
+
+  const piped = await readStdin();
+  const prompt = rest.join(' ').trim();
+
+  if (prompt) {
+    const task = piped ? `${prompt}\n\n--- piped input ---\n${piped}` : prompt;
+    return oneShot(task, { flags });
+  }
+  if (piped) return oneShot(piped, { flags });
+
+  if (flags.print) {
+    fail('Print mode needs a prompt: jaitus -p "explain this project"');
+    return 1;
+  }
+
+  if (!process.stdin.isTTY) {
+    err('Nothing to do. Give a task: jaitus "add a test for the parser"');
+    return 1;
+  }
+  return session({ flags });
+}