nexrall-code 0.5.116 → 0.5.118

package/dist/commands/chat.js

@@ -1,2715 +0,0 @@
-import * as readline from 'readline';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as crypto from 'crypto';
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import { execSync, execFileSync } from 'child_process';
-import chalk from 'chalk';
-import { runAgentLoop, getBalance, describeAttachment, CheckpointManager, loadPlugins, isDestructiveBash, compactMessagesForResume, readAllMemory, readMemory, memoryStats, clearMemory, loadSkills, findSkill, expandSkill, userInvokableSkills, salvageHistory, loadAgentTypesWithWarnings, McpManager, contextWindowFor, compactionThresholds, estimateTokensRough, estimateBodyBytes, getModelCatalogue, liveLabelFor, liveCostMultiplierFor, liveSupportsImageInput, liveSupportsPdfInput, liveReasoningEffortStyle, liveVendorFor, liveSelectableModelIds, createWorktree, removeWorktree, enterWorktree, findWorktreeByName, listWorktrees, worktreeHasWork, registerPeer, listPeers, startPeerInbox, } from '@nexrall/code-core';
-import { formatToolUse, formatToolResult, formatUsage, formatThinking, MarkdownStreamRenderer, ToolStreamPrinter } from '../ui/theme';
-import { requestPermission, setAutoApprove, initPermissions, setMode, setReadlineInterface, isYoloMode } from '../permissions/handler';
-import { currentAudit, enableAudit } from '../audit';
-import { describeMode, resetSessionSubAgentBudget } from '@nexrall/code-core';
-import { listSessions, loadSession, saveSession, lastSession } from './sessions';
-import { decideTerminalSetup, detectMacOSMajor, installEditorKeybinding, enableAppleTerminalOptionAsMeta, SHIFT_ENTER_SEQUENCE, MACOS_NATIVE_SHIFT_RETURN_MAJOR, } from '../terminal/terminalSetup';
-import { updateCommand } from './update';
-import { prepareSessionScreen, padToBottom, startRowCount, stopRowCount, addRowCount, renderBanner as renderBannerCard, } from '../ui/screen';
-import { detectTrustSignals, trustGrantedByEnv, TRUST_ENV_VAR } from '../trust';
-import { askForTrust } from '../ui/trustPrompt';
-import { startInkTerminal, stopInkTerminal, getInkTerminal, flushInkFrame, footerText } from '../ui/inkTerminal';
-import { InkReadlineAdapter } from '../ui/inkReadlineAdapter';
-// CLI version for the startup banner, read from package.json — the single
-// source of truth — rather than hand-typed here.
-//
-// This WAS `const CLI_VERSION = '0.5.63'`, kept in sync by hand per the release
-// checklist. index.ts had the identical literal and was fixed to read
-// package.json after it shipped a lagging `nex --version`; this copy was missed
-// and silently drifted SEVEN releases (banner said 0.5.63 while the installed
-// package was 0.5.70). A release checklist step that must be remembered is not
-// a guarantee — deriving it is.
-// Resolved by WALKING UP to the nearest package.json rather than a fixed
-// relative path, because this file runs from two different layouts and no
-// single literal is correct in both:
-//   • built:  bundled by esbuild into packages/cli/dist/index.js  → '../package.json'
-//   • source: executed by tsx from packages/cli/src/commands/     → '../../package.json'
-// Hardcoding either one leaves the other throwing MODULE_NOT_FOUND at startup
-// (the test suite catches exactly that, which is how this was found).
-const require = createRequire(import.meta.url);
-const CLI_VERSION = (() => {
-    let dir = path.dirname(fileURLToPath(import.meta.url));
-    // Bounded walk: the package root is 1-2 levels up in both layouts; the guard
-    // stops at the filesystem root instead of looping if something is unexpected.
-    for (let i = 0; i < 6; i++) {
-        const candidate = path.join(dir, 'package.json');
-        if (fs.existsSync(candidate)) {
-            try {
-                const v = require(candidate).version;
-                if (typeof v === 'string' && v)
-                    return v;
-            }
-            catch { /* unreadable — keep walking */ }
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    // Never block startup over a banner string.
-    return 'unknown';
-})();
-// ─── Model Map ────────────────────────────────────────────────────────────────
-// NOTE: alias → real model ID mapping lives on the BACKEND (backend/routes/code.js
-// CODE_MODEL_MAP: turbo→claude-sonnet-5, pro→claude-opus-4-8, ultra→claude-fable-5).
-// The CLI sends the alias as-is; only display labels are resolved locally.
-// Display labels for the models the picker offers, plus the legacy tier aliases
-// an older config may still hold.
-//
-// The labels are the real model names now: with more than one provider, "Pro"
-// says nothing about what is running or what it costs, while "Claude Opus 5"
-// and "GPT-5.4" do. Aliases stay accepted on the wire (the backend resolves
-// them) but are shown under their real name so the two never look like
-// different things.
-const MODEL_LABELS = {
-    'claude-sonnet-5': 'Claude Sonnet 5',
-    'claude-opus-5': 'Claude Opus 5',
-    'claude-fable-5': 'Claude Fable 5',
-    'claude-haiku-4-5-20251001': 'Claude Haiku 4.5',
-    'gpt-5.6-sol': 'GPT-5.6 Sol',
-    'gpt-5.6-terra': 'GPT-5.6 Terra',
-    'gpt-5.6-luna': 'GPT-5.6 Luna',
-    'gpt-5.4': 'GPT-5.4',
-    'gpt-5.4-mini': 'GPT-5.4 Mini',
-    'gpt-4.1': 'GPT-4.1',
-    'deepseek-flash': 'DeepSeek Flash',
-    'qwen3.7-max': 'Qwen3.7 Max',
-    'glm-5.3': 'GLM 5.3',
-};
-/** Legacy tier alias -> real model id. Kept so existing configs keep working. */
-const LEGACY_MODEL_ALIASES = {
-    turbo: 'claude-sonnet-5',
-    auto: 'claude-sonnet-5',
-    pro: 'claude-opus-5',
-    power: 'claude-opus-5',
-    ultra: 'claude-fable-5',
-    fast: 'claude-haiku-4-5-20251001',
-};
-/** Models offered by `/model` and `--model`, in display order (grouped by provider). */
-const SELECTABLE_MODELS = [
-    'claude-sonnet-5', 'claude-opus-5', 'claude-fable-5',
-    'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna',
-    'gpt-5.4', 'gpt-5.4-mini', 'gpt-4.1',
-    'deepseek-flash',
-    'qwen3.7-max',
-    'glm-5.3',
-];
-// Relative cost vs gpt-4.1 / qwen3.7-max (=1x), for the "which one's cheaper"
-// hint printed by `/model` and shown as a badge in the VS Code model menu.
-// Rounded to friendly round numbers off backend/migrations/113_multi_provider_
-// pricing.sql and 114_deepseek_qwen_pricing.sql's per-1M-token pricing — a
-// relative signal only, not a live price feed. It will drift if pricing
-// changes without this table being updated by hand (no shared source between
-// this repo and the backend's model_pricing table).
-const MODEL_COST_MULTIPLIER = {
-    'claude-sonnet-5': 1.5,
-    'claude-opus-5': 3,
-    'claude-fable-5': 5,
-    // GPT-5.6 family (2026-07 launch, Terra/Luna repriced 2026-07-30) — same
-    // relative-to-gpt-4.1/qwen3.7-max (=1x) signal as every other row here,
-    // off backend migration 132's per-1M-token seed prices (Sol $5/$30, Terra
-    // $2/$12, Luna $0.20/$1.20 vs gpt-4.1's $2/$8).
-    'gpt-5.6-sol': 2,
-    'gpt-5.6-terra': 1.2,
-    'gpt-5.6-luna': 0.1,
-    'gpt-5.4': 2,
-    'gpt-5.4-mini': 0.5,
-    'gpt-4.1': 1,
-    'deepseek-flash': 0.1,
-    'qwen3.7-max': 1,
-    // $1.40/$4.40 per 1M in/out (docs.z.ai, 2026-08-30) vs gpt-4.1's $2.00/$8.00
-    // (migration 113) — roughly 0.6x on a blended 75/25 in/out turn. Rounded to
-    // a friendly number like every other row; re-check backend/migrations/
-    // 130_glm_5_3_pricing.sql's own caveat if Z.ai ships a GLM-5.3-specific rate.
-    'glm-5.3': 0.6,
-};
-function modelWithCostHint(id) {
-    // Live catalogue first (GET /api/code/models, fetched once at session
-    // start — see fetchLiveModelCatalogue below), falling back to this
-    // hand-maintained table when offline or on an older backend.
-    const mult = liveCostMultiplierFor(id, MODEL_COST_MULTIPLIER[id]);
-    return mult === undefined ? id : `${id} (${mult}x)`;
-}
-// Models with NO image/vision input support, mirroring backend
-// services/providers/modelRegistry.js's `supportsImageInput: false` rows.
-// This is now the FALLBACK, not the source of truth: needsVisionSidecar()
-// below checks the live catalogue (GET /api/code/models) first, so a model
-// added to the backend registry gets the CORRECT gating even before this
-// table is updated by hand for a new nexrall-code release. Kept as a fallback
-// for offline use / older backends without the route.
-//
-// 2026-08-11+: no longer a hard refusal. A model in this set still cannot see
-// the raw bytes, but claude-sonnet-5 transcribes the attachment into a text
-// spec BEFORE it is ever pushed into `messages`, so the turn proceeds on the
-// model the user actually picked — see describeAttachment's header in
-// @nexrall/code-core for why this only needs to happen once, not per turn.
-//
-// deepseek-flash (DeepSeek-V4.1-Flash, renamed from deepseek-v4-pro 2026-09)
-// is DELIBERATELY absent here — DeepSeek's own pricing page marks Vision as
-// supported for this model (unlike the retired deepseek-v4-pro), so it sees
-// the raw image bytes directly and needs no sidecar. See backend
-// services/providers/modelRegistry.js's own comment on this id.
-const NO_VISION_MODELS = new Set(['qwen3.7-max', 'glm-5.3']);
-// Models with NO PDF/`document`-block support at all. Wider than
-// NO_VISION_MODELS: none of the OpenAI-compatible models (GPT included) speak
-// Anthropic's `document` content-block shape — there is no equivalent field in
-// `chat/completions` — so the backend degrades it to a text placeholder for
-// EVERY one of them (see backend streamFactory.js's `document` branch),
-// regardless of whether that model has vision support. deepseek-flash is
-// listed explicitly here (not inherited via NO_VISION_MODELS) since it has
-// vision but still has no PDF/document-block support.
-const NO_PDF_MODELS = new Set([
-    'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna',
-    'gpt-5.4', 'gpt-5.4-mini', 'gpt-4.1', 'gpt-4o-mini',
-    'deepseek-flash',
-    ...NO_VISION_MODELS,
-]);
-/**
- * Does `model` need the blind-attachment sidecar for an image? Live catalogue
- * first (populated by fetchLiveModelCatalogue at session start), static
- * NO_VISION_MODELS fallback otherwise — see that Set's own doc comment.
- */
-function needsVisionSidecar(model) {
-    return !liveSupportsImageInput(model, !NO_VISION_MODELS.has(model));
-}
-/** Same live-first, static-fallback pattern as needsVisionSidecar, for PDFs. */
-function needsPdfSidecar(model) {
-    return !liveSupportsPdfInput(model, !NO_PDF_MODELS.has(model));
-}
-/**
- * The models `/model` and `--model` offer, in display order. Live catalogue
- * first (already grouped/ordered by the backend the same way
- * SELECTABLE_MODELS is by hand), static fallback otherwise.
- */
-function selectableModelIds() {
-    return liveSelectableModelIds() ?? SELECTABLE_MODELS;
-}
-export function normaliseModelId(model) {
-    const raw = (model ?? '').trim();
-    if (!raw)
-        return 'claude-sonnet-5';
-    return LEGACY_MODEL_ALIASES[raw.toLowerCase()] ?? raw;
-}
-/** Keyed by exact model id — mirrors backend modelRegistry.js's REASONING_EFFORT_STYLE. */
-const MODEL_EFFORT_STYLE = {
-    // GPT-5.6 Sol/Terra/Luna hit the SAME "reasoning_effort + tools" 400 as
-    // gpt-5.4/mini below (confirmed by multiple third-party integrations
-    // 2026-07: github.com/BerriAI/litellm#33221, github.com/danny-avila/
-    // LibreChat#14231) — OPENAI_GATED already handles that (skip when tools
-    // are present), so no new style is needed for this family.
-    'gpt-5.6-sol': 'openai_gated',
-    'gpt-5.6-terra': 'openai_gated',
-    'gpt-5.6-luna': 'openai_gated',
-    'gpt-5.4': 'openai_gated',
-    'gpt-5.4-mini': 'openai_gated',
-    'gpt-4.1': 'none',
-    'gpt-4o-mini': 'none',
-    'deepseek-flash': 'deepseek',
-    'qwen3.7-max': 'qwen',
-    'glm-5.3': 'glm',
-    // Everything else (all claude-* ids) falls through to 'anthropic' below.
-};
-const EFFORT_STYLE_CONFIG = {
-    // Anthropic's real output_config.effort enum is low|medium|high|xhigh|max
-    // (docs.claude.com extended output). 'extra'/'ultra' are legacy UI labels
-    // this codebase invented, translated server-side by routes/code.js's
-    // EFFORT_MAP (extra->xhigh, ultra->max) — kept as the wire values here
-    // (rather than switching to 'xhigh'/'max' directly) only for backward
-    // compatibility with saved sessions/scripts already passing them.
-    anthropic: { levels: ['low', 'medium', 'high', 'extra', 'ultra'], names: ['Low', 'Medium', 'High', 'Extra High', 'Max'] },
-    // DeepSeek V4 has THREE real buckets — live-verified against
-    // api.deepseek.com 2026-08-30 (see streamFactory.test.js's DEEPSEEK case):
-    // low->low, medium/high/xhigh->high, max->max.
-    deepseek: { levels: ['low', 'high', 'max'], names: ['Low', 'Standard', 'Max'] },
-    // Qwen3.7-Max's knob is a boolean (enable_thinking), not a graded scale.
-    qwen: { levels: ['low', 'high'], names: ['Thinking Off', 'Thinking On'] },
-    // GLM-5.3 cannot disable reasoning at all (a hard 400 if you try) and has
-    // 3 real buckets (low/high/max) via a FLAT top-level `reasoning_effort`
-    // string — live-verified against api.z.ai 2026-08-30 (see
-    // streamFactory.test.js's GLM_THINKING_LEVEL case).
-    glm: { levels: ['low', 'high', 'max'], names: ['Low', 'High', 'Max'] },
-    // Effectively a no-op today whenever the turn has tools (almost always true
-    // for nexrall-code) — see backend modelRegistry.js's OPENAI_GATED doc
-    // comment. Still forwards a real value for the rare tool-less turn.
-    openai_gated: { levels: ['low', 'medium', 'high'], names: ['Low', 'Medium', 'High'] },
-    // No reasoning-effort concept on this model at all (gpt-4.1, gpt-4o-mini).
-    none: { levels: ['medium'], names: ['N/A'] },
-};
-/**
- * Backend REASONING_EFFORT_STYLE value (modelRegistry.js) -> this file's
- * EffortStyle.
- */
-const _BACKEND_STYLE_TO_LOCAL = {
-    openai_gated: 'openai_gated',
-    deepseek: 'deepseek',
-    qwen_thinking_toggle: 'qwen',
-    glm_thinking_level: 'glm',
-    none: 'none',
-};
-function effortStyleFor(modelId) {
-    const id = normaliseModelId(modelId);
-    // Anthropic's five-level lever isn't `reasoningEffortStyle` at all — the
-    // backend reports 'none' for EVERY Anthropic model (Claude has no
-    // `reasoning_effort` field; its lever is the separate output_config.effort
-    // mechanism this file models as 'anthropic'). Detect by VENDOR rather than
-    // by style string, mirroring webview/main.js's applyModelCatalogue (same
-    // exception, same reason) — checking the static table instead would wrongly
-    // fall through to 'none' for a brand-new Anthropic model this table has
-    // never seen.
-    if (liveVendorFor(id) === 'Anthropic')
-        return 'anthropic';
-    const liveStyle = liveReasoningEffortStyle(id);
-    if (liveStyle && _BACKEND_STYLE_TO_LOCAL[liveStyle])
-        return _BACKEND_STYLE_TO_LOCAL[liveStyle];
-    return MODEL_EFFORT_STYLE[id] ?? 'anthropic';
-}
-export function effortConfigFor(modelId) {
-    return EFFORT_STYLE_CONFIG[effortStyleFor(modelId)];
-}
-/**
- * Clamp a stored/requested effort token to one this model's scale actually
- * has. Without this, switching from Claude (5 levels) to Qwen (2 levels)
- * would leave an unsupported token in state — the CLI would echo back
- * "Effort → extra" for a model that silently treats it as its default.
- *
- * @returns a wire value guaranteed to be in `effortConfigFor(modelId).levels`
- */
-function clampEffortForModel(effort, modelId) {
-    const config = effortConfigFor(modelId);
-    if (config.levels.includes(effort))
-        return effort;
-    return defaultEffortForModel(modelId);
-}
-/** The "normal" notch for a model's scale — its SECOND level where one exists. */
-function defaultEffortForModel(modelId) {
-    const levels = effortConfigFor(modelId).levels;
-    return levels[Math.min(1, levels.length - 1)];
-}
-/**
- * Label for a model id or legacy alias.
- *
- * An UNKNOWN id echoes back as-is rather than silently displaying the default
- * model's name: this build ships independently of the backend, so a model added
- * server-side is valid before this table knows about it. Showing "Claude Sonnet
- * 5" for a session actually running something else would be a lie in the one
- * place the user looks to check.
- */
-function resolveModelLabel(alias) {
-    const id = normaliseModelId(alias);
-    return liveLabelFor(id, MODEL_LABELS[id] ?? id);
-}
-// Session helpers imported from sessions.ts
-// ─── Env collection ───────────────────────────────────────────────────────────
-function tryExec(cmd, cwd) {
-    try {
-        return execSync(cmd, { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-// ─── Low/zero balance topup notice ────────────────────────────────────────────
-// Same deep-link the VS Code extension's gear-icon "Payment & Billing" and the
-// web app's ?settings=billing param both already use.
-const BILLING_URL = 'https://app.nexrall.com/?settings=billing';
-// OSC 8 terminal hyperlink — terminals that support it (iTerm2, Kitty, modern
-// Windows Terminal, VS Code's integrated terminal, etc.) render `label` as a
-// clickable link; terminals that don't just print `label` with the escape
-// codes stripped by their parser, so this degrades gracefully everywhere.
-function hyperlink(label, url) {
-    return `\x1b]8;;${url}\x1b\\${label}\x1b]8;;\x1b\\`;
-}
-// Deduped per-process: only re-print when the state actually changes (low →
-// zero, or after a topup brings the balance back up and it drops again later)
-// — mirrors CanvasChat.jsx's lastBalanceNoticeRef, so a long session doesn't
-// reprint this on every single turn while the user stays under the threshold.
-let lastBalanceNoticeState = null;
-function printBalanceNotice(balance, zero) {
-    const state = zero ? 'zero' : 'low';
-    if (lastBalanceNoticeState === state)
-        return;
-    lastBalanceNoticeState = state;
-    const title = zero ? 'Out of balance' : 'Balance running low';
-    const detail = zero
-        ? "You're out of funds — top up to keep the agent working."
-        : `Your wallet is under $5${typeof balance === 'number' ? ` ($${balance.toFixed(2)} left)` : ''}. Top up before it runs out.`;
-    console.log();
-    console.log(chalk.bgYellow.black(` ${title} `) + '  ' + chalk.dim(detail));
-    console.log('  ' + chalk.yellow(hyperlink('→ Top up', BILLING_URL)) + chalk.dim(`  (${BILLING_URL})`));
-    console.log();
-}
-/** OS username fallback for the "Welcome back <name>!" banner greeting. */
-function currentUserLabel() {
-    try {
-        const u = os.userInfo().username;
-        return u ? u.charAt(0).toUpperCase() + u.slice(1) : 'there';
-    }
-    catch {
-        return 'there';
-    }
-}
-export function collectEnv(workDir) {
-    return {
-        cwd: workDir,
-        platform: `${os.platform()} ${os.release()}`,
-        shell: process.env.SHELL ?? process.env.ComSpec ?? 'unknown',
-        date: new Date().toISOString().slice(0, 10),
-        gitBranch: tryExec('git branch --show-current', workDir),
-        gitStatus: tryExec('git status --short', workDir),
-        gitDiff: tryExec('git diff --stat HEAD', workDir),
-        recentCommits: tryExec('git log --oneline -5', workDir),
-    };
-}
-// ─── nexrall.md reader — project + global instructions + memory ───────────────
-const NEXRALL_MD_CANDIDATES = [
-    'nexrall.md',
-    'NEXRALL.md',
-    '.nexrall/instructions.md',
-    '.nexrall/config.md',
-];
-const tryRead = (p) => {
-    try {
-        return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8').trim() : null;
-    }
-    catch {
-        return null;
-    }
-};
-export function readNexrallMd(workDir) {
-    const parts = [];
-    // 0. Persistent memory (project + global, see agent/memory.ts) — project-scoped
-    // memory is keyed by workDir so it never leaks into an unrelated project's session.
-    const memContent = readAllMemory(workDir);
-    if (memContent)
-        parts.push(memContent);
-    // 1. Global user-level: ~/.nexrall/nexrall.md (applies to every project)
-    const globalContent = tryRead(path.join(os.homedir(), '.nexrall', 'nexrall.md'));
-    if (globalContent)
-        parts.push(`[Global instructions]\n${globalContent}`);
-    // 2. Project-level nexrall.md
-    for (const candidate of NEXRALL_MD_CANDIDATES) {
-        const content = tryRead(path.join(workDir, candidate));
-        if (content) {
-            parts.push(`[Project instructions — ${candidate}]\n${content}`);
-            break;
-        }
-    }
-    return parts.length > 0 ? parts.join('\n\n---\n\n') : undefined;
-}
-// ─── Spinner ──────────────────────────────────────────────────────────────────
-// How much of the model's live thinking text to keep on the one-line status row.
-// Short on purpose: it shares the row with the spinner, the elapsed timer and the
-// token counter, and the point is a glanceable sign of activity, not readable
-// prose — the full thinking block is printed properly by onThinking afterwards.
-const THINK_TAIL_CHARS = 48;
-/**
- * Compose the live status row. Pure + exported so the formatting rules can be
- * tested without an Ink instance, a real terminal or a running timer — the class
- * below owns only the timing/lifecycle, which is what makes this testable at all.
- */
-export function composeStatusLine(opts) {
-    const timer = chalk.dim(` (${opts.elapsedSec}s)`);
-    // Past 15s with zero output, a plain "running…" reads as hung even with the
-    // counter ticking — add an explicit reassurance so the user knows nothing is
-    // wrong. Suppressed when a detail is present: a live token counter is already
-    // proof of life, so the sentence would be noise.
-    const hint = opts.hint !== false && !opts.detail && opts.elapsedSec >= 15
-        ? chalk.dim('  · still running, no output yet is normal for quiet commands')
-        : '';
-    const detail = opts.detail ? chalk.dim(`  ${opts.detail}`) : '';
-    return `${chalk.cyan(opts.frame)} ${chalk.dim(opts.text)}${timer}${detail}${hint}`;
-}
-/** Format a cumulative output-token count for the status row. */
-export function formatProgressTokens(tokens) {
-    if (!Number.isFinite(tokens) || tokens <= 0)
-        return '';
-    return tokens >= 1000 ? `~${(tokens / 1000).toFixed(1)}k tokens` : `~${tokens} tokens`;
-}
-// A bare "running bash…" spinner with no elapsed-time counter is
-// indistinguishable from a genuinely hung process — a silent long-running
-// command (a directory scan, a slow network call with no progress output)
-// looked identical to a frozen terminal, which is what users reported as
-// "đứng yên không thấy tác động gì". Claude Code's own status line always
-// shows a running elapsed-seconds counter for exactly this reason: proof of
-// life doesn't require the underlying command to print anything itself.
-//
-// Renders through Ink's `setLive()` (an ephemeral, non-<Static> status line
-// the App component already exposes for exactly this) instead of a raw
-// `\r\x1b[K` in-place repaint — Ink owns the whole frame, so a spinner
-// fighting it for direct terminal control would just get overwritten by
-// Ink's own next render. In one-shot/headless runs there is no Ink instance
-// (getInkTerminal() returns null) and the spinner is silently a no-op, which
-// is correct: runTurn() is never invoked on that path (see runTurnHeadless).
-class Spinner {
-    interval = null;
-    frames = ['◐', '◓', '◑', '◒'];
-    i = 0;
-    startedAt = 0;
-    baseText = '';
-    // Extra live detail appended after the elapsed timer (e.g. "~1.2k tokens").
-    // Kept separate from `baseText` and mutated through setDetail() so a stream of
-    // progress events can refresh it WITHOUT restarting the spinner — calling
-    // start() again would reset `startedAt` and the elapsed counter would sit at 0s
-    // forever, which is precisely the "is it frozen?" signal this class exists to
-    // remove.
-    detail = '';
-    // Whether the reassurance hint applies. Off for phases where slowness is
-    // already explained by the detail text (e.g. a live token counter is itself
-    // proof of life, so "no output yet is normal" would be noise).
-    hintEnabled = true;
-    start(text, opts) {
-        this.stop();
-        this.baseText = text;
-        this.detail = '';
-        this.hintEnabled = opts?.hint !== false;
-        this.startedAt = Date.now();
-        this.render();
-        this.interval = setInterval(() => this.render(), 100);
-    }
-    /**
-     * Replace the trailing detail text in place, keeping the elapsed timer running.
-     *
-     * No-op when the spinner isn't active: progress events can arrive a tick after
-     * something else (a tool row, the first text delta) legitimately stopped it, and
-     * resurrecting the spinner there would fight the printed output for the status line.
-     *
-     * Deliberately does NOT call render() immediately. onThinkingDelta/onThinkingProgress
-     * can fire many times per second while the model streams (one SSE delta each), and
-     * each of those used to trigger its own Ink re-render (setLive -> React state update ->
-     * full-frame clear/redraw) layered on TOP of the interval's own 100ms redraw already
-     * running in start(). Two independent, unsynchronized render sources hitting the same
-     * frame is exactly what produced the visible jitter users reported ("dòng working...
-     * giật giật liên tục") — every fast delta briefly repainted the status line out of
-     * step with the spinner's own tick. Just updating the field here and letting the
-     * existing setInterval pick it up on its next 100ms tick caps the redraw rate at a
-     * steady 10fps with zero perceptible added latency (worst case: one stale frame for
-     * <100ms), and removes the race entirely.
-     */
-    setDetail(detail) {
-        if (this.interval === null)
-            return;
-        this.detail = detail;
-    }
-    /** Swap the label without resetting the elapsed timer (phase change within one turn). Same reasoning as setDetail() above: no immediate render, the interval tick picks it up. */
-    setText(text) {
-        if (this.interval === null)
-            return;
-        this.baseText = text;
-    }
-    render() {
-        getInkTerminal()?.setLive(composeStatusLine({
-            frame: this.frames[this.i % this.frames.length],
-            text: this.baseText,
-            elapsedSec: Math.floor((Date.now() - this.startedAt) / 1000),
-            detail: this.detail,
-            hint: this.hintEnabled,
-        }));
-        this.i++;
-    }
-    stop() {
-        if (this.interval !== null) {
-            clearInterval(this.interval);
-            this.interval = null;
-            this.detail = '';
-            getInkTerminal()?.setLive('');
-        }
-    }
-    get active() { return this.interval !== null; }
-}
-// ─── MCP (Model Context Protocol) ──────────────────────────────────────────────
-//
-// Historically only the VS Code extension connected to configured MCP servers
-// (ChatPanel._initMcp) — the CLI never read .nexrall/mcp.json at all, so any
-// MCP tool a user configured silently didn't exist as far as the CLI's agent
-// loop was concerned (no error, the model just never saw those tools). This
-// module-level singleton is initialized once per process in startChatSession
-// and threaded into every runTurn/runTurnHeadless call below, so MCP tools
-// now work identically across both surfaces.
-//
-// NOT ported: the VS Code extension's OAuth 2.1 device-flow for remote
-// (HTTP/SSE) servers lacking an explicit Authorization header (it stores
-// tokens in vscode.SecretStorage, which has no CLI equivalent). A remote MCP
-// server that needs OAuth still works here if the user supplies a static
-// Authorization header in mcp.json; interactive OAuth login is VS Code-only
-// for now (tracked as a follow-up, not silently broken — /mcp reports it).
-let _mcpManager = null;
-let _mcpConfig = null;
-async function initMcp(workDir) {
-    _mcpConfig = McpManager.loadConfig(workDir);
-    if (Object.keys(_mcpConfig.mcpServers).length === 0) {
-        _mcpManager = null;
-        return;
-    }
-    const manager = new McpManager();
-    await manager.connectAll(_mcpConfig);
-    _mcpManager = manager;
-}
-/** Human-readable MCP status for the `/mcp` slash command. */
-function formatMcpStatus() {
-    if (!_mcpConfig || Object.keys(_mcpConfig.mcpServers).length === 0) {
-        return chalk.dim('  No MCP servers configured. Add one to .nexrall/mcp.json or ~/.nexrall/mcp.json.');
-    }
-    if (!_mcpManager)
-        return chalk.dim('  MCP servers configured but not connected.');
-    const rows = _mcpManager.getStatus();
-    const lines = rows.map((s) => {
-        if (s.connected) {
-            return '  ' + chalk.green('●') + ' ' + chalk.bold(s.name) + chalk.dim(` (${s.transport}) — ${s.tools.length} tool(s)`);
-        }
-        const authNote = s.needsAuth ? chalk.yellow(' [needs OAuth — not supported in CLI yet, add a static Authorization header]') : '';
-        return '  ' + chalk.red('●') + ' ' + chalk.bold(s.name) + chalk.dim(` (${s.transport}) — `) + chalk.red(s.error ?? 'failed to connect') + authNote;
-    });
-    return lines.join('\n');
-}
-/**
- * `/context` — show current conversation size against the model's context
- * window and the auto-prune/auto-compact thresholds, so a long session's
- * housekeeping (which fires silently mid-run) is visible on demand instead of
- * being a surprise. Uses the same rough token estimate the auto-compact guard
- * itself relies on for a resumed session (no extra API call needed).
- */
-function formatContextUsage(messages, modelAlias) {
-    const window = contextWindowFor(modelAlias);
-    const tokens = estimateTokensRough(messages);
-    const bytes = estimateBodyBytes(messages);
-    const { prune, compact } = compactionThresholds();
-    const pct = Math.min(100, (tokens / window) * 100);
-    const barWidth = 30;
-    const filled = Math.round((pct / 100) * barWidth);
-    const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
-    const barColor = pct >= compact * 100 ? chalk.red : pct >= prune * 100 ? chalk.yellow : chalk.green;
-    const lines = [
-        '',
-        '  ' + chalk.bold('Context usage'),
-        '  ' + barColor(bar) + chalk.dim(`  ~${pct.toFixed(1)}%`),
-        chalk.dim(`  ~${tokens.toLocaleString()} / ${window.toLocaleString()} tokens (rough estimate)  ·  ${(bytes / 1024).toFixed(0)}KB serialized  ·  ${messages.length} messages`),
-        chalk.dim(`  auto-prune at ~${(prune * 100).toFixed(0)}%  ·  auto-compact (summarise) at ~${(compact * 100).toFixed(0)}%`),
-        '',
-    ];
-    return lines.join('\n');
-}
-/** `/agents` — list discovered custom sub-agent types (built-in + project + global + plugin). */
-function formatAgentsList(workDir) {
-    const { types, warnings } = loadAgentTypesWithWarnings(workDir);
-    if (!types.length)
-        return chalk.dim('  No agent types found (this should not happen — builtins always register).');
-    const lines = types.map((t) => {
-        const tools = t.tools ? chalk.dim(` — tools: ${t.tools.join(', ')}`) : chalk.dim(' — ALL tools (no allowlist)');
-        const model = t.model ? chalk.dim(` — model: ${t.model}`) : '';
-        const scope = chalk.dim(` (${t.source})`);
-        return '  ' + chalk.cyan(t.name.padEnd(16)) + chalk.white(t.description) + scope + tools + model;
-    });
-    // Problems are shown right where the user is looking at agents. Each of these
-    // silently changed what an agent could do, which is precisely why they must not
-    // stay quiet.
-    if (warnings.length) {
-        lines.push('');
-        lines.push('  ' + chalk.yellow.bold(`⚠ ${warnings.length} problem${warnings.length > 1 ? 's' : ''} in your agent definitions:`));
-        for (const w of warnings) {
-            lines.push('    ' + chalk.yellow(`• ${w.agent}`) + chalk.dim(` — ${w.message}`));
-            lines.push('      ' + chalk.dim(w.file));
-        }
-    }
-    return lines.join('\n');
-}
-// ─── Run One Turn via Agent Loop ──────────────────────────────────────────────
-async function runTurn(messages, modelAlias, workDir, abortSignal, env, nexrallMd, mode, effort, checkpointManager, onProgress, 
-// Optional Claude-Code-style mid-turn follow-ups (see the InkReadlineAdapter
-// comment for why `rl.pause()` no longer blocks typing): when provided,
-// the loop drains these at every turn boundary and folds them into the
-// conversation instead of waiting for the whole turn to finish. Omitted by
-// callers that run a turn OUTSIDE the main REPL loop (e.g. /compact, /init)
-// where there is no live rl to queue against.
-takePendingInput, 
-// Active worktree isolation, if this session was started with --worktree
-// or resumed into one — threaded straight into AgentLoopOptions.worktree
-// so core's hard enforcement (checkWorktreeIsolation) is actually engaged.
-// Undefined for an ordinary session, matching every existing call site.
-worktreeState, 
-// Cross-session messaging context, set up once in startChatSession when
-// this session registers as a discoverable peer (interactive sessions
-// only — see peerHandle's own comment there). Bundled into one object
-// (rather than three more positional params on an already-long signature)
-// since all three always travel together — see runAgentLoop's identical
-// fields in types.ts for what each one actually does.
-peerCtx) {
-    let lastUsage;
-    const spinner = new Spinner();
-    const mdRender = new MarkdownStreamRenderer();
-    const toolStream = new ToolStreamPrinter();
-    let toolStartTime = 0;
-    let lastToolName = '';
-    let thinkingTokens = 0;
-    // Live one-line detail for the status line while the model is working.
-    // Composed from the two independent progress signals the backend sends
-    // (a cumulative output-token count, and the thinking text itself) so the
-    // status line reflects whichever has arrived.
-    let liveThinkTail = '';
-    const pushStatus = () => {
-        const parts = [];
-        const tok = formatProgressTokens(thinkingTokens);
-        if (tok)
-            parts.push(tok);
-        if (liveThinkTail)
-            parts.push(liveThinkTail);
-        spinner.setDetail(parts.join('  · '));
-    };
-    // Resume the "model is working" status line after something printed over it.
-    //
-    // Every printed row (a tool call, a tool result, a notice) stops the spinner,
-    // but the agent loop then goes straight back to the model — which can spend a
-    // long time on prompt processing before the next token. Without restarting the
-    // spinner there, the terminal falls silent again after every single tool round,
-    // which is the bulk of a long agentic run.
-    const resumeWorking = (label = 'working…') => {
-        if (abortSignal.aborted)
-            return;
-        thinkingTokens = 0;
-        liveThinkTail = '';
-        spinner.start(label, { hint: false });
-    };
-    // Apply the active mode to the permission gate so 'plan' hard-refuses writes
-    // (matches the VS Code panel — enforcement, not just a system-prompt request).
-    setMode(mode);
-    console.log();
-    // Proof of life from the very first millisecond of the turn.
-    //
-    // Nothing used to be shown between the user pressing Enter and the first text
-    // token, and on a large context that gap is genuinely long (the client allows
-    // FIRST_EVENT_TIMEOUT_MS = 300 s for prompt processing before it even calls it a
-    // stall). A dead terminal for tens of seconds is indistinguishable from a hang,
-    // which is the single biggest reason this CLI *felt* slower than it is.
-    //
-    // `hint: false` because the reassurance copy is written for quiet shell commands
-    // ("no output yet is normal"); here the live token counter below is itself the
-    // proof of life, so the extra sentence would just be noise.
-    spinner.start('thinking…', { hint: false });
-    const result = await runAgentLoop(messages, {
-        workDir,
-        model: modelAlias,
-        env,
-        nexrallMd,
-        mode,
-        // `/mode plan` previously only hinted to the backend — the footer said "plan
-        // mode on" while every write tool stayed live, so the one mode whose entire
-        // promise is "I will not touch anything" was the one not enforced. This
-        // makes it real: the loop refuses mutating tools before the permission
-        // prompt, and sub-agents inherit the lock.
-        planMode: mode === 'plan',
-        // Same "enforced, not just hinted" reasoning as planMode directly above:
-        // when set, core's checkWorktreeIsolation refuses any write/bash-cwd/git-
-        // redirect that targets outside this worktree, BEFORE the permission
-        // prompt — undefined (the default) changes nothing for an ordinary session.
-        worktree: worktreeState,
-        // Cross-session messaging — see peerCtx's own doc comment above for why
-        // these three travel together. Undefined (spread of an undefined
-        // object's properties is a no-op) for a session that isn't registered
-        // as a peer, changing nothing for that case.
-        selfPeer: peerCtx?.selfPeer,
-        drainPeerMessages: peerCtx?.drainPeerMessages,
-        onPeerMessage: peerCtx?.onPeerMessage,
-        effort,
-        // Claude-Code-style follow-ups: text the user typed and sent WHILE this
-        // turn was already running. inkTerminal.tsx echoes each one into the
-        // transcript itself the moment it's submitted (chronological, matching
-        // the VS Code panel's queueMessage) — so onInjectedInput is intentionally
-        // a no-op here rather than printing it again.
-        takePendingInput,
-        onInjectedInput: () => { },
-        // The backend streams a cumulative output-token count (routes/code.js's
-        // sendProgress, throttled to ≤5/s) covering thinking, visible text AND
-        // tool-argument JSON. This used to be stored in a variable and rendered only
-        // at message_complete — i.e. after the turn was already over — so during the
-        // long phase it exists to describe, it showed nothing at all.
-        onThinkingProgress: (tokens) => {
-            thinkingTokens = tokens;
-            pushStatus();
-        },
-        // Live thinking text. Previously a hard no-op with the note "shown on
-        // onThinking" — but onThinking only fires at message_complete, so a long
-        // reasoning phase rendered nothing whatsoever until it had finished. Show a
-        // short rolling tail on the status line so the user can see it actively
-        // reasoning, then let onThinking print the proper summary block at the end.
-        onThinkingDelta: (text) => {
-            if (abortSignal.aborted)
-                return;
-            // Collapse to a single line: the status line is one row, and a raw newline
-            // would tear Ink's frame.
-            const flat = text.replace(/\s+/g, ' ');
-            liveThinkTail = (liveThinkTail + flat).slice(-THINK_TAIL_CHARS);
-            pushStatus();
-        },
-        onThinking: (text) => {
-            if (abortSignal.aborted)
-                return;
-            spinner.stop();
-            console.log(formatThinking(text, thinkingTokens));
-            thinkingTokens = 0;
-            liveThinkTail = '';
-            // The model keeps generating after a thinking block (text, or a tool call
-            // whose arguments can take a while to stream) — keep the status line alive
-            // instead of going dark until the next event lands.
-            resumeWorking();
-        },
-        onText: (text) => {
-            if (abortSignal.aborted)
-                return;
-            spinner.stop();
-            mdRender.feed(text); // stream through markdown renderer
-        },
-        // System notices (mid-run auto-prune/auto-compact housekeeping) are NOT part
-        // of the model's own reply — used to go through onText, which spliced
-        // "♻️ Trimmed ~0.3MB…" straight into the markdown stream renderer as if the
-        // model itself had said it. Print it as its own dim line instead (same
-        // treatment as the resume-time compaction notice below).
-        onNotice: (text) => {
-            if (abortSignal.aborted)
-                return;
-            mdRender.flush();
-            spinner.stop();
-            console.log(chalk.dim(`  ${text}`));
-            resumeWorking();
-        },
-        onToolUse: (name, input) => {
-            if (abortSignal.aborted)
-                return;
-            mdRender.flush(); // finalize any in-progress line before tool
-            spinner.stop();
-            toolStream.reset();
-            console.log();
-            console.log(formatToolUse(name, input));
-            lastToolName = name;
-            toolStartTime = Date.now();
-            spinner.start(`running ${name}…`);
-        },
-        // Live progress for foreground bash: the FIRST chunk stops the "running…"
-        // spinner (which would otherwise overwrite/interleave badly with printed
-        // lines) and every subsequent chunk streams straight to the terminal —
-        // see ToolStreamPrinter for the line-buffering/cap logic.
-        onToolStreamChunk: (_name, chunk) => {
-            if (abortSignal.aborted)
-                return;
-            if (spinner.active)
-                spinner.stop();
-            toolStream.feed(chunk);
-        },
-        onToolResult: (_name, res) => {
-            spinner.stop();
-            toolStream.flush(); // emit any trailing partial line the stream held back
-            const durationMs = Date.now() - toolStartTime;
-            console.log(formatToolResult(lastToolName, res, durationMs));
-            toolStartTime = 0;
-            // Back to the model with this result — that round trip is often the longest
-            // silent stretch in an agentic run, so keep the status line up.
-            resumeWorking();
-        },
-        // Ignore a `partial` report: it belongs to a cut-short attempt that was restarted,
-        // and the replacement attempt reports the turn's real totals. Letting it through
-        // would print a token count for output the user never saw.
-        onUsage: (u, partial) => { if (!partial)
-            lastUsage = u; },
-        // A transient disconnect (network drop, machine sleep/wake, overloaded upstream)
-        // is retried transparently by the network layer — without this, that pause was
-        // completely invisible: the CLI just appeared to freeze and then resume with no
-        // explanation. Reuse the same spinner to show what's actually happening.
-        onRetry: (attempt, _maxAttempts, reason) => {
-            if (abortSignal.aborted)
-                return;
-            spinner.start(`${reason}… (attempt ${attempt})`);
-        },
-        onRetryResolved: () => {
-            spinner.stop();
-        },
-        // The stream died after part of the answer had already been printed, and the
-        // turn is being restarted from the top. Providing this handler is what OPTS US
-        // IN to post-render restarts at all (see AgentLoopOptions.onStreamRestart) —
-        // without it a mid-answer disconnect kills the whole turn.
-        //
-        // A terminal can't unprint scrolled-away output, so instead of pretending the
-        // fragment never happened we (a) reset the markdown parser so the dead attempt's
-        // half-open code fence/table can't corrupt everything the retry prints, and
-        // (b) draw an explicit marker so the user understands why the answer restarts.
-        onStreamRestart: (reason, discardedChars) => {
-            if (abortSignal.aborted)
-                return;
-            spinner.stop();
-            mdRender.reset();
-            if (discardedChars > 0) {
-                console.log('\n' + chalk.yellow('  ↺ Connection dropped mid-answer — restarting this response.') +
-                    chalk.dim(`\n    (${reason}. The ${discardedChars} characters above are incomplete; the full answer follows.)`) + '\n');
-            }
-        },
-        onBalanceStatus: (balance, zero) => {
-            spinner.stop();
-            mdRender.flush();
-            printBalanceNotice(balance, zero);
-        },
-        requestPermission,
-        checkpointManager,
-        onProgress,
-        mcpManager: _mcpManager ?? undefined,
-        // undefined unless --audit was passed, in which case the loop's behaviour
-        // is unchanged. Read per turn (not captured once) so /clear and /resume,
-        // which reassign sessionId, are reflected in the trail immediately.
-        audit: currentAudit(),
-    });
-    mdRender.flush(); // flush any remaining buffered text
-    spinner.stop();
-    if (lastUsage) {
-        console.log(chalk.dim('  ' + formatUsage(lastUsage.output_tokens)));
-    }
-    return { messages: result, usage: lastUsage };
-}
-// ─── Headless Turn (JSON output modes) ─────────────────────────────────────
-//
-// For scripting/CI: `nex -p "..." --output-format json` emits a single JSON
-// object on stdout; `stream-json` emits one JSON object per line as events
-// happen (NDJSON). All permissions are auto-approved (headless implies yolo —
-// there is no TTY to prompt on) and nothing decorative is written to stdout.
-async function runTurnHeadless(messages, modelAlias, workDir, _abortSignal, env, nexrallMd, mode, effort, format, checkpointManager, onProgress, 
-// See runTurn's identical parameter for what this threads through to.
-worktreeState) {
-    let lastUsage;
-    let resultText = '';
-    let toolCallCount = 0;
-    const emit = (obj) => {
-        if (format === 'stream-json')
-            process.stdout.write(JSON.stringify(obj) + '\n');
-    };
-    emit({ type: 'start', model: modelAlias, workDir });
-    const result = await runAgentLoop(messages, {
-        workDir,
-        model: modelAlias,
-        env,
-        nexrallMd,
-        mode,
-        planMode: mode === 'plan',
-        worktree: worktreeState,
-        effort,
-        abortSignal: _abortSignal,
-        onText: (text) => { resultText += text; emit({ type: 'text', text }); },
-        // ── Reasoning-phase liveness ──────────────────────────────────────
-        // These used to be UNWIRED here while runTurn() (interactive) wired all
-        // three, and the asymmetry was not cosmetic: on a reasoning model at high
-        // effort the thinking phase emits no text and no tool calls, so a headless
-        // consumer saw ZERO events for the entire phase and could not distinguish
-        // "actively reasoning" from "process wedged".
-        //
-        // Measured on a Terminal-Bench 4.0 trial (2026-08-30, deepseek-v4-pro
-        // --effort max): nex-output.jsonl sat at 4 lines for 65 MINUTES while
-        // tcpdump inside the container's netns showed ~25 packets/s still flowing
-        // and the turn ultimately reported 310,872 output tokens. Nothing was
-        // actually wrong — but every signal available to the harness (log line
-        // count, file mtime) said "hung", and the socket/CPU forensics needed to
-        // prove otherwise are not something a CI wrapper can do.
-        //
-        // `thinking_progress` is the load-bearing one: it carries the backend's
-        // cumulative output-token count (routes/code.js's sendProgress, already
-        // throttled to <=5/s server-side, so this cannot flood the log) and fires
-        // DURING the phase. That makes it a real heartbeat.
-        onThinkingProgress: (tokens) => { emit({ type: 'thinking_progress', tokens }); },
-        // Fires once per turn at message_complete with the full reasoning text.
-        // Typed `thinking` deliberately: the bench's ATIF converter (atif.py)
-        // already routes exactly this event type into the trajectory's reasoning
-        // buffer, so wiring it here also fills in reasoning that was previously
-        // dropped on the floor for every headless run.
-        onThinking: (text) => { emit({ type: 'thinking', text }); },
-        // onThinkingDelta is intentionally NOT wired. Its chunks concatenate to the
-        // same string `onThinking` emits in full above, so emitting both would
-        // duplicate the entire reasoning trace — on the 310k-token turn measured
-        // above that is megabytes of redundant NDJSON — while adding no liveness
-        // signal `thinking_progress` does not already provide.
-        // System notice (mid-run auto-prune/auto-compact) — emit as its own event
-        // type instead of falling through to onText, so a stream-json consumer
-        // doesn't see compaction housekeeping text mixed into the model's `text`
-        // events or accumulated into resultText.
-        onNotice: (text) => { emit({ type: 'notice', text }); },
-        onToolUse: (name, input) => {
-            emit({ type: 'tool_use', tool: name, input });
-        },
-        // Live bash progress for scripted/CI consumers — lets a wrapper tail a
-        // long-running build/test command instead of blocking silently until
-        // tool_result. Chunk is raw and un-truncated (unlike the final result,
-        // which is head/tail-capped), so a chatty command can emit many of these.
-        onToolStreamChunk: (name, chunk) => {
-            emit({ type: 'tool_stream', tool: name, chunk });
-        },
-        onToolResult: (name, res) => {
-            toolCallCount++;
-            emit({ type: 'tool_result', tool: name, ok: res.error === undefined, ...(res.error ? { error: res.error } : {}) });
-        },
-        // Headless consumers get the partial report too — tagged, so a script can account
-        // for the real cost of a restarted turn — but it never becomes `lastUsage`, which
-        // represents the turn's actual output.
-        onUsage: (u, partial) => {
-            if (!partial)
-                lastUsage = u;
-            emit({ type: 'usage', usage: u, ...(partial ? { partial: true } : {}) });
-        },
-        onRetry: (attempt, maxAttempts, reason) => {
-            emit({ type: 'retry', attempt, max_attempts: maxAttempts, reason });
-        },
-        // Headless consumers parse NDJSON, so a restart is trivially clean for them:
-        // they simply drop every `text`/`thinking` event seen since the turn started.
-        // Emitting it also opts headless mode into post-render restarts, so a scripted
-        // /CI run survives a blip instead of exiting non-zero halfway through.
-        onStreamRestart: (reason, discardedChars) => {
-            emit({ type: 'stream_restart', reason, discarded_chars: discardedChars });
-        },
-        onBalanceStatus: (balance, zero) => {
-            emit({ type: 'balance_status', balance, zero, billing_url: BILLING_URL });
-        },
-        // Headless → auto-approve (no TTY to ask on). Destructive/irreversible
-        // commands (DB drops, force-push, terraform destroy…) fail CLOSED here: with
-        // no human to confirm, they are denied unless NEXRALL_ALLOW_DESTRUCTIVE=1 is
-        // explicitly set for this CI run.
-        requestPermission: async ({ tool, input }) => {
-            const d = isDestructiveBash(tool, input);
-            if (d && process.env.NEXRALL_ALLOW_DESTRUCTIVE !== '1') {
-                emit({ type: 'error', error: `Destructive command blocked in headless mode (${d.category}): ${d.reason}. Set NEXRALL_ALLOW_DESTRUCTIVE=1 to permit.` });
-                return false;
-            }
-            return true;
-        },
-        checkpointManager,
-        onProgress,
-        mcpManager: _mcpManager ?? undefined,
-        // Threaded here as well as in runTurn(). This is the path where the trail
-        // matters MOST — headless auto-approves every tool call because there is no
-        // TTY to ask on, so nothing else records what an unattended CI run touched.
-        audit: currentAudit(),
-    });
-    if (format === 'json') {
-        process.stdout.write(JSON.stringify({
-            type: 'result',
-            result: resultText.trim(),
-            tool_calls: toolCallCount,
-            usage: lastUsage ?? null,
-            num_messages: result.length,
-        }) + '\n');
-    }
-    else {
-        emit({ type: 'result', result: resultText.trim(), usage: lastUsage ?? null });
-    }
-    return { messages: result, usage: lastUsage };
-}
-// ─── Slash Command Help ───────────────────────────────────────────────────────
-function printHelp() {
-    console.log();
-    console.log(chalk.bold('  Slash commands:'));
-    const cmds = [
-        ['/exit, /quit', 'Exit Nexrall Code'],
-        ['/clear', 'Clear conversation history'],
-        ['/sessions', 'List saved sessions'],
-        ['/resume [id]', 'Resume last or specific saved session'],
-        ['/save', 'Save current session now'],
-        ['/rewind [id]', 'List file checkpoints, or roll back to one'],
-        ['/compact', 'Summarize conversation to save tokens'],
-        ['/init', 'Generate nexrall.md for this project'],
-        ['/memory [global] [archived] [clear]', 'View persistent memory (project or global); archived also shows superseded facts; clear wipes it'],
-        ['/worktree [list]', 'Show this session\'s worktree isolation status, or list every worktree (start one with `nex --worktree [name]`)'],
-        ['/peers [send <name> <msg>|broadcast <msg>]', 'List other discoverable Nexrall Code sessions, message one directly, or broadcast to all'],
-        ['/help', 'Show this help'],
-        ['/model [name]', 'Switch model (e.g. claude-opus-5, gpt-5.4)'],
-        ['/mode [ask|edit|plan|auto]', 'Set agent mode'],
-        ['/effort [level]', 'Set thinking effort level (options depend on the current model — run /effort with no argument to see them)'],
-        ['/yolo', 'Auto-approve all permissions'],
-        ['/balance', 'Show wallet balance'],
-        ['/add <filepath>', 'Add a file to conversation context'],
-        ['/image <filepath> [caption]', 'Attach an image or PDF (png/jpg/gif/webp/pdf, max 10MB) and send it to the model'],
-        ['/skills', 'List skills (.nexrall/skills/<name>/SKILL.md or .nexrall/commands/*.md) — the model can also auto-invoke these'],
-        ['/plugins', 'List installed plugins (.nexrall/plugins/)'],
-        ['/mcp', 'Show MCP server connection status'],
-        ['/agents', 'List available sub-agent types (for the task tool)'],
-        ['/context', 'Show context window usage for this conversation'],
-        ['/terminal-setup', 'Configure this terminal so Shift+Enter inserts a newline'],
-        ['/update', 'Update nex to the latest version'],
-    ];
-    for (const [cmd, desc] of cmds) {
-        console.log('  ' + chalk.cyan(cmd.padEnd(35)) + chalk.dim(desc));
-    }
-    // The footer advertises "/help for shortcuts", but this only ever listed
-    // slash commands — so the keys that need explaining most (how to type a
-    // newline without submitting) were documented nowhere at all.
-    console.log();
-    console.log(chalk.bold('  Keys:'));
-    const keys = [
-        ['Enter', 'Send the message'],
-        ['Ctrl+J', 'Insert a newline — works in every terminal, no setup'],
-        ['\\ then Enter', 'Continue on the next line'],
-        ['Shift+Enter', 'Insert a newline (run /terminal-setup once if it sends instead)'],
-        ['Option+Enter', 'Insert a newline (macOS; /terminal-setup enables it)'],
-        ['Ctrl+C', 'Stop the current turn, or press twice to exit'],
-        ['←/→', 'Move the cursor within the line'],
-    ];
-    for (const [key, desc] of keys) {
-        console.log('  ' + chalk.cyan(key.padEnd(35)) + chalk.dim(desc));
-    }
-    console.log();
-}
-// ─── Session List Display ─────────────────────────────────────────────────────
-function printSessions() {
-    const sessions = listSessions().slice(0, 20);
-    if (!sessions.length) {
-        console.log(chalk.dim('  No saved sessions yet.'));
-        return;
-    }
-    console.log();
-    console.log(chalk.bold('  Saved sessions:'));
-    for (const s of sessions) {
-        const when = new Date(s.updatedAt).toLocaleString();
-        const title = s.title.length > 50 ? s.title.slice(0, 50) + '…' : s.title;
-        console.log('  ' + chalk.cyan(s.id.slice(0, 8).padEnd(10)) +
-            chalk.dim(`${when}  `) +
-            chalk.white(title));
-    }
-    console.log(chalk.dim('\n  Use /resume <id> to continue a session.'));
-    console.log();
-}
-// ─── Start Chat Session ───────────────────────────────────────────────────────
-export async function startChatSession(options) {
-    // Headless JSON output → stdout must contain ONLY JSON. Suppress all decor.
-    const headless = options.outputFormat === 'json' || options.outputFormat === 'stream-json';
-    const requestedWorkDir = options.workDir;
-    // Reassigned below, ONLY when --worktree is active, to the worktree's own
-    // directory — every downstream use of `workDir` in this function (env
-    // collection, nexrall.md, MCP config, checkpoints, session storage, and the
-    // AgentLoopOptions.workDir passed to runAgentLoop) then transparently
-    // operates on the isolated directory instead of the main checkout, with no
-    // other code in this file needing to know isolation is active. `let`, not
-    // `const`, purely to allow that one reassignment — nothing else in this
-    // function mutates it.
-    let workDir = requestedWorkDir;
-    // Set once a worktree is created/resumed below; threaded into every
-    // runAgentLoop call's `worktree:` option so the hard enforcement in
-    // core/agent/loop.ts (checkWorktreeIsolation) is actually active for this
-    // session. Undefined for an ordinary (non-isolated) session — the default,
-    // unchanged behaviour.
-    let worktreeState;
-    // Set below (interactive sessions only — see its own registration block)
-    // once this session registers itself as a discoverable peer. Threaded into
-    // AgentLoopOptions as `selfPeer`/`drainPeerMessages` so the
-    // list_peer_sessions/message_peer_session tools and the inbox-drain hook
-    // in loop.ts actually work. Undefined for a one-shot/headless run — a
-    // process that exits before any OTHER session could plausibly reach it
-    // has nothing to gain from the registration overhead, mirroring why
-    // Claude Code's own docs describe messaging as meaningful between
-    // LONG-LIVED sessions.
-    let peerHandle;
-    let peerInbox;
-    const peerInboxQueue = [];
-    let modelAlias = options.model;
-    // Kick off the live model catalogue fetch (GET /api/code/models) in the
-    // BACKGROUND, not awaited: every call site that reads it
-    // (modelWithCostHint/resolveModelLabel/effortStyleFor/needsVisionSidecar/
-    // needsPdfSidecar/selectableModelIds, all in this file) falls back to its
-    // hand-maintained table when the cache isn't populated yet, so there is
-    // nothing to block on. Started this early so the round-trip has the
-    // longest possible head start — the trust prompt and startup banner below
-    // give it several hundred ms to resolve before the user can reach `/model`.
-    // Failures are swallowed inside getModelCatalogue itself; nothing here
-    // needs a .catch — but one is defensive against a future change removing
-    // that guarantee, since an unhandled rejection would otherwise crash a CLI
-    // session over a model-picker enrichment call.
-    void getModelCatalogue().catch(() => { });
-    // ── Workspace trust gate ──────────────────────────────────────────────────
-    //
-    // This MUST run before anything reads the working directory. Opening a
-    // folder is not passive: `.nexrall/mcp.json` causes `spawn()` of the
-    // commands it names, `nexrall.md` is injected into the system prompt as
-    // trusted instructions, and `.nexrall/{skills,commands,permissions.json}`
-    // add playbooks and pre-approved tool permissions. Without this gate,
-    // `git clone` of a hostile repo followed by `nex` runs attacker-chosen
-    // commands before the user has typed anything.
-    //
-    // Note the ordering constraint: readNexrallMd/loadSkills/initMcp all appear
-    // BELOW this point on purpose. Moving any of them above it would reintroduce
-    // the hole this closes.
-    //
-    // The answer is deliberately NOT remembered between sessions (see trust.ts):
-    // trust would be granted to a path, but the risk lives in the folder's
-    // contents, and a later `git pull` can add a .nexrall/mcp.json that would
-    // then run without ever being announced.
-    //
-    // Only interactive TTY sessions can show a prompt. Non-interactive runs
-    // (piped stdin, one-shot `-p`, headless JSON) have no way to ask, so rather
-    // than hanging on a prompt nobody can see — or silently proceeding — they
-    // refuse, unless the invoker pre-authorised the run via the environment.
-    const canPrompt = !headless &&
-        !options.prompt &&
-        !options.stdinText &&
-        process.stdin.isTTY === true &&
-        process.stdout.isTTY === true;
-    if (!trustGrantedByEnv()) {
-        if (!canPrompt) {
-            process.stderr.write(`Refusing to run in an unconfirmed folder:\n  ${workDir}\n\n` +
-                'This folder can configure the agent (.nexrall/mcp.json can run local ' +
-                'commands, nexrall.md steers the agent).\n' +
-                `Set ${TRUST_ENV_VAR}=1 to confirm non-interactively, or run \`nex\` ` +
-                'interactively here to review it.\n');
-            process.exit(1);
-        }
-        const signals = detectTrustSignals(workDir);
-        const trusted = await askForTrust(workDir, signals);
-        if (!trusted) {
-            // Ink clears its final frame as it unmounts, and process.exit() can cut
-            // off a write that hasn't flushed yet. Defer the message to the next
-            // tick so it lands after the unmount and is actually visible.
-            await new Promise((r) => setImmediate(r));
-            process.stdout.write('Not trusted — exiting without loading this folder.\n');
-            process.exit(0);
-        }
-        // ── Close the raw-mode gap between the trust prompt and the main UI ──────
-        //
-        // askForTrust() runs in its OWN short-lived Ink instance. When the user
-        // answers, that instance's exit() synchronously unmounts, and Ink's
-        // unmount() calls `stdin.setRawMode(false)` — handing the terminal back to
-        // the OS in cooked mode WITH LOCAL ECHO. The main UI's Ink instance
-        // (startInkTerminal(), below) doesn't re-enable raw mode until its own
-        // render() runs, which happens after collectEnv/readNexrallMd/
-        // prepareSessionScreen() below.
-        //
-        // That gap is real wall-clock time (measured ~150-300ms with a synchronous
-        // pty harness), and terminal echo is done by the OS tty driver, not by
-        // Node — so any key typed during it is echoed by the KERNEL at whatever
-        // row the cursor happened to land on after the trust prompt's last frame
-        // (i.e. one row below "Enter to confirm..."), not drawn into the input box
-        // Ink hasn't mounted yet. That is the exact "text appears below the
-        // chrome, only reappearing correctly once enough is typed" symptom this
-        // fixes: once the main Ink instance's useInput() effect fires and
-        // re-enables raw mode, it starts rendering correctly again, so short
-        // bursts of fast typing right after confirming trust were the ones
-        // visibly torn.
-        //
-        // We can enable raw mode here unconditionally: reaching this line means
-        // `canPrompt` was true, which requires an interactive TTY session, so
-        // `interactive` is guaranteed to be true below. Re-enabling here just
-        // closes the window; Ink's own setRawMode(true) call once it mounts is a
-        // harmless no-op on top of this (see ink's App.js rawModeEnabledCount).
-        //
-        // MUST be deferred past the current microtask queue via setImmediate, not
-        // called synchronously right after `await askForTrust(...)`. Ink's own
-        // raw-mode teardown for the JUST-UNMOUNTED trust prompt is itself queued
-        // with `queueMicrotask()` (see ink's App.js `handleSetRawMode`'s disable
-        // branch) — it hasn't run yet at this point, it only runs once the
-        // microtask queue drains. Calling `setRawMode(true)` synchronously here
-        // races that pending microtask: ordering isn't guaranteed to put ours
-        // last, so the trust prompt's own delayed `setRawMode(false)` can still
-        // fire AFTER ours and undo it, or the two calls can otherwise leave
-        // stdin's raw-mode/`readable` listener bookkeeping inconsistent — this
-        // was reproduced directly as `nex` hanging forever after confirming
-        // trust (this line was reached, but the session never rendered).
-        // `setImmediate` schedules a macrotask, which only runs after Node fully
-        // drains the microtask queue — guaranteeing Ink's pending teardown has
-        // already completed by the time we re-enable raw mode.
-        await new Promise((resolve) => setImmediate(resolve));
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(true);
-    }
-    // ── Worktree isolation (--worktree) ─────────────────────────────────────
-    //
-    // Deliberately AFTER the trust gate above (isolation is a property of an
-    // already-trusted folder, not a substitute for trusting it) and BEFORE
-    // collectEnv/readNexrallMd below, so every subsequent read of `workDir` in
-    // this function — env, nexrall.md, MCP config, checkpoints, session
-    // storage, and the AgentLoopOptions passed to runAgentLoop — transparently
-    // operates on the worktree instead of the main checkout.
-    if (options.worktree !== undefined) {
-        const requestedName = typeof options.worktree === 'string' ? options.worktree : undefined;
-        const existing = requestedName ? findWorktreeByName(requestedWorkDir, requestedName) : null;
-        if (existing) {
-            const entered = enterWorktree(existing);
-            if (!entered.ok) {
-                process.stderr.write(`Failed to resume worktree "${requestedName}": ${entered.error}\n`);
-                process.exit(1);
-            }
-            worktreeState = existing;
-            if (!headless)
-                console.log(chalk.dim(`  Resumed worktree: ${chalk.bold(existing.name)} (${existing.worktreePath})`));
-        }
-        else {
-            const created = createWorktree(requestedWorkDir, requestedName);
-            if (!created.ok || !created.state) {
-                process.stderr.write(`Failed to create worktree: ${created.error ?? 'unknown error'}\n`);
-                process.exit(1);
-            }
-            worktreeState = created.state;
-            if (!headless) {
-                console.log(chalk.green(`  Created worktree: ${chalk.bold(worktreeState.name)}`));
-                console.log(chalk.dim(`  ${worktreeState.worktreePath}`));
-                if (worktreeState.branch)
-                    console.log(chalk.dim(`  Branch: ${worktreeState.branch}`));
-                console.log();
-            }
-        }
-        // Every later use of `workDir` in this function now transparently
-        // resolves inside the isolated directory — this is the ONE reassignment
-        // `let workDir` above exists to allow.
-        workDir = worktreeState.worktreePath;
-        // Auto-cleanup on process exit — mirrors Claude Code's own worktree
-        // lifecycle ("When the agent finishes and the worktree is clean, it's
-        // automatically cleaned up"). Registered on `process.on('exit', …)`
-        // rather than at any of this function's many individual
-        // `process.exit()` call sites, because 'exit' fires for every one of
-        // them uniformly (Node still runs 'exit' listeners even after
-        // `process.exit()` is called) — one registration point instead of
-        // needing to thread cleanup through 15+ separate exit paths.
-        //
-        // Deliberately SYNCHRONOUS only: Node does not run the event loop during
-        // 'exit', so nothing async here would ever complete — worktreeHasWork
-        // and removeWorktree are both plain sync fs/spawnSync calls for exactly
-        // this reason (see worktree.ts).
-        process.on('exit', () => {
-            if (!worktreeState)
-                return;
-            const hadWork = worktreeHasWork(worktreeState);
-            if (hadWork) {
-                // Matches Claude Code's own choice here: a worktree with real,
-                // uncommitted work is left in place rather than silently discarded,
-                // with the exact resume incantation printed so nothing is lost.
-                process.stderr.write(`\nWorktree "${worktreeState.name}" has uncommitted work and was left in place:\n` +
-                    `  ${worktreeState.worktreePath}\n` +
-                    `Resume it with: nex --worktree ${worktreeState.name}\n`);
-                return;
-            }
-            removeWorktree(worktreeState);
-        });
-    }
-    // Collect runtime env
-    const env = collectEnv(workDir);
-    const nexrallMd = readNexrallMd(workDir);
-    // Interactive-only (no one-shot prompt, no headless output) sessions take
-    // over the screen: both the visible screen and the scrollback are cleared so
-    // the session starts on a clean slate with the banner at the top, and
-    // scrolling up later reveals the banner and earlier turns rather than the
-    // shell prompts that preceded `nex`. See ui/screen.ts's prepareSessionScreen
-    // for why this uses the normal screen buffer rather than the alternate one.
-    //
-    // One-shot/headless runs never clear anything: they're meant to compose with
-    // other commands in a pipeline and must leave the user's scrollback intact.
-    const interactive = !headless && !options.prompt && !options.stdinText;
-    // ── Cross-session peer discovery + messaging ────────────────────────────
-    //
-    // Register this session as a discoverable peer BEFORE the REPL starts, so
-    // it is visible to any other session's list_peer_sessions from the very
-    // first turn. Interactive-only, deliberately (see peerHandle's own field
-    // comment for why). No flag to opt in/out — matches Claude Code's own
-    // default (cross-session messaging is on by default, refusable per-message
-    // via the target's own inbound policy, not a global toggle a user has to
-    // discover first).
-    let peerHeartbeatTimer;
-    if (interactive) {
-        // registerPeer mints the id first; startPeerInbox's socket is named
-        // after that SAME id, so registration happens before the inbox starts.
-        // The record is then updated with the real socketPath and re-persisted
-        // (via heartbeat()) so other sessions' list_peer_sessions see a
-        // reachable peer immediately, not one whose socketPath is still empty.
-        const handle = registerPeer({ clientType: 'cli', workDir: requestedWorkDir });
-        const inbox = startPeerInbox(handle.record.id, { onMessage: (m) => peerInboxQueue.push(m) });
-        handle.record.socketPath = inbox.socketPath;
-        handle.heartbeat();
-        peerHandle = handle;
-        peerInbox = inbox;
-        peerHeartbeatTimer = setInterval(() => handle.heartbeat(), 10_000);
-        // Timers keep the process alive even with nothing else pending — must
-        // not prevent normal exit once the REPL itself decides to quit.
-        peerHeartbeatTimer.unref?.();
-        process.on('exit', () => {
-            peerInbox?.close();
-            peerHandle?.unregister();
-            if (peerHeartbeatTimer)
-                clearInterval(peerHeartbeatTimer);
-        });
-    }
-    // Built once — passed to every runTurn call site below (see runTurn's
-    // peerCtx parameter). undefined selfPeer/drainPeerMessages/onPeerMessage
-    // when peerHandle never got set (non-interactive) makes every field a
-    // no-op in the loop, identical to today's behaviour.
-    const peerCtx = {
-        selfPeer: peerHandle ? { id: peerHandle.record.id, name: peerHandle.record.name } : undefined,
-        drainPeerMessages: peerHandle ? () => peerInboxQueue.splice(0) : undefined,
-        onPeerMessage: peerHandle
-            ? (msgs) => {
-                for (const m of msgs) {
-                    if (!headless)
-                        console.log(chalk.dim(`\n  › Message from @${m.from}: `) + chalk.white(m.text));
-                }
-            }
-            : undefined,
-    };
-    if (interactive) {
-        prepareSessionScreen();
-        process.on('exit', () => { stopInkTerminal(); });
-        // ── Close the SAME raw-mode gap as above, for the "already trusted"
-        // fast path ──────────────────────────────────────────────────────────
-        //
-        // The `setRawMode(true)` fix a few lines up (search "Close the raw-mode
-        // gap between the trust prompt and the main UI") only runs when the
-        // trust prompt was actually shown. When the workspace is already
-        // trusted — `NEXRALL_TRUST_WORKSPACE=1`, or trust remembered from an
-        // earlier `nex` invocation in this folder — the entire `if
-        // (!trustGrantedByEnv())` block above is skipped, so stdin is left at
-        // whatever mode the process started in (cooked, with the kernel doing
-        // local echo) all the way from process start until Ink's own
-        // `useInput()` effect fires inside `startInkTerminal()` below. That is
-        // the exact same "typed text appears one row below the input box, only
-        // reappearing correctly once enough is typed" symptom, just triggered on
-        // ordinary startup instead of right after a trust decision — reachable
-        // on literally every `nex` run in an already-trusted folder, not just
-        // the first one. Setting raw mode here, synchronously and unconditionally
-        // right before Ink mounts, closes it: there is no pending Ink
-        // teardown microtask to race against here (unlike the post-trust-prompt
-        // case), since no other Ink instance has run yet in this process.
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(true);
-        // Boot the Ink app FIRST, before anything (including the banner below)
-        // prints — Ink's own default `patchConsole: true` behavior (see
-        // ink/build/render.js) only takes effect once `render()` has run, so
-        // every console.log call after this point transparently prints above
-        // the input box/footer this component owns. The Spinner class and
-        // MarkdownStreamRenderer/ToolStreamPrinter (theme.ts) — the only other
-        // interactive-path writers — use console.log / Ink's own setLive() API,
-        // so there is no separate bridge needed for raw process.stdout.write().
-        await startInkTerminal();
-        // Begin tallying startup output so padToBottom() below knows how far to
-        // push the input line + footer down. This must come AFTER
-        // startInkTerminal(): Ink's patchConsole replaces console.log during
-        // render(), so counting first would have Ink's patch overwrite the
-        // counting wrapper and every line would go uncounted.
-        startRowCount();
-    }
-    if (options.showBanner !== false && !headless) {
-        const branch = tryExec('git branch --show-current', workDir);
-        const gitStatus = tryExec('git status --short', workDir);
-        const changedLines = gitStatus ? gitStatus.split('\n').filter(Boolean).length : 0;
-        const tips = ['Run /init to create a nexrall.md file with instructions for Nexrall Code.'];
-        if (branch) {
-            tips.push(`On branch ${branch}${changedLines > 0 ? ` (${changedLines} changed)` : ''}.`);
-        }
-        // Box-drawn "Welcome back" card matching Claude Code's own startup
-        // screen (chalk/Unicode only — see conversation: Ink's Yoga layout
-        // engine can't be bundled into the single-file esbuild output `nex`
-        // ships as, so this reimplements just the visual layout by hand).
-        //
-        // Everything BUT `workDir` in this info bundle is captured once here and
-        // reused verbatim by the regenerator below — none of it changes for the
-        // life of the session (version/user/tips are fixed at startup, and the
-        // model label only changes via /model, which doesn't re-print the
-        // banner). Only `columns` varies per call, which is the ENTIRE reason
-        // this needs to be regenerable at all — see setBannerRegenerator's doc.
-        const bannerInfo = {
-            version: CLI_VERSION,
-            userLabel: currentUserLabel(),
-            modelLabel: resolveModelLabel(modelAlias),
-            workDir,
-            nexrallMdLoaded: !!nexrallMd,
-            tips,
-        };
-        if (interactive) {
-            // Routed through print(isBanner: true) instead of a plain console.log
-            // so a later resize can find and replace it — see
-            // AppHandle.setBannerRegenerator's own doc for the full mechanism
-            // (verified end-to-end against a real `claude` binary in a pty
-            // harness: banner/transcript/footer all reprint at the CURRENT column
-            // count on every resize, not just at startup).
-            const bannerCard = renderBannerCard({ ...bannerInfo, columns: process.stdout.columns ?? 80 });
-            getInkTerminal().print(bannerCard, { isBanner: true });
-            getInkTerminal().setBannerRegenerator((columns) => renderBannerCard({ ...bannerInfo, columns }));
-            // print() above goes through Ink's <Static> list, not console.log, so
-            // the startRowCount() tally (which only patches console.log/error) is
-            // otherwise blind to the banner's ~15-18 rows entirely — see
-            // addRowCount's own doc for the padToBottom() breakage that caused.
-            addRowCount(bannerCard);
-        }
-        else {
-            console.log(renderBannerCard({ ...bannerInfo, columns: process.stdout.columns ?? 80 }));
-        }
-        console.log();
-    }
-    let messages = [];
-    let sessionId = crypto.randomBytes(8).toString('hex');
-    let sessionTitle = '';
-    let agentMode = 'auto';
-    // Effort is now validated PER MODEL (effortConfigFor's levels), not against
-    // one fixed 4-level list shared by every provider — see the "Per-model
-    // effort scale" section above for why. A caller-supplied value (the
-    // -e/--effort CLI flag, or a headless harness's CLI_FLAGS) that isn't on
-    // the CURRENT model's scale clamps to that model's "normal" notch instead
-    // of sending a value the backend/model has never seen.
-    let effortLevel = options.effort
-        ? clampEffortForModel(options.effort, modelAlias)
-        : defaultEffortForModel(modelAlias);
-    const permRules = initPermissions(workDir);
-    const ruleCount = permRules.allow.length + permRules.ask.length + permRules.deny.length;
-    if (ruleCount && !headless)
-        console.log(chalk.dim(`  ${ruleCount} permission rule(s) loaded`));
-    let skills = loadSkills(workDir);
-    if (skills.length && !headless)
-        console.log(chalk.dim(`  ${skills.length} skill(s) loaded`));
-    // MCP servers configured in .nexrall/mcp.json (project or global) — connect
-    // once up front, same as the VS Code extension's _initMcp. Errors per-server
-    // are non-fatal (recorded in getStatus() for `/mcp`); a server that fails to
-    // connect just contributes no tools rather than blocking the whole session.
-    //
-    // ── Why an INTERACTIVE session does not await this ────────────────────────
-    //
-    // connectAll() spawns every stdio server and performs a full JSON-RPC
-    // handshake (initialize + tools/list) against every remote one, in parallel
-    // but bounded by the SLOWEST of them. Measured against a real 5-server
-    // mcp.json: 8.0s, dominated by one server whose endpoint now returns 410.
-    //
-    // Awaiting that here — between Ink mounting and padToBottom() below — is the
-    // direct cause of the reported "footer starts in the wrong place and only
-    // drops to the bottom after a while": the input box and footer paint
-    // immediately (measured 170ms) wherever the banner ended, then sit there
-    // for the whole handshake because the padding that pushes them down is
-    // queued behind this await. Measured end-to-end: chrome visible at 170ms,
-    // final position at 8651ms — an 8.5s window in which the UI looks wrong
-    // and typed characters land against a stale frame.
-    //
-    // Interactive sessions therefore START the connect and carry on painting.
-    // Nothing is lost: `_mcpManager` is read at CALL time when each turn is
-    // dispatched (see the `mcpManager: _mcpManager ?? undefined` argument in
-    // runTurn/runTurnHeadless), never captured at startup, and the REPL awaits
-    // `mcpReady()` before the first turn — so the model can never see a
-    // half-connected tool list. The only visible difference is that the
-    // "N/M MCP server(s) connected" line now arrives when it's true rather
-    // than holding the whole UI hostage until it is.
-    //
-    // Headless/one-shot runs still await: they dispatch their single turn
-    // immediately with no REPL to defer to, and printing progress into a
-    // machine-readable stream is not a concern there.
-    const mcpStarted = (async () => {
-        try {
-            await initMcp(workDir);
-            const connected = _mcpManager?.serverNames.length ?? 0;
-            const total = _mcpConfig ? Object.keys(_mcpConfig.mcpServers).length : 0;
-            if (total && !headless) {
-                console.log(chalk.dim(`  ${connected}/${total} MCP server(s) connected`) + chalk.dim('  (/mcp for details)'));
-            }
-        }
-        catch { /* non-fatal — session works fine with zero MCP tools */ }
-    })();
-    // Awaited before the first turn (and by /mcp) so no turn ever runs against a
-    // half-connected tool list. Never rejects — the IIFE above swallows errors.
-    const mcpReady = () => mcpStarted;
-    if (!interactive)
-        await mcpStarted;
-    // Headless output only makes sense with a one-shot prompt (or piped stdin).
-    if (headless && !options.prompt && !options.stdinText) {
-        process.stdout.write(JSON.stringify({ type: 'error', error: '--output-format json/stream-json requires a one-shot prompt (or piped stdin).' }) + '\n');
-        process.exit(1);
-    }
-    // ── Resume session ────────────────────────────────────────────────────────
-    if (options.resume) {
-        const stored = options.resume === 'last'
-            ? lastSession()
-            : loadSession(options.resume);
-        if (!stored) {
-            console.error(chalk.red(`  Session not found: ${options.resume}`));
-            console.error(chalk.dim('  Use /sessions to list saved sessions.'));
-            process.exit(1);
-        }
-        messages = stored.messages;
-        sessionId = stored.id;
-        sessionTitle = stored.title;
-        // Resuming an old session and sending one message used to resend the WHOLE
-        // stored history at full price: the in-loop auto-compact guard only reacts
-        // to lastPromptTokens from a PREVIOUS turn's usage event, which doesn't
-        // exist yet on turn 0 of a freshly-resumed session. Proactively compact
-        // here, before the first new message is even sent.
-        try {
-            const compacted = await compactMessagesForResume(messages, {
-                workDir,
-                model: modelAlias,
-                clientType: 'cli',
-                onNotice: (text) => { if (!headless)
-                    console.log(chalk.dim(text.trim())); },
-            });
-            void compacted;
-        }
-        catch { /* non-fatal — worst case the session resends uncompacted */ }
-        if (!headless) {
-            console.log(chalk.green(`  Resumed session: ${chalk.bold(stored.title.slice(0, 60))}`));
-            console.log(chalk.dim(`  ${messages.length} messages restored`));
-            console.log();
-        }
-    }
-    // Checkpoints are scoped per session so resuming a session (even after a
-    // process restart) restores its rewind history from disk.
-    const checkpoints = new CheckpointManager(workDir, sessionId);
-    // Enabled HERE, next to the checkpoint manager, because both key off
-    // sessionId and this is the first point where it is final: the --resume
-    // branch above replaces it, so enabling any earlier would print (and, for
-    // the default path, derive) a trail location for a session that was then
-    // discarded. Thereafter the id is read LIVE per turn — /clear and /resume
-    // reassign it mid-session, and a trail stamped with a stale id would
-    // attribute work to the wrong conversation.
-    if (options.audit) {
-        const auditPath = enableAudit({
-            filePath: typeof options.audit === 'string' ? options.audit : undefined,
-            workDir,
-            getSessionId: () => sessionId,
-        });
-        if (!headless)
-            console.log(chalk.dim(`  Audit trail: ${auditPath}`));
-    }
-    // Helper: derive session title from first user message
-    const updateTitle = () => {
-        if (sessionTitle)
-            return;
-        const first = messages.find(m => m.role === 'user');
-        const raw = first?.content[0]?.text ?? '';
-        sessionTitle = raw.length > 60 ? raw.slice(0, 60) + '…' : raw;
-    };
-    // A turn died (dead stream, upstream error, crashed tool). The agent loop works
-    // on its own copy of the history, so WITHOUT this the REPL would fall back to a
-    // `messages` array that still contains only the original user message — every
-    // completed tool round of a long run silently evaporates, even though the user
-    // was already billed for it and "continue" then has nothing to continue FROM.
-    // salvageHistory() returns the loop's partial history when real progress was
-    // made, so we adopt it, persist it, and tell the user it's safe to resume.
-    const recoverTurn = (err, current) => {
-        const salvaged = salvageHistory(err);
-        console.error('\n' + chalk.red('Error: ') + String(err.message));
-        if (!salvaged)
-            return current;
-        // progressCount is already a count of completed tool ROUNDS, tracked by the loop.
-        // Deriving it from array lengths here would be wrong: auto-compaction can splice the
-        // history shorter mid-run, so the delta doesn't reflect what the user watched happen.
-        const rounds = err.progressCount ?? 1;
-        console.error(chalk.dim(`  Kept the ${rounds} step${rounds === 1 ? '' : 's'} completed before the interruption — ` +
-            `send "continue" to pick up where it stopped.`));
-        return salvaged;
-    };
-    // Incremental session persistence: fired at every turn boundary inside the
-    // agent loop so a crash / kill hours into a long run only loses the in-flight
-    // step. Debounced (≤ every 3s) to keep disk writes cheap on fast tool rounds.
-    let lastProgressSave = 0;
-    const saveProgress = (live) => {
-        const now = Date.now();
-        if (now - lastProgressSave < 3_000)
-            return;
-        lastProgressSave = now;
-        try {
-            updateTitle();
-            if (live.length)
-                saveSession(sessionId, sessionTitle || 'Untitled', workDir, live);
-        }
-        catch { /* best-effort — never let persistence break the run */ }
-    };
-    // ── One-shot mode ─────────────────────────────────────────────────────────
-    if (options.prompt || options.stdinText) {
-        // If stdin is piped, prepend it to the prompt
-        let text = options.prompt ?? '';
-        if (options.stdinText) {
-            text = options.stdinText + (text ? `\n\n${text}` : '');
-        }
-        checkpoints.beginTurn(text, messages.length);
-        messages.push({ role: 'user', content: [{ type: 'text', text }] });
-        const abortSignal = { aborted: false };
-        const onSigint = () => { abortSignal.aborted = true; };
-        process.once('SIGINT', onSigint);
-        try {
-            const fmt = options.outputFormat;
-            const result = (fmt === 'json' || fmt === 'stream-json')
-                ? await runTurnHeadless(messages, modelAlias, workDir, abortSignal, env, nexrallMd, agentMode, effortLevel, fmt, checkpoints, saveProgress, worktreeState)
-                : await runTurn(messages, modelAlias, workDir, abortSignal, env, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, undefined, worktreeState, peerCtx);
-            messages = result.messages;
-            checkpoints.commitTurn();
-            updateTitle();
-            saveSession(sessionId, sessionTitle, workDir, messages);
-            // One-shot must exit explicitly on success, matching the error path below
-            // (process.exit(1)). Without this, Node's event loop only exits once every
-            // handle is gone — but a background shell started via run_in_background
-            // (bash tool, detached:true, stdio:['ignore','pipe','pipe']) keeps its
-            // stdout/stderr pipes open on OUR side without ever being unref()'d. If the
-            // agent's turn left behind a live background process — e.g. a dev/gRPC/pypi
-            // server started with run_in_background:true and deliberately never killed,
-            // because it's meant to keep serving — those open pipes count as active
-            // handles and the process hangs forever after a fully successful turn,
-            // even though the model already produced its final `result` event. This
-            // was confirmed live: a --output-format stream-json run against
-            // terminal-bench tasks that start a background server (kv-store-grpc,
-            // pypi-server) emitted the final `result` event and then never exited,
-            // hanging the wrapping `docker compose exec` for the rest of the task
-            // timeout. Exiting explicitly here makes success behave like failure
-            // always did — the process ends the instant the turn is done, regardless
-            // of what background children it leaves running.
-            //
-            // On Linux, stdout to a pipe (exactly the `nex ... | tee file` setup used
-            // by CI/benchmark harnesses) is non-blocking — process.stdout.write() can
-            // return before the OS has actually flushed the bytes. process.exit() does
-            // not wait for that; see the identical note on the trust-prompt exit above.
-            // The headless JSON/stream-json result event was just written synchronously
-            // above (inside runTurnHeadless), so defer one tick to let it actually drain
-            // before tearing the process down.
-            await new Promise((r) => setImmediate(r));
-            process.exit(0);
-        }
-        catch (err) {
-            // One-shot exits the process, so the ONLY way a partial run survives is on
-            // disk — persist the salvaged history before exiting so `nex --resume`
-            // resumes the work instead of silently restarting it from zero.
-            const salvaged = salvageHistory(err);
-            if (salvaged) {
-                messages = salvaged;
-                try {
-                    updateTitle();
-                    saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    // Commit the checkpoint turn as well. Only the success path does this, so
-                    // without it a salvaged run would resume its conversation via --resume but
-                    // the file snapshots taken during the interrupted turn would never become a
-                    // /rewind point — history and undo would disagree about what happened.
-                    checkpoints.commitTurn();
-                }
-                catch { /* best-effort — never mask the real error */ }
-            }
-            if (options.outputFormat === 'json' || options.outputFormat === 'stream-json') {
-                process.stdout.write(JSON.stringify({
-                    type: 'error',
-                    error: String(err.message),
-                    ...(salvaged ? { resumable: true, messagesCompleted: salvaged.length } : {}),
-                }) + '\n');
-            }
-            else {
-                console.error(chalk.red('\nError: ') + String(err.message));
-                if (salvaged) {
-                    console.error(chalk.dim('  Progress was saved — run `nex --resume` (or `nex -r`) to resume this session.'));
-                }
-            }
-            process.exit(1);
-        }
-        finally {
-            process.removeListener('SIGINT', onSigint);
-        }
-        return;
-    }
-    // ── Interactive REPL ──────────────────────────────────────────────────────
-    console.log(chalk.dim('  Type a message, /help for commands, or Ctrl+C to exit.'));
-    console.log();
-    // All startup output is on screen now, so insert exactly enough blank rows
-    // for the input line + footer to come to rest on the terminal's last row.
-    // Without this they sat directly beneath the banner with a block of empty
-    // rows below them.
-    //
-    // Nothing may print between here and the REPL: any later line would be
-    // counted by neither the tally nor the padding and would push the chrome one
-    // row past the bottom, scrolling the top of the banner away.
-    //
-    // `startupPadded` records whether padToBottom actually printed filler rows
-    // — those rows are real, permanent scrollback (a terminal is append-only,
-    // so nothing printed later can ever "fill" the gap instead of just
-    // appending after it) and have to be collapsed once real conversation
-    // content starts, or they stay wedged between the banner and the first
-    // turn for the rest of the session. See the first `rl.on('line', …)`
-    // handling below, and collapseStartupPadding's own doc in inkTerminal.tsx.
-    let startupPadded = false;
-    if (interactive) {
-        // Wait for Ink to commit the frame containing everything printed above
-        // before measuring against it. Ink renders on a timer, so without this the
-        // padding is computed against a stale frame and the result is
-        // nondeterministic — measured: identical terminal sizes kept the banner on
-        // some runs and scrolled its top row away on others.
-        await flushInkFrame();
-        // Pass the real footer string so its true height is measured rather than
-        // assumed — it wraps to two rows on a terminal narrower than ~56 columns,
-        // and under-counting pushes the banner's top row off the screen.
-        startupPadded = padToBottom(stopRowCount(), footerText({ mode: agentMode, autoApprove: isYoloMode() }));
-    }
-    let agentRunning = false;
-    const abortSignal = { aborted: false };
-    // Handles Ctrl+C for the NON-interactive path only (headless/one-shot's
-    // real readline.Interface, not running under Ink's raw mode). A pressed
-    // Ctrl+C there is translated into a genuine SIGINT by the kernel's tty
-    // line discipline, which this listens for directly.
-    //
-    // Interactive sessions never reach this: Ink puts stdin into raw mode for
-    // the whole session, which disables that kernel-level Ctrl+C→SIGINT
-    // translation entirely (see inkTerminal.tsx's useInput setting rawMode via
-    // Ink internally) — so the '\x03' byte only ever exists as a keystroke for
-    // useInput's own handler to see, never as a process signal. That handler's
-    // `onInterrupt` callback (wired below, once `rl` exists) is the only path
-    // left to interrupt a running turn interactively; this listener would
-    // simply never fire for it.
-    process.on('SIGINT', () => {
-        if (agentRunning) {
-            console.log('\n' + chalk.yellow('  Interrupted.'));
-            abortSignal.aborted = true;
-            agentRunning = false;
-        }
-        else {
-            updateTitle();
-            if (messages.length)
-                saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-            console.log('\n' + chalk.dim('  Goodbye.'));
-            process.exit(0);
-        }
-    });
-    // Interactive sessions get a readline.Interface-SHAPED adapter backed by
-    // Ink (see ui/inkReadlineAdapter.ts) instead of a real readline.Interface —
-    // chat.ts's business logic below (`rl.on('line', …)`, `rl.pause()`,
-    // `rl.resume()`, `rl.close()`) is unchanged; only the rendering/input
-    // layer underneath it moved to Ink's React-driven renderer. One-shot/
-    // headless runs (no Ink instance) fall back to a real readline.Interface,
-    // same as before.
-    const rl = interactive
-        ? new InkReadlineAdapter(getInkTerminal())
-        : readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-    // Interactive-only: Ctrl+C pressed WHILE a turn is running, routed through
-    // Ink (see the SIGINT comment above for why the kernel signal never fires
-    // here). Mirrors the SIGINT branch above exactly — same message, same
-    // abortSignal/agentRunning reset — just triggered via the adapter's
-    // 'interrupt' event instead of a process signal.
-    if (rl instanceof InkReadlineAdapter) {
-        rl.on('interrupt', () => {
-            if (agentRunning) {
-                console.log('\n' + chalk.yellow('  Interrupted.'));
-                abortSignal.aborted = true;
-                agentRunning = false;
-            }
-        });
-    }
-    // Route every permission y/n prompt through THIS same interface instead of
-    // letting askUser() spin up a second readline.Interface on process.stdin.
-    // rl.pause() (used below before each agent turn) doesn't remove this
-    // interface's stdin listeners, so a second Interface listening concurrently
-    // caused every keystroke — including the permission answer itself — to be
-    // processed and re-drawn by both, which is what produced the duplicated/
-    // "lấn" characters and broken line-wrapping users were seeing.
-    setReadlineInterface(rl);
-    // The footer ("auto mode on · /help for shortcuts · /agents for agents")
-    // reflects agentMode/yolo state, which slash commands below mutate
-    // directly — unlike before (where it redrew implicitly on every
-    // rl.prompt()), Ink only re-renders when its own state changes, so each
-    // place that changes agentMode/auto-approve must call this explicitly.
-    const updateFooter = () => {
-        if (interactive)
-            getInkTerminal().setFooter({ mode: agentMode, autoApprove: isYoloMode() });
-    };
-    updateFooter();
-    // Passed to every runTurn() call below as its takePendingInput param — see
-    // that param's own comment. `rl instanceof InkReadlineAdapter` is false for
-    // headless/one-shot's plain readline.Interface (no queueing surface there,
-    // and one-shot exits right after its single turn so there is no "typing
-    // during" to speak of), in which case runTurn just gets `undefined` and
-    // behaves exactly as it always did.
-    const takePendingInput = rl instanceof InkReadlineAdapter
-        ? () => rl.takePendingInput()
-        : undefined;
-    let inputBuffer = '';
-    rl.on('line', async (rawLine) => {
-        // Multi-line continuation (trailing backslash)
-        if (rawLine.endsWith('\\')) {
-            inputBuffer += rawLine.slice(0, -1) + '\n';
-            if (!interactive)
-                process.stdout.write(chalk.dim('… '));
-            return;
-        }
-        const userInput = (inputBuffer + rawLine).trim();
-        inputBuffer = '';
-        if (!userInput) {
-            rl.prompt();
-            return;
-        }
-        // Collapse the startup padding gap (see `startupPadded`'s own comment
-        // above) exactly once, on the FIRST real line submitted — right before
-        // anything from this line gets appended to the transcript. Every
-        // branch below (a slash command or an ordinary message) is about to
-        // print something, so this is the last point at which "nothing has been
-        // appended below the padding yet" is still true; any later point would
-        // let real content print into the gap first and defeat the collapse.
-        if (startupPadded) {
-            startupPadded = false;
-            // Awaited — see collapseStartupPadding's own doc for why firing the raw
-            // clear before Ink has flushed the just-echoed line to the terminal can
-            // lose that line (the "first message sometimes doesn't show up" bug this
-            // fixes). Every branch below only prints AFTER this resolves, so nothing
-            // races the flush this waits for.
-            await getInkTerminal().collapseStartupPadding();
-        }
-        // ── Slash commands ────────────────────────────────────────────────────
-        if (userInput.startsWith('/')) {
-            const parts = userInput.split(/\s+/);
-            const cmd = parts[0];
-            const arg = parts.slice(1).join(' ');
-            switch (cmd) {
-                case '/exit':
-                case '/quit':
-                    updateTitle();
-                    if (messages.length)
-                        saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    console.log(chalk.dim('  Goodbye.'));
-                    rl.close();
-                    process.exit(0);
-                case '/clear':
-                    updateTitle();
-                    if (messages.length)
-                        saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    messages = [];
-                    sessionId = crypto.randomBytes(8).toString('hex');
-                    sessionTitle = '';
-                    // `/clear` starts a new session in a REUSED process, so the sub-agent budget has to
-                    // start over with it — otherwise it would only ever be a per-invocation cap, and a
-                    // long interactive session would silently lose delegation.
-                    resetSessionSubAgentBudget();
-                    console.log(chalk.dim('  Conversation cleared. New session started.'));
-                    rl.prompt();
-                    return;
-                case '/save':
-                    updateTitle();
-                    saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    console.log(chalk.green(`  Session saved: ${chalk.bold(sessionTitle || sessionId.slice(0, 8))}`));
-                    rl.prompt();
-                    return;
-                case '/sessions':
-                    printSessions();
-                    rl.prompt();
-                    return;
-                case '/resume': {
-                    if (agentRunning) {
-                        console.log(chalk.red('  Cannot resume while agent is running.'));
-                        rl.prompt();
-                        return;
-                    }
-                    // Save current session first
-                    updateTitle();
-                    if (messages.length)
-                        saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    const stored = arg ? loadSession(arg) : lastSession();
-                    if (!stored) {
-                        console.log(chalk.red(`  Session not found${arg ? `: ${arg}` : ''}.`));
-                        console.log(chalk.dim('  Use /sessions to list.'));
-                        rl.prompt();
-                        return;
-                    }
-                    messages = stored.messages;
-                    sessionId = stored.id;
-                    sessionTitle = stored.title;
-                    // Same resume-time cost guard as the --resume startup flag (see above):
-                    // proactively compact BEFORE the next message is sent, since the in-loop
-                    // guard's lastPromptTokens is stale/zero for a session resumed mid-process.
-                    try {
-                        await compactMessagesForResume(messages, {
-                            workDir,
-                            model: modelAlias,
-                            clientType: 'cli',
-                            onNotice: (text) => console.log(chalk.dim(text.trim())),
-                        });
-                    }
-                    catch { /* non-fatal */ }
-                    console.log(chalk.green(`  Resumed: ${chalk.bold(stored.title.slice(0, 60))}`));
-                    console.log(chalk.dim(`  ${messages.length} messages restored`));
-                    rl.prompt();
-                    return;
-                }
-                case '/rewind': {
-                    const cps = checkpoints.list();
-                    if (!cps.length) {
-                        console.log(chalk.dim('  No checkpoints yet — file edits create them automatically.'));
-                        rl.prompt();
-                        return;
-                    }
-                    if (!arg) {
-                        console.log();
-                        console.log(chalk.bold('  Checkpoints:'));
-                        for (const c of cps) {
-                            const when = c.createdAt.slice(11, 19);
-                            console.log('  ' + chalk.cyan(`#${c.id}`.padEnd(5)) +
-                                chalk.dim(`${when}  `) +
-                                chalk.yellow(`${c.fileCount} file${c.fileCount !== 1 ? 's' : ''}`.padEnd(9)) +
-                                chalk.white(c.label));
-                        }
-                        console.log(chalk.dim('  Use /rewind <id> to restore.'));
-                        console.log();
-                        rl.prompt();
-                        return;
-                    }
-                    const id = parseInt(arg, 10);
-                    if (Number.isNaN(id)) {
-                        console.log(chalk.red(`  Invalid id: ${arg}`));
-                        rl.prompt();
-                        return;
-                    }
-                    const res = checkpoints.restore(id);
-                    if (!res) {
-                        console.log(chalk.red(`  Checkpoint #${id} not found.`));
-                        rl.prompt();
-                        return;
-                    }
-                    messages = messages.slice(0, res.messageIndex);
-                    console.log(chalk.green(`  Rewound to #${id}: restored ${res.restored.length} file(s), ${messages.length} messages kept.`));
-                    for (const p of res.restored)
-                        console.log(chalk.dim('    ↩ ' + path.relative(workDir, p)));
-                    if (res.bashCount > 0) {
-                        console.log(chalk.yellow(`  ⚠ ${res.bashCount} shell command(s) ran in the rewound turns — their side effects were NOT undone.`));
-                        for (const h of res.gitStashHashes) {
-                            console.log(chalk.dim(`    Recovery point (pre-bash git snapshot): git stash apply ${h}`));
-                        }
-                    }
-                    rl.prompt();
-                    return;
-                }
-                case '/compact': {
-                    if (messages.length < 4) {
-                        console.log(chalk.dim('  Nothing to compact.'));
-                        rl.prompt();
-                        return;
-                    }
-                    rl.pause();
-                    console.log(chalk.dim('  Compacting conversation…'));
-                    const KEEP = 4;
-                    const toSummarize = messages.slice(0, -KEEP);
-                    const kept = messages.slice(-KEEP);
-                    const convText = toSummarize
-                        .map(m => `${m.role.toUpperCase()}: ${m.content[0]?.text ?? '(tool content)'}`)
-                        .join('\n\n');
-                    const summaryPrompt = `Summarize the key facts, decisions, code changes, and context from this conversation in concise bullet points (max 300 words):\n\n${convText}`;
-                    try {
-                        abortSignal.aborted = false;
-                        agentRunning = true;
-                        const r = await runTurn([{ role: 'user', content: [{ type: 'text', text: summaryPrompt }] }], modelAlias, workDir, abortSignal, env, nexrallMd, agentMode, effortLevel, undefined, undefined, takePendingInput, worktreeState, peerCtx);
-                        agentRunning = false;
-                        const summaryText = [...r.messages].reverse().find(m => m.role === 'assistant')?.content[0]?.text ?? '';
-                        messages = [
-                            { role: 'user', content: [{ type: 'text', text: `[Compacted ${toSummarize.length} messages]\n\nSummary:\n${summaryText}` }] },
-                            { role: 'assistant', content: [{ type: 'text', text: 'Got it — I have the summary of our earlier work.' }] },
-                            ...kept,
-                        ];
-                        // MUST persist immediately: without this, the on-disk transcript still
-                        // holds the FULL pre-compact history until the next natural save point
-                        // (sending the very next message), which then overwrites the file with
-                        // this shortened `messages` array — permanently discarding everything
-                        // /compact just summarized away, with no backup. Same bug, same fix,
-                        // as ChatPanel.ts's identical /compact handler.
-                        saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                        console.log(chalk.green(`  Compacted ${toSummarize.length} messages → ${messages.length} messages.`));
-                    }
-                    catch (err) {
-                        agentRunning = false;
-                        console.error(chalk.red('  Compact failed: ') + String(err.message));
-                    }
-                    rl.resume();
-                    rl.prompt();
-                    return;
-                }
-                case '/init': {
-                    // Generate nexrall.md for the current project
-                    const nexrallMdPath = path.join(workDir, 'nexrall.md');
-                    if (fs.existsSync(nexrallMdPath)) {
-                        // Must reuse `rl` (the shared interface) rather than spinning up a
-                        // second readline.Interface on process.stdin. In interactive
-                        // sessions `rl` is an InkReadlineAdapter and Ink owns stdin in raw
-                        // mode; a concurrent readline.Interface becomes a competing stdin
-                        // consumer, so keystrokes get consumed/echoed by both and
-                        // characters go missing or duplicated — the same class of bug the
-                        // comment above setReadlineInterface() describes.
-                        const answer = await new Promise(resolve => rl.question(chalk.yellow('  nexrall.md already exists. Overwrite? [y/n] '), a => resolve(a.trim())));
-                        if (answer !== 'y' && answer !== 'yes') {
-                            console.log(chalk.dim('  Cancelled.'));
-                            rl.prompt();
-                            return;
-                        }
-                    }
-                    const readme = tryRead(path.join(workDir, 'README.md'))?.slice(0, 2000) ?? '';
-                    const pkgJson = tryRead(path.join(workDir, 'package.json'))?.slice(0, 1000) ?? '';
-                    const dirList = tryExec('ls -la', workDir)?.slice(0, 500) ?? '';
-                    const initPrompt = `Analyze this project and write a concise nexrall.md (project-specific instructions for an AI coding assistant).\nInclude: project overview, tech stack, coding conventions, important files/folders, what to avoid.\nKeep it under 400 words. Use markdown. Be specific and actionable.\n\nREADME:\n${readme || '(none)'}\n\npackage.json:\n${pkgJson || '(none)'}\n\nDirectory:\n${dirList}`;
-                    console.log(chalk.dim('  Generating nexrall.md…'));
-                    rl.pause();
-                    abortSignal.aborted = false;
-                    agentRunning = true;
-                    try {
-                        const r = await runTurn([{ role: 'user', content: [{ type: 'text', text: initPrompt }] }], modelAlias, workDir, abortSignal, env, nexrallMd, 'auto', effortLevel, undefined, undefined, takePendingInput, worktreeState, peerCtx);
-                        agentRunning = false;
-                        const content = [...r.messages].reverse().find(m => m.role === 'assistant')?.content[0]?.text ?? '';
-                        if (content) {
-                            fs.writeFileSync(nexrallMdPath, content, 'utf-8');
-                            console.log(chalk.green(`  nexrall.md written to ${nexrallMdPath}`));
-                        }
-                    }
-                    catch (err) {
-                        agentRunning = false;
-                        console.error(chalk.red('  Init failed: ') + String(err.message));
-                    }
-                    rl.resume();
-                    rl.prompt();
-                    return;
-                }
-                case '/worktree': {
-                    // Usage: /worktree           → show this session's isolation status
-                    //        /worktree list      → list every worktree under requestedWorkDir
-                    const sub = arg.trim().toLowerCase();
-                    console.log();
-                    if (sub === 'list') {
-                        const all = listWorktrees(requestedWorkDir);
-                        if (!all.length) {
-                            console.log(chalk.dim('  No worktrees under this project.'));
-                        }
-                        else {
-                            console.log(chalk.bold(`  Worktrees (${all.length})`));
-                            for (const w of all) {
-                                const dirty = worktreeHasWork(w) ? chalk.yellow('dirty') : chalk.dim('clean');
-                                console.log(`  ${chalk.cyan(w.name)}  ${chalk.dim(w.worktreePath)}  [${dirty}]`);
-                            }
-                            console.log();
-                            console.log(chalk.dim('  Resume one with: nex --worktree <name>'));
-                        }
-                    }
-                    else if (worktreeState) {
-                        console.log(chalk.bold('  This session is isolated in a worktree:'));
-                        console.log(`  ${chalk.cyan(worktreeState.name)}  ${chalk.dim(worktreeState.worktreePath)}`);
-                        console.log(chalk.dim(`  Backend: ${worktreeState.backend}${worktreeState.branch ? `  ·  Branch: ${worktreeState.branch}` : ''}`));
-                        console.log(chalk.dim(`  Main checkout: ${worktreeState.mainCheckout}`));
-                        console.log();
-                        console.log(chalk.dim('  Writes/bash outside this worktree are refused by this session automatically.'));
-                    }
-                    else {
-                        console.log(chalk.dim('  This session is NOT isolated in a worktree.'));
-                        console.log(chalk.dim('  Start one with: nex --worktree [name]'));
-                    }
-                    console.log();
-                    rl.prompt();
-                    return;
-                }
-                case '/peers': {
-                    // Usage: /peers                       → list other discoverable sessions
-                    //        /peers send <name> <message>  → message one directly
-                    //        /peers broadcast <message>    → message every other reachable session at once
-                    const rest = arg.trim();
-                    console.log();
-                    if (!peerHandle) {
-                        console.log(chalk.dim('  This session is not registered as a discoverable peer (non-interactive sessions skip registration).'));
-                        console.log();
-                        rl.prompt();
-                        return;
-                    }
-                    if (rest.startsWith('send ')) {
-                        const afterSend = rest.slice('send '.length);
-                        const spaceIdx = afterSend.indexOf(' ');
-                        const targetName = spaceIdx === -1 ? afterSend : afterSend.slice(0, spaceIdx);
-                        const text = spaceIdx === -1 ? '' : afterSend.slice(spaceIdx + 1).trim();
-                        if (!targetName || !text) {
-                            console.log(chalk.dim('  Usage: /peers send <name> <message>'));
-                        }
-                        else {
-                            const target = listPeers().find((p) => p.name === targetName);
-                            if (!target) {
-                                console.log(chalk.red(`  No live session named "${targetName}". Use /peers to list who's reachable.`));
-                            }
-                            else if (!target.socketPath) {
-                                console.log(chalk.red(`  Session "${targetName}" is not currently reachable for messaging.`));
-                            }
-                            else {
-                                const { sendPeerMessage } = await import('@nexrall/code-core');
-                                const result = await sendPeerMessage(target.socketPath, { from: peerHandle.record.name, fromId: peerHandle.record.id, text });
-                                console.log(result.ok ? chalk.green(`  Sent to ${targetName}.`) : chalk.red(`  Failed: ${result.error}`));
-                            }
-                        }
-                    }
-                    else if (rest.startsWith('broadcast ')) {
-                        const text = rest.slice('broadcast '.length).trim();
-                        if (!text) {
-                            console.log(chalk.dim('  Usage: /peers broadcast <message>'));
-                        }
-                        else {
-                            const { broadcastPeerMessage } = await import('@nexrall/code-core');
-                            const targets = listPeers(peerHandle.record.id)
-                                .filter((p) => p.id !== peerHandle.record.id && p.socketPath && p.inbound !== 'refuse')
-                                .map((p) => ({ name: p.name, socketPath: p.socketPath }));
-                            if (!targets.length) {
-                                console.log(chalk.dim('  No other reachable Nexrall Code sessions to broadcast to.'));
-                            }
-                            else {
-                                const results = await broadcastPeerMessage(targets, { from: peerHandle.record.name, fromId: peerHandle.record.id, text });
-                                const ok = results.filter((r) => r.ok);
-                                console.log(chalk.green(`  Broadcast to ${results.length} session(s): ${ok.length} delivered.`));
-                                for (const r of results.filter((r) => !r.ok))
-                                    console.log(chalk.red(`    ✗ ${r.name}: ${r.error}`));
-                            }
-                        }
-                    }
-                    else {
-                        const peers = listPeers(peerHandle.record.id);
-                        if (peers.length <= 1) {
-                            console.log(chalk.dim('  No other Nexrall Code sessions are currently discoverable on this machine.'));
-                        }
-                        else {
-                            console.log(chalk.bold(`  This session: ${chalk.cyan(peerHandle.record.name)}`));
-                            console.log();
-                            for (const p of peers) {
-                                if (p.id === peerHandle.record.id)
-                                    continue;
-                                const status = p.status === 'running' ? chalk.yellow('busy') : chalk.dim('idle');
-                                console.log(`  ${chalk.cyan(p.name)}  ${chalk.dim(p.clientType)}  [${status}]  ${chalk.dim(p.workDir)}`);
-                            }
-                            console.log();
-                            console.log(chalk.dim('  Message one with: /peers send <name> <message>'));
-                        }
-                    }
-                    console.log();
-                    rl.prompt();
-                    return;
-                }
-                case '/memory': {
-                    // Usage: /memory                → show project + global ACTIVE memory merged
-                    //        /memory global         → show ONLY global memory
-                    //        /memory archived       → also include superseded/archived facts
-                    //        /memory clear          → wipe project memory (with confirm)
-                    //        /memory global clear   → wipe global memory (with confirm)
-                    const memArgs = arg.toLowerCase().split(/\s+/).filter(Boolean);
-                    const wantsGlobalOnly = memArgs.includes('global');
-                    const wantsClear = memArgs.includes('clear');
-                    const wantsArchived = memArgs.includes('archived');
-                    const memScope = wantsGlobalOnly ? 'global' : 'project';
-                    if (wantsClear) {
-                        // Reuse the shared `rl` — see the /init note above: a second
-                        // readline.Interface on process.stdin competes with Ink for
-                        // keystrokes. (Also note rl.pause() would suppress the very
-                        // answer we're about to ask for, so don't pause around this.)
-                        const label = memScope === 'global' ? 'GLOBAL' : "this PROJECT's";
-                        const answer = await new Promise(resolve => rl.question(chalk.yellow(`  Clear ${label} memory? This cannot be undone. [y/n] `), a => resolve(a.trim())));
-                        if (answer === 'y' || answer === 'yes') {
-                            clearMemory(memScope, workDir);
-                            console.log(chalk.green(`  ${memScope === 'global' ? 'Global' : 'Project'} memory cleared.`));
-                        }
-                        else {
-                            console.log(chalk.dim('  Cancelled.'));
-                        }
-                        rl.resume();
-                        rl.prompt();
-                        return;
-                    }
-                    console.log();
-                    if (wantsGlobalOnly) {
-                        const stats = memoryStats('global');
-                        const content = readMemory('global', undefined, { includeArchived: wantsArchived });
-                        const archivedNote = stats.archived > 0 ? `, ${stats.archived} archived` : '';
-                        console.log(chalk.bold('  Global memory ') + chalk.dim(`(${stats.entries} entries${archivedNote}, ${(stats.bytes / 1024).toFixed(1)}KB) — ${stats.file}`));
-                        console.log();
-                        console.log(content || chalk.dim('  No global memories saved yet.'));
-                    }
-                    else {
-                        const projStats = memoryStats('project', workDir);
-                        const globalStats = memoryStats('global');
-                        const projArchived = projStats.archived > 0 ? `+${projStats.archived} archived ` : '';
-                        const globalArchived = globalStats.archived > 0 ? `+${globalStats.archived} archived ` : '';
-                        console.log(chalk.bold('  Memory') + chalk.dim(`  — project: ${projStats.entries} ${projArchived}entries (${(projStats.bytes / 1024).toFixed(1)}KB)  ·  global: ${globalStats.entries} ${globalArchived}entries (${(globalStats.bytes / 1024).toFixed(1)}KB)`));
-                        console.log();
-                        const merged = readAllMemory(workDir, { includeArchived: wantsArchived });
-                        console.log(merged || chalk.dim('  No memories saved yet.'));
-                    }
-                    console.log();
-                    console.log(chalk.dim('  Tip: /memory global  ·  /memory archived  ·  /memory clear  ·  /memory global clear'));
-                    rl.prompt();
-                    return;
-                }
-                case '/help':
-                    printHelp();
-                    rl.prompt();
-                    return;
-                case '/model': {
-                    // NOT lowercased: model ids are case-sensitive tokens, and forcing case
-                    // here would corrupt any id containing uppercase. normaliseModelId does
-                    // the case-insensitive match for the legacy ALIASES only.
-                    const requested = arg.trim();
-                    const models = selectableModelIds();
-                    if (!requested) {
-                        console.log(chalk.dim(`  Current: ${chalk.cyan(resolveModelLabel(modelAlias))}`));
-                        console.log(chalk.dim(`  Options: ${models.map(modelWithCostHint).join(' · ')}`));
-                    }
-                    else if (models.includes(normaliseModelId(requested))) {
-                        // Store the RESOLVED id, so `/model turbo` and `/model claude-sonnet-5`
-                        // leave the session in identical state rather than two spellings that
-                        // drift apart in later comparisons.
-                        modelAlias = normaliseModelId(requested);
-                        // Re-clamp effort onto the NEW model's scale — switching from
-                        // Claude (5 levels, e.g. 'extra') to Qwen (2 levels) would
-                        // otherwise leave effortLevel holding a wire value Qwen has never
-                        // seen, silently treated as its default by the backend with
-                        // nothing on screen saying so.
-                        const clamped = clampEffortForModel(effortLevel, modelAlias);
-                        const effortChanged = clamped !== effortLevel;
-                        effortLevel = clamped;
-                        console.log(chalk.green(`  Model → ${chalk.bold(resolveModelLabel(modelAlias))}`));
-                        if (effortChanged) {
-                            console.log(chalk.dim(`  Effort reset → ${effortLevel} (previous level not available on this model)`));
-                        }
-                    }
-                    else {
-                        console.log(chalk.red(`  Unknown: ${requested}. Options: ${models.join(', ')}`));
-                    }
-                    rl.prompt();
-                    return;
-                }
-                case '/mode': {
-                    const modeArg = arg.toLowerCase();
-                    if (!modeArg) {
-                        // Spell out what each mode PERMITS, from the same descriptions the policy
-                        // uses. Listing bare names ("ask · edit · plan · auto") told the user
-                        // nothing about the actual trade-off, which is the whole decision being
-                        // made here — and while the modes were still decorative, it was worse than
-                        // nothing, since three of the four names described behaviour that did not
-                        // exist.
-                        console.log(chalk.dim(`  Current: ${chalk.cyan(agentMode)}`));
-                        for (const m of ['ask', 'edit', 'auto', 'plan']) {
-                            const marker = m === agentMode ? chalk.cyan('❯') : ' ';
-                            console.log(`  ${marker} ${chalk.bold(m.padEnd(5))} ${chalk.dim(describeMode(m).replace(`${m} — `, ''))}`);
-                        }
-                    }
-                    else if (['ask', 'edit', 'plan', 'auto'].includes(modeArg)) {
-                        agentMode = modeArg;
-                        updateFooter();
-                        console.log(chalk.green(`  Mode → ${chalk.bold(modeArg)}`) + chalk.dim(`  ${describeMode(modeArg).replace(`${modeArg} — `, '')}`));
-                    }
-                    else {
-                        console.log(chalk.red(`  Unknown: ${modeArg}`));
-                    }
-                    rl.prompt();
-                    return;
-                }
-                case '/effort': {
-                    // Options are THIS model's real scale, not a fixed list shared by
-                    // every provider — see "Per-model effort scale" above. A DeepSeek
-                    // session shows low/high/max (its 3 real buckets); a Qwen session
-                    // shows Thinking Off/On (its boolean toggle); gpt-4.1 shows nothing
-                    // meaningful to change at all.
-                    const effortArg = arg.toLowerCase();
-                    const config = effortConfigFor(modelAlias);
-                    const optionsLine = config.levels.map((v, i) => `${v} (${config.names[i]})`).join(' · ');
-                    if (!effortArg) {
-                        console.log(chalk.dim(`  Current: ${chalk.cyan(effortLevel)}  Options: ${optionsLine}`));
-                    }
-                    else if (config.levels.includes(effortArg)) {
-                        effortLevel = effortArg;
-                        console.log(chalk.green(`  Effort → ${chalk.bold(effortArg)}`));
-                    }
-                    else {
-                        console.log(chalk.red(`  Unknown: ${effortArg}. Options: ${optionsLine}`));
-                    }
-                    rl.prompt();
-                    return;
-                }
-                case '/yolo':
-                    setAutoApprove('all');
-                    updateFooter();
-                    console.log(chalk.yellow('  Yolo mode: all permissions auto-approved.'));
-                    rl.prompt();
-                    return;
-                case '/balance': {
-                    rl.pause();
-                    try {
-                        const bal = await getBalance();
-                        console.log(chalk.dim('  Balance: ') + chalk.cyan(`$${bal.toFixed(4)}`));
-                    }
-                    catch (err) {
-                        console.error(chalk.red('  Failed: ') + String(err.message));
-                    }
-                    rl.resume();
-                    rl.prompt();
-                    return;
-                }
-                case '/add': {
-                    if (!arg) {
-                        console.log(chalk.red('  Usage: /add <filepath>'));
-                        rl.prompt();
-                        return;
-                    }
-                    const filePath = path.isAbsolute(arg) ? arg : path.join(workDir, arg);
-                    try {
-                        const content = fs.readFileSync(filePath, 'utf-8');
-                        const rel = path.relative(workDir, filePath);
-                        messages.push({ role: 'user', content: [{ type: 'text', text: `Content of \`${rel}\`:\n\`\`\`\n${content}\n\`\`\`` }] }, { role: 'assistant', content: [{ type: 'text', text: `Got it, I've read \`${rel}\`.` }] });
-                        console.log(chalk.green(`  Added ${rel} (${content.split('\n').length} lines)`));
-                    }
-                    catch (err) {
-                        console.error(chalk.red('  Failed: ') + String(err.message));
-                    }
-                    rl.prompt();
-                    return;
-                }
-                // Attach an image (or PDF) and send it as a REAL turn to the model —
-                // unlike /add above, this is NOT a fake Q&A stub: the model must
-                // actually see the pixels/pages to reason about a UI bug screenshot,
-                // a diagram, or a scanned document, so it goes through the same
-                // runTurn() path as a normal typed message. Mirrors the VS Code
-                // extension's attachment handling in ChatPanel.ts's
-                // _handleUserMessage (leading text-label block naming the file, then
-                // the image/document block, since the block itself can't carry a
-                // `name` field the Anthropic API would recognize).
-                case '/image': {
-                    if (agentRunning) {
-                        console.log(chalk.red('  Cannot attach while agent is running.'));
-                        rl.prompt();
-                        return;
-                    }
-                    if (!arg) {
-                        console.log(chalk.red('  Usage: /image <filepath> [caption]'));
-                        rl.prompt();
-                        return;
-                    }
-                    const [rawPath, ...captionParts] = arg.split(/\s+/);
-                    const caption = captionParts.join(' ').trim();
-                    const filePath = path.isAbsolute(rawPath) ? rawPath : path.join(workDir, rawPath);
-                    const ext = path.extname(filePath).toLowerCase();
-                    const IMAGE_MIME = {
-                        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-                        '.gif': 'image/gif', '.webp': 'image/webp',
-                    };
-                    const isPdf = ext === '.pdf';
-                    const mimeType = IMAGE_MIME[ext];
-                    if (!mimeType && !isPdf) {
-                        console.log(chalk.red(`  Unsupported file type: ${ext || '(none)'}. Supported: png, jpg, jpeg, gif, webp, pdf.`));
-                        rl.prompt();
-                        return;
-                    }
-                    const model = normaliseModelId(modelAlias);
-                    let buf;
-                    try {
-                        buf = fs.readFileSync(filePath);
-                    }
-                    catch (err) {
-                        console.error(chalk.red('  Failed: ') + String(err.message));
-                        rl.prompt();
-                        return;
-                    }
-                    // 10MB raw-file soft cap: base64 inflates size ~33%, and very large
-                    // images/scans routinely exceed the Anthropic API's per-request payload
-                    // limit — fail fast locally with a clear reason instead of a confusing
-                    // 413/400 from the backend several seconds into the turn.
-                    const MAX_BYTES = 10 * 1024 * 1024;
-                    if (buf.length > MAX_BYTES) {
-                        console.log(chalk.red(`  File too large (${(buf.length / 1024 / 1024).toFixed(1)}MB) — max 10MB.`));
-                        rl.prompt();
-                        return;
-                    }
-                    const rel = path.relative(workDir, filePath);
-                    const data = buf.toString('base64');
-                    const label = caption ? `[Attached: ${rel}]\n${caption}` : `[Attached: ${rel}]`;
-                    const content = [{ type: 'text', text: label }];
-                    // Blind model (no vision / no PDF support): transcribe via the
-                    // sidecar ONCE, right now, and push TEXT into `messages` instead of
-                    // the raw block — see describeAttachment's header for why this must
-                    // happen before the attachment ever reaches history. The turn still
-                    // runs on the model the user chose; it is never silently switched.
-                    const needsSidecar = isPdf ? needsPdfSidecar(model) : needsVisionSidecar(model);
-                    if (needsSidecar) {
-                        console.log(chalk.dim(`  ${resolveModelLabel(modelAlias)} can't read ${isPdf ? 'PDFs' : 'images'} directly — describing ${rel} with Claude Sonnet 5 first…`));
-                        try {
-                            const { text } = await describeAttachment(isPdf ? 'pdf' : 'image', data, mimeType, rel);
-                            content.push({ type: 'text', text: `<attachment_description>\n${text}\n</attachment_description>` });
-                        }
-                        catch (err) {
-                            console.log(chalk.red(`  Could not describe ${rel}: ${err.message}`));
-                            rl.prompt();
-                            return;
-                        }
-                    }
-                    else {
-                        content.push(isPdf
-                            ? { type: 'document', source: { type: 'base64', media_type: 'application/pdf', data } }
-                            : { type: 'image', source: { type: 'base64', media_type: mimeType, data } });
-                    }
-                    console.log(chalk.dim(`  Attached ${rel} (${(buf.length / 1024).toFixed(0)}KB) — sending…`));
-                    checkpoints.beginTurn(`/image ${rel}${caption ? ' ' + caption : ''}`, messages.length);
-                    messages.push({ role: 'user', content: content });
-                    rl.pause();
-                    abortSignal.aborted = false;
-                    agentRunning = true;
-                    await mcpReady(); // see the normal-message path below
-                    try {
-                        const result = await runTurn(messages, modelAlias, workDir, abortSignal, env, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, takePendingInput, worktreeState, peerCtx);
-                        messages = result.messages;
-                        updateTitle();
-                        saveSession(sessionId, sessionTitle, workDir, messages);
-                    }
-                    catch (err) {
-                        messages = recoverTurn(err, messages);
-                        updateTitle();
-                        saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    }
-                    finally {
-                        agentRunning = false;
-                        checkpoints.commitTurn();
-                    }
-                    rl.resume();
-                    rl.prompt();
-                    return;
-                }
-                case '/update': {
-                    rl.close();
-                    await updateCommand({ yes: false });
-                    process.exit(0);
-                }
-                case '/plugins': {
-                    const plugins = loadPlugins(workDir);
-                    if (!plugins.length) {
-                        console.log(chalk.dim('  No plugins installed. Install one:  nex plugin install owner/repo'));
-                    }
-                    else {
-                        console.log();
-                        console.log(chalk.bold('  Installed plugins:'));
-                        for (const p of plugins) {
-                            const ver = p.version ? chalk.dim(` v${p.version}`) : '';
-                            const scope = chalk.dim(` (${p.scope})`);
-                            console.log('  ' + chalk.cyan(p.name.padEnd(20)) + (p.description ?? '') + ver + scope);
-                        }
-                        console.log();
-                    }
-                    // Plugins may add skills/commands — refresh the palette.
-                    skills = loadSkills(workDir);
-                    rl.prompt();
-                    return;
-                }
-                case '/mcp': {
-                    // Reporting "not connected" purely because the background connect
-                    // hasn't finished would be misleading, so wait for the real answer.
-                    await mcpReady();
-                    console.log();
-                    console.log(chalk.bold('  MCP servers:'));
-                    console.log(formatMcpStatus());
-                    console.log();
-                    rl.prompt();
-                    return;
-                }
-                case '/trust': {
-                    // Trust is per-session and never persisted, so there is no stored
-                    // grant to inspect or revoke — the only thing worth showing is what
-                    // in THIS folder can configure the agent, which is exactly what the
-                    // startup prompt listed.
-                    console.log();
-                    console.log(chalk.bold('  Workspace trust:'));
-                    console.log(chalk.dim(`  ${workDir}`));
-                    const signals = detectTrustSignals(workDir);
-                    console.log();
-                    if (signals.length) {
-                        console.log(chalk.dim('  This folder configures the agent:'));
-                        for (const s of signals)
-                            console.log(chalk.dim(`    • ${s}`));
-                    }
-                    else {
-                        console.log(chalk.dim('  This folder contains no agent configuration files.'));
-                    }
-                    console.log();
-                    console.log(chalk.dim('  You confirmed this folder when the session started. ') +
-                        chalk.dim('Trust is not saved — you will be asked again next time, so a\n  ') +
-                        chalk.dim('newly added .nexrall/mcp.json can never run un-announced.'));
-                    console.log();
-                    rl.prompt();
-                    return;
-                }
-                case '/terminal-setup': {
-                    // Shift+Enter cannot be fixed from inside this process: most
-                    // terminals send a bare `\r` for it, byte-identical to Enter (see
-                    // terminal/terminalSetup.ts's own header, and decideEnterKey's
-                    // byte table). This reconfigures the TERMINAL to send a distinct
-                    // sequence; the handler already understands it.
-                    console.log();
-                    console.log(chalk.bold('  Terminal setup — Shift+Enter for a newline:'));
-                    console.log();
-                    const target = decideTerminalSetup({
-                        env: process.env,
-                        platform: process.platform,
-                        macOSMajor: detectMacOSMajor(),
-                    });
-                    if (target.kind === 'already-native') {
-                        console.log(chalk.green(`  ✓ ${target.terminal} already sends Shift+Enter as a newline.`));
-                        console.log(chalk.dim('    Nothing to install.'));
-                    }
-                    else if (target.kind === 'editor') {
-                        const outcome = await installEditorKeybinding(target.editor, {
-                            readFile: (p) => fs.promises.readFile(p, 'utf-8'),
-                            writeFile: (p, body) => fs.promises.writeFile(p, body, 'utf-8'),
-                            copyFile: (from, to) => fs.promises.copyFile(from, to),
-                            mkdir: async (p) => { await fs.promises.mkdir(p, { recursive: true }); },
-                            randomSuffix: () => crypto.randomBytes(4).toString('hex'),
-                        });
-                        switch (outcome.kind) {
-                            case 'installed':
-                                console.log(chalk.green(`  ✓ Installed the ${target.editor} Shift+Enter keybinding.`));
-                                console.log(chalk.dim(`    ${outcome.filePath}`));
-                                console.log(chalk.dim('    Takes effect immediately — no reload needed.'));
-                                break;
-                            case 'already-configured':
-                                console.log(chalk.green(`  ✓ ${target.editor} already has this keybinding.`));
-                                console.log(chalk.dim(`    ${outcome.filePath}`));
-                                break;
-                            case 'conflict':
-                                // Deliberately not overwritten: the user, or claude's own
-                                // /terminal-setup, chose that sequence. Report it instead.
-                                console.log(chalk.yellow(`  ! ${target.editor} already binds shift+enter to a different sequence.`));
-                                console.log(chalk.dim(`    Existing: ${JSON.stringify(outcome.existingText)}`));
-                                console.log(chalk.dim(`    Left as-is. Change it to ${JSON.stringify(SHIFT_ENTER_SEQUENCE)} to use it here.`));
-                                console.log(chalk.dim(`    ${outcome.filePath}`));
-                                break;
-                            case 'failed':
-                                console.log(chalk.red(`  ✗ Couldn't update ${target.editor}'s keybindings: ${outcome.reason}`));
-                                console.log(chalk.dim(`    ${outcome.filePath}`));
-                                break;
-                        }
-                    }
-                    else if (target.kind === 'apple-terminal') {
-                        // Below macOS 27 there is no Shift+Enter to install here — see
-                        // enableAppleTerminalOptionAsMeta's doc for why Option+Enter is
-                        // the supported route on those versions.
-                        const res = await enableAppleTerminalOptionAsMeta({
-                            run: async (cmd, args) => {
-                                try {
-                                    const stdout = execFileSync(cmd, args, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
-                                    return { code: 0, stdout };
-                                }
-                                catch (err) {
-                                    const e = err;
-                                    return { code: e.status ?? 1, stdout: e.stdout ?? '' };
-                                }
-                            },
-                            plistPath: path.join(os.homedir(), 'Library', 'Preferences', 'com.apple.Terminal.plist'),
-                        });
-                        if (res.ok) {
-                            console.log(chalk.green('  ✓ Enabled "Use Option as Meta Key" in Apple Terminal.'));
-                            console.log(chalk.dim(`    Profiles: ${res.profiles.join(', ')}`));
-                            console.log(chalk.dim('    Option+Enter now inserts a newline. Restart Terminal to apply.'));
-                            console.log(chalk.dim(`    Apple Terminal only gained Shift+Return in macOS ${MACOS_NATIVE_SHIFT_RETURN_MAJOR}; ` +
-                                'until then Option+Enter is the equivalent.'));
-                        }
-                        else {
-                            console.log(chalk.red(`  ✗ Couldn't configure Apple Terminal: ${res.reason}`));
-                        }
-                    }
-                    else {
-                        console.log(chalk.yellow(`  ! Not sure how to configure this terminal${target.terminal ? ` (${target.terminal})` : ''}.`));
-                        console.log(chalk.dim('    Bind Shift+Enter to send ESC then CR, if your terminal supports it.'));
-                    }
-                    // Always shown: these need no configuration anywhere, so a failed or
-                    // skipped install never leaves the user without a way to type a
-                    // newline.
-                    console.log();
-                    console.log(chalk.dim('  Works in every terminal, no setup required:'));
-                    console.log(chalk.dim('    • Ctrl+J          — insert a newline'));
-                    console.log(chalk.dim('    • \\ then Enter    — continue on the next line'));
-                    console.log();
-                    rl.prompt();
-                    return;
-                }
-                case '/agents': {
-                    console.log();
-                    console.log(chalk.bold('  Sub-agent types (used by the `task` tool):'));
-                    console.log(formatAgentsList(workDir));
-                    console.log();
-                    console.log(chalk.dim('  Define your own in .nexrall/agents/<name>.md or ~/.nexrall/agents/<name>.md'));
-                    console.log();
-                    rl.prompt();
-                    return;
-                }
-                case '/context': {
-                    console.log(formatContextUsage(messages, modelAlias));
-                    rl.prompt();
-                    return;
-                }
-                case '/skills':
-                case '/commands': {
-                    skills = loadSkills(workDir);
-                    const invocable = userInvokableSkills(skills);
-                    if (!invocable.length) {
-                        console.log(chalk.dim('  No skills. Add .nexrall/skills/<name>/SKILL.md (or .nexrall/commands/<name>.md) to create one.'));
-                    }
-                    else {
-                        console.log();
-                        console.log(chalk.bold('  Skills:'));
-                        for (const s of invocable) {
-                            const scope = s.source === 'project' ? '' : chalk.dim(` (${s.source})`);
-                            const auto = s.disableModelInvocation ? chalk.dim(' [manual only]') : '';
-                            console.log('  ' + chalk.cyan(`/${s.name}`.padEnd(20)) + chalk.dim(s.description) + scope + auto);
-                        }
-                        console.log();
-                    }
-                    rl.prompt();
-                    return;
-                }
-                default: {
-                    // Custom skill/command?
-                    const custom = findSkill(skills, cmd);
-                    if (!custom) {
-                        console.log(chalk.red(`  Unknown command: ${cmd}`));
-                        console.log(chalk.dim('  Type /help for built-ins or /skills for custom ones.'));
-                        rl.prompt();
-                        return;
-                    }
-                    const expanded = expandSkill(custom, arg, workDir);
-                    const turnModel = custom.model ?? modelAlias;
-                    const turnMode = custom.mode ?? agentMode;
-                    console.log(chalk.dim(`  Running /${custom.name}…`));
-                    checkpoints.beginTurn(`/${custom.name} ${arg}`.trim(), messages.length);
-                    messages.push({ role: 'user', content: [{ type: 'text', text: expanded }] });
-                    rl.pause();
-                    abortSignal.aborted = false;
-                    agentRunning = true;
-                    await mcpReady(); // see the normal-message path below
-                    try {
-                        const result = await runTurn(messages, turnModel, workDir, abortSignal, env, nexrallMd, turnMode, effortLevel, checkpoints, saveProgress, takePendingInput, worktreeState, peerCtx);
-                        messages = result.messages;
-                        updateTitle();
-                        saveSession(sessionId, sessionTitle, workDir, messages);
-                    }
-                    catch (err) {
-                        messages = recoverTurn(err, messages);
-                        updateTitle();
-                        saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-                    }
-                    finally {
-                        agentRunning = false;
-                        checkpoints.commitTurn();
-                    }
-                    rl.resume();
-                    rl.prompt();
-                    return;
-                }
-            }
-        }
-        // ── Normal message ────────────────────────────────────────────────────
-        checkpoints.beginTurn(userInput, messages.length);
-        messages.push({ role: 'user', content: [{ type: 'text', text: userInput }] });
-        rl.pause();
-        abortSignal.aborted = false;
-        agentRunning = true;
-        // MCP connects in the background so it can't delay the UI (see mcpStarted).
-        // Gate the turn on it here: the model must see the COMPLETE tool list, and
-        // by the time a user has typed a message this has almost always finished
-        // already, so in practice it waits for nothing.
-        await mcpReady();
-        try {
-            const result = await runTurn(messages, modelAlias, workDir, abortSignal, env, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, takePendingInput, worktreeState, peerCtx);
-            messages = result.messages;
-            updateTitle();
-            saveSession(sessionId, sessionTitle, workDir, messages);
-        }
-        catch (err) {
-            messages = recoverTurn(err, messages);
-            updateTitle();
-            saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-        }
-        finally {
-            agentRunning = false;
-            checkpoints.commitTurn();
-        }
-        rl.resume();
-        rl.prompt();
-    });
-    rl.on('close', () => {
-        updateTitle();
-        if (messages.length)
-            saveSession(sessionId, sessionTitle || 'Untitled', workDir, messages);
-        console.log('\n' + chalk.dim('  Goodbye.'));
-        process.exit(0);
-    });
-}