dexterm-cli 0.1.3 → 0.1.5

package/dist/packages/cli/src/main.js

@@ -29,6 +29,9 @@ import { makeFixtureState, makeFeedState, syncFeed, renderFrame, isScreenKey, ac
 import { mulberry32, tick, spawnPair, shock } from "./fixtures.js";
 import { createLiveFeed, createReplayFeed } from "./feed.js";
 import { LiveContext, INTERVALS, WATCH_REFRESH_MS, POSITIONS_REFRESH_MS, popupBubbleVM } from "./live/index.js";
+import { FOLLOW_NAV_ACTIONS } from '../../mcp/src/index.js';
+import { McpFollowSession } from "./mcp-follow.js";
+import { AgentPaperSwitch } from "./agent-paper.js";
 import { TOKEN_REFRESH_MS, CandlePrefetcher } from "./live/token.js";
 import { PRESETS, presetSpec } from "./screener/presets.js";
 import { parseSortArg, SORT_KEYS } from "./screener/sort.js";
@@ -45,6 +48,7 @@ import { copyAlertToDelivery } from "./alerts/format.js";
 import { readTelegramCreds, readDiscordCreds } from "./alerts/creds.js";
 import { launchIntelCells, launchRetryable } from "./live/intel.js";
 import { AnalystSession } from "./analyst/session.js";
+import { analystCliOnPath, parseEngineChoice, resolveEngine } from "./analyst/codex.js";
 import { resolveAnalystResults } from "./analyst/results.js";
 import { parseScanCommand, SCAN_FLAGS, checkScanFlag, SCAN_HELP } from "./scan/command.js";
 import { parseWalletCommand, WALLET_HELP } from "./wallet-command.js";
@@ -100,6 +104,21 @@ export function appStateBlock(state) {
         alerts, // booleans only — never a token, webhook or key
     };
 }
+/**
+ * task-1443: the reduced screen snapshot a terminal following an EXTERNAL agent (`--spectate-mcp`) publishes for
+ * that agent's `dexterm mcp` server: what is on screen plus a VIEW-ONLY nav allow-list. Never the watchlist,
+ * tickets, positions or app settings, and only the four follow nav action types (no watchlist add, no ticket).
+ */
+export function followSnapshot(state) {
+    const ss = buildScreenState(state);
+    const a = ss.actions;
+    return {
+        screen: ss.screen, selected: ss.selected, selectedDetail: ss.selectedDetail, filter: ss.filter, sort: ss.sort,
+        visible: ss.visible, visibleMints: ss.visibleMints,
+        actions: { enabled: a.enabled, mints: a.mints, feeds: a.feeds, sortKeys: a.sortKeys, screens: a.screens, workspaces: [], themes: [], types: [...FOLLOW_NAV_ACTIONS] },
+        now: ss.now,
+    };
+}
 export function buildScreenState(state) {
     const live = state.live;
     const sc = state.screener;
@@ -272,6 +291,7 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   dexterm alerts status|enable|disable|set-telegram|set-discord|test  where rule alerts are delivered (desktop / your Telegram / Discord; creds stay local, never logged)
   dexterm watch [--interval S] [--once] [--replay FILE]  run your rules headless and push alerts when the terminal is closed (no signer, proposals only)
   dexterm record run|install|uninstall|status  keep the history recorder fed with no TUI open, as a user-level launchd agent (no network beyond the data layer; 'dexterm record help')
+  dexterm larp-detected --out DIR [--db PATH]  build timestamped high-risk follow-up drafts/cards from recorder history; never posts
   dexterm --fixtures                          interactive demo on seeded fixtures
   dexterm --screen <name>                     one-shot frame to stdout (live)
   dexterm --screen <name> --fixtures          one-shot frame from fixtures
@@ -284,6 +304,11 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   --sort KEY[:asc|desc]     ${SORT_KEYS.map((k) => k.key).join(' | ')}
   --preset NAME             ${PRESETS.map((p) => p.id).join(' | ')}
   --record FILE             save every live response (and the PumpPortal session) to FILE (replay it with --replay)
+  --spectate-mcp            follow an MCP agent's allowed navigation in this terminal; Ctrl+P pauses, Ctrl+K stops,
+                            and any normal user keypress takes control (refused actions never move the UI)
+  --agent-paper MANDATE_ID  (experimental, with --spectate-mcp) let that MCP agent PAPER-trade inside a mandate you
+                            armed: simulated fills only, never signs or sends, never raises a cap; Ctrl+P / Ctrl+K /
+                            any key also pause, stop or take over its paper trading
   --max-requests N          hard cap on live requests for this run (default: none)
   --max-credits N           hard cap on Helius credits for this run (default: 5000)
   --mint MINT|LINK          token to open on the token screen (a CA or a dexscreener / pump.fun / solscan / birdeye link)
@@ -298,6 +323,8 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   --selected N              highlighted row / token index
   --seed N                  fixture PRNG seed (default 7)
   --no-ai                   hide the analyst panel on the token screen
+  --analyst-engine E        auto | claude | codex: which of YOUR installed CLIs runs the analyst (default auto = claude
+                            if installed, else codex; DEXTERM_ANALYST_ENGINE or config analyst.engine too; /engine in chat)
 
   --intensity LEVEL         off | normal | fever (default fever: rain, trails, glitch, blink, scanlines at 30 fps;
                             normal: 15 fps, sparser rain, no idle aberration; off = calm: neon theme, no motion)
@@ -385,13 +412,14 @@ export function parseArgs(argv) {
         screen: null, fixtures: false, replay: null, record: null, filter: null, sort: null, preset: null, maxRequests: 0, maxCredits: 0, db: null,
         mint: null, interval: '1h', listen: 20, verbose: false,
         width: null, height: null, html: null, export: null, theme: DEFAULT_THEME, selected: 0, seed: 7,
-        noAi: false, title: null, plain: false, ansi: false, color: null, tz: null,
+        noAi: false, analystEngine: null, title: null, plain: false, ansi: false, color: null, tz: null,
         calm: false, intensity: null, fps: null, frame: 0, t: 1, event: null, ai: null, mood: null, activity: null, noBoot: false, fit: null, fontPx: null, asciiRain: false, noImages: false,
         scan: false, scanConfig: {},
         noRecorder: false,
         sound: false,
         trade: [], live: true,
         workspace: null, priceMode: null,
+        spectateMcp: false, agentPaper: null,
         help: false, version: false, unknown: [],
     };
     for (let i = 0; i < argv.length; i++) {
@@ -480,6 +508,13 @@ export function parseArgs(argv) {
         }
         else if (k === '--no-ai')
             a.noAi = true;
+        else if (k === '--analyst-engine') {
+            const s = str();
+            const e = parseEngineChoice(s);
+            if (!e)
+                throw new Error(`unknown analyst engine ${s} (expected auto|claude|codex)`);
+            a.analystEngine = e;
+        }
         else if (k === '--calm')
             a.calm = true;
         else if (k === '--intensity') {
@@ -573,6 +608,16 @@ export function parseArgs(argv) {
                 throw new Error(`--price-mode expects price|mcap, got ${JSON.stringify(s.slice(0, 20))}`);
             a.priceMode = s;
         }
+        // task-1421: follow an agent driving over MCP (the running terminal moves with it; a read-only stream opens).
+        else if (k === '--spectate-mcp')
+            a.spectateMcp = true;
+        // task-1443: agent PAPER trading inside a mandate the user armed (validated against the plans journal at start).
+        else if (k === '--agent-paper') {
+            const s = str();
+            if (!/^[A-Za-z0-9_-]{1,64}$/.test(s))
+                throw new Error(`--agent-paper expects a mandate id (see \`dexterm mandate list\`), got ${JSON.stringify(s.slice(0, 20))}`);
+            a.agentPaper = s;
+        }
         else if (k === '--workspace') {
             const s = str();
             if (!/^[a-z][a-z0-9-]{0,39}(\/[a-z][a-z0-9-]{0,39})?$/.test(s))
@@ -610,6 +655,10 @@ export function parseArgs(argv) {
         throw new Error('--scan needs live data or a recording (drop --fixtures)');
     if (a.scan && a.screen)
         throw new Error('--scan is interactive (drop --screen)');
+    if (a.agentPaper && !a.spectateMcp)
+        throw new Error('--agent-paper needs --spectate-mcp (every agent paper trade must be visible in this terminal)');
+    if (a.agentPaper && a.db === ':memory:')
+        throw new Error('--agent-paper needs an on-disk --db (the agent books into the same paper wallet)');
     return a;
 }
 /**
@@ -790,6 +839,11 @@ export async function main(argv, io = process, proc = process) {
         const { backtestCommand } = await import("./backtest-cmd.js");
         return backtestCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // Local-only marketing evidence pipeline (task-1433): drafts and cards for human review, never posts.
+    if (argv[0] === 'larp-detected') {
+        const { larpDetectedCommand } = await import("./larp-detected.js");
+        return larpDetectedCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
     // `dexterm kol …` → KOL lists on the shared DB (task-1330): list/create/add/remove/mute/unmute/enable/disable/import.
     if (argv[0] === 'kol')
         return kolCommand(argv.slice(1), io);
@@ -1006,6 +1060,8 @@ export async function main(argv, io = process, proc = process) {
                     });
                     recorder.attach(feed.dl.store);
                     ctx.recorder = recorder;
+                    // 0.1.5 dev history: PumpPortal / RugCheck creators of new pairs go into the creator index too.
+                    ctx.newpairs.onCreator = (mint, creator, source, createdAt) => { recorder.recordCreator(mint, creator, source, undefined, createdAt); };
                 }
                 if (args.verbose)
                     io.stderr.write(`dexterm: rpc ${rpc.provider} (${rpc.basis}) · db ${dbPath} · recorder ${ctx.recorder ? 'on' : 'off'} · live trading ${args.live && !io.env.DEXTERM_OFFLINE ? 'available' : 'off'}\n`);
@@ -2626,6 +2682,50 @@ export function applyScanAnalystAction(state, raw) {
     const res = validateAnalystAction(raw, { ...allow, types: SCAN_ACTION_TYPES });
     return { ok: false, error: res.ok ? 'AI scan mode is observe-only' : res.error };
 }
+/**
+ * The analyst engine for a run (0.1.5): `--analyst-engine`, then DEXTERM_ANALYST_ENGINE, then config
+ * `analyst.engine`, then auto (claude when installed, else codex). Only the user picks it; models cannot.
+ */
+export function analystEngineFor(flag, env, configured, has = (b) => analystCliOnPath(b, env)) {
+    const choice = parseEngineChoice(flag) ?? parseEngineChoice(env.DEXTERM_ANALYST_ENGINE) ?? parseEngineChoice(configured) ?? 'auto';
+    return resolveEngine(choice, has);
+}
+/** `/engine [auto|claude|codex]` in the chat box (0.1.5). Null when the input is not this command. */
+export function parseEngineCommand(q) {
+    const m = /^\/engine(?:\s+(\S+))?\s*$/i.exec(q.trim());
+    if (!m)
+        return null;
+    if (!m[1])
+        return { show: true };
+    const c = parseEngineChoice(m[1]);
+    return c ? { choice: c } : { error: `unknown analyst engine "${m[1].slice(0, 16)}" (use /engine auto|claude|codex)` };
+}
+/**
+ * Apply `/engine`: switch the CLI for NEW conversations this run (cached per-coin chats are dropped so the next
+ * `a` starts on the chosen engine; a running turn finishes where it started). Returns the line to show.
+ */
+export function engineCommand(state, cmd, env, has = (b) => analystCliOnPath(b, env)) {
+    const installed = ['claude', 'codex'].filter((b) => has(b));
+    const list = installed.length ? installed.join(' + ') : 'neither claude nor codex';
+    if ('error' in cmd)
+        return cmd.error;
+    const cur = state.analystEngine ?? 'claude';
+    if ('show' in cmd)
+        return `analyst engine: ${cur} · installed: ${list} · /engine claude|codex|auto switches (config analyst.engine keeps it)`;
+    const next = resolveEngine(cmd.choice, has);
+    if (cmd.choice !== 'auto' && !has(next))
+        return `${next} is not installed (installed: ${list}); ${next === 'codex' ? 'npm i -g @openai/codex && codex login' : 'install Claude Code, then run claude once to log in'}`;
+    if (next !== cur) {
+        for (const [k, sess] of state.analystByMint ?? []) {
+            if (!sess.busy)
+                state.analystByMint.delete(k);
+        }
+        if (state.analyst && !state.analyst.busy && state.analyst.engine !== next)
+            state.analyst = null;
+    }
+    state.analystEngine = next;
+    return `analyst engine: ${next} (your own ${next} CLI and login) for new conversations · set analyst.engine in config.json to keep it`;
+}
 /**
  * The ONE way a scan-driven analyst conversation is built (task-1324; the loop and the safety tests both
  * use it): the locked coin as the selected coin, `actionTypes: []` (observe-only at the validator, the
@@ -2639,7 +2739,7 @@ export function createScanSession(state, mint, symbol, hooks = {}, deps = {}) {
         const type = typeof raw.type === 'string' ? raw.type.replace(/[^a-z_]/gi, '').slice(0, 24) : '?';
         hooks.onBlocked?.(type, r.error ?? 'refused');
     };
-    return new AnalystSession({ skill: 'token-dossier', mint, symbol, screenState: ss, onAction, actionTypes: SCAN_ACTION_TYPES, scan: true }, hooks.onChange ?? (() => { }), deps);
+    return new AnalystSession({ skill: 'token-dossier', mint, symbol, screenState: ss, onAction, actionTypes: SCAN_ACTION_TYPES, scan: true, ...(state.analystEngine === 'codex' ? { engine: 'codex' } : {}) }, hooks.onChange ?? (() => { }), deps);
 }
 /**
  * Resolve a mint to an openable seed from what the app already knows (screener view → new pairs →
@@ -2895,6 +2995,76 @@ export function applyAnalystAction(state, raw, stack) {
     times.push(now);
     return { ok: true, label: res.label };
 }
+/**
+ * task-1421: move the REAL terminal to mirror an agent's navigation (follow mode, on the owner's own
+ * machine). This is the same VIEW-ONLY navigation the analyst / go-to path uses — open a token, switch
+ * screen/feed, set a filter, highlight a row, open the PAPER ticket editor. It never trades, sizes, confirms
+ * or signs, and the key loop flips control to the user before any of it runs, so the human always wins the
+ * screen. Unlike the analyst boundary it does not re-check the on-screen allow-list: the agent already made
+ * the call on its own server and this only reflects where it went. A no-op when live navigation is off.
+ */
+export function applyFollowNav(state, nav, stack) {
+    const sc = state.screener;
+    const live = state.live && state.screener.source !== 'fixtures' ? state.live : null;
+    const toScreen = (next) => { if (state.screen !== next) {
+        stack.push(state.screen);
+        state.screen = next;
+    } };
+    if (nav.mint && (!nav.screen || nav.screen === 'token')) {
+        if (!live)
+            return;
+        try {
+            live.openToken(seedForMint(state, live, nav.mint));
+            toScreen('token');
+        }
+        catch { /* a stale mint never breaks follow */ }
+        return;
+    }
+    if (nav.screen === 'ticket') {
+        if (!live || !nav.mint)
+            return;
+        try {
+            const seed = seedForMint(state, live, nav.mint);
+            live.openTicket({ mint: seed.mint, symbol: seed.symbol, name: seed.name }, nav.side === 'sell' ? 'sell' : 'buy');
+            toScreen('ticket');
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    if (nav.screen === 'watchlist') {
+        if (live && nav.mint) {
+            try {
+                if (!live.watch.has(nav.mint))
+                    live.watch.add(LiveContext.candidate(seedForMint(state, live, nav.mint)));
+            }
+            catch { /* ignore */ }
+        }
+        toScreen('watchlist');
+        return;
+    }
+    if (nav.feed || nav.filter || nav.highlight || nav.screen === 'screener') {
+        toScreen('screener');
+        if (nav.feed) {
+            if (setPreset(sc, nav.feed) && state.feed)
+                state.feed.setPreset(sc.preset);
+        }
+        if (nav.filter) {
+            try {
+                setFilter(sc, nav.filter);
+            }
+            catch { /* an invalid agent filter is ignored */ }
+        }
+        if (nav.highlight) {
+            const i = screenerView(sc).findIndex((r) => r.mint === nav.highlight);
+            if (i >= 0)
+                state.selected = i;
+        }
+        state.selected = clampSelection(sc, state.selected);
+        return;
+    }
+    if (nav.screen && isScreenKey(nav.screen))
+        toScreen(nav.screen);
+}
 /**
  * task-1413: apply an accepted tier-(b) config proposal through the journaled path as actor `analyst`
  * (so `ctrl+z` undoes it), creating the parent section when absent (exactly like the `$` / `,` handlers),
@@ -3393,7 +3563,14 @@ export function terminalGuard(io, onFatal = () => { }, proc = process, hooks = {
         proc.exit(1);
     };
     const onExit = () => restore();
-    const onSignal = (sig) => { restore(); proc.exit(sig === 'SIGTERM' ? 143 : 129); };
+    const onSignal = (sig) => {
+        restore();
+        try {
+            hooks.onSignal?.();
+        }
+        catch { /* cleanup is best-effort; the exit still happens */ }
+        proc.exit(sig === 'SIGTERM' ? 143 : 129);
+    };
     const onTerm = () => onSignal('SIGTERM');
     const onHup = () => onSignal('SIGHUP');
     let installed = false;
@@ -3430,6 +3607,8 @@ export function fpsFor(args, intensity) {
 const SYNC_ON = '\x1b[?2026h';
 const SYNC_OFF = '\x1b[?2026l';
 export function interactive(state, io, depth, args, proc = process) {
+    // 0.1.5: the analyst engine for new conversations (the user's own claude or codex CLI; never a shipped key).
+    state.analystEngine ??= analystEngineFor(args.analystEngine, io.env, state.custom?.config.analyst?.engine);
     const out = io.stdout;
     const inp = io.stdin;
     const rnd = mulberry32(99);
@@ -3730,6 +3909,11 @@ export function interactive(state, io, depth, args, proc = process) {
         let timer = null;
         let lastRefresh = 0;
         let done = false;
+        // task-1421: the MCP follow session (set below when `--spectate-mcp` is on). Declared here so the quit /
+        // terminal-guard teardown closures can stop it.
+        let followSession = null;
+        // task-1443: `--agent-paper <mandate-id>` (with --spectate-mcp) lets that agent PAPER-trade inside the mandate.
+        const agentPaper = args.spectateMcp && args.agentPaper ? new AgentPaperSwitch({ env: io.env, mandateId: args.agentPaper, db: args.db ?? defaultDbPath(io.env) }) : null;
         // Idle economy (task-1303, retuned for task-1319 AC3): between events the ambient rain redraws at
         // IDLE_FPS instead of the full frame cap, cutting idle CPU. A keypress opens a KEY_WAKE_S full-rate
         // window (`wakeUntil`) so input and transitions stay smooth; data landings paint at once on their own
@@ -3758,10 +3942,13 @@ export function interactive(state, io, depth, args, proc = process) {
                     say(`trade moment failed: ${describeError(e)}`, 'warn');
                 }
             };
-        const guard = terminalGuard(io, () => { done = true; prefetcher?.close(); if (timer)
-            clearInterval(timer); state.analyst?.cancel(); if (state.analystByMint)
+        const teardown = () => { done = true; prefetcher?.close(); if (timer)
+            clearInterval(timer); void followSession?.stop(); agentPaper?.stop(); state.analyst?.cancel(); if (state.analystByMint)
             for (const s of state.analystByMint.values())
-                s.cancel(); state.popups?.shutdown(); voice?.disable(); images?.close(); live?.close(); feed?.close(); }, proc, { beforeLeave: () => layer?.teardown() ?? '' });
+                s.cancel(); state.popups?.shutdown(); voice?.disable(); images?.close(); live?.close(); feed?.close(); };
+        // task-1443: SIGTERM/SIGHUP (a closed terminal window) runs the same teardown as a fatal error, so the agent-paper
+        // rendezvous, the spectator rendezvous and the --record file never outlive the terminal that owns them.
+        const guard = terminalGuard(io, teardown, proc, { beforeLeave: () => layer?.teardown() ?? '', onSignal: teardown });
         let lastTokenRefresh = 0;
         let lastWatchRefresh = 0;
         let lastPositionsRefresh = 0;
@@ -3930,6 +4117,41 @@ export function interactive(state, io, depth, args, proc = process) {
         // task-1326: an image landing (decoded, or found missing) repaints at most once per macrotask.
         if (images)
             images.onChange = () => scheduleDraw();
+        // task-1421: `--spectate-mcp` → follow an agent driving over MCP. The rendezvous lets a `dexterm mcp`
+        // server the external client spawned emit here; we tail it, move the terminal for navigation calls, and
+        // the owner's controls (ctrl+p pause/resume · ctrl+k stop · any key = take over) are handled in onInput.
+        // A read-only, loopback, token-gated stream opens too (`dexterm spectate --info`). Off (and zero-cost)
+        // unless the flag is set; nothing it folds can arm, sign, confirm, send or raise a cap.
+        if (args.spectateMcp) {
+            followSession = new McpFollowSession({
+                env: io.env,
+                stream: true,
+                onNav: (nav) => {
+                    const before = state.screen;
+                    try {
+                        applyFollowNav(state, nav, stack);
+                    }
+                    catch { /* a stale mint never breaks follow */ }
+                    if (state.screen !== before) {
+                        try {
+                            startTransition();
+                        }
+                        catch {
+                            transition = null;
+                        }
+                    }
+                    scheduleDraw();
+                },
+                onStatus: (line) => { say(line, 'ai', 4); scheduleDraw(); },
+                onEvent: () => scheduleDraw(),
+                onControl: agentPaper ? (st) => agentPaper.control(st) : undefined,
+                snapshot: () => followSnapshot(state),
+            });
+            void followSession.start();
+            say('following agents over MCP · ctrl+p pause · ctrl+k stop · any key takes over', 'ai', 6);
+            if (agentPaper)
+                say(agentPaper.start(), 'ai', 8);
+        }
         // Launch a real Claude analyst session when a key asked for one (applyAction cannot spawn). A
         // `question` means start it as a chat turn, not a paid structured skill run (task-1311, QA B3).
         const beginAnalyst = () => {
@@ -3996,7 +4218,7 @@ export function interactive(state, io, depth, args, proc = process) {
                     maybeSpeakVoiceAnswer(session); // task-1282: speak a voice-initiated answer when it settles
                     scheduleDraw();
                 };
-                const session = new AnalystSession({ skill: p.skill, mint: p.mint, symbol: p.symbol, screenState: buildScreenState(state), model: p.model, onAction }, onChange);
+                const session = new AnalystSession({ skill: p.skill, mint: p.mint, symbol: p.symbol, screenState: buildScreenState(state), model: p.model, onAction, ...(state.analystEngine === 'codex' ? { engine: 'codex' } : {}) }, onChange);
                 if (p.question)
                     session.ask(p.question, buildScreenState(state));
                 else
@@ -4919,6 +5141,8 @@ export function interactive(state, io, depth, args, proc = process) {
             prefetcher?.close();
             if (timer)
                 clearInterval(timer);
+            void followSession?.stop();
+            agentPaper?.stop();
             guard.restore();
             guard.uninstall();
             cancelAllAnalysts();
@@ -4973,6 +5197,27 @@ export function interactive(state, io, depth, args, proc = process) {
                     quit();
                     return;
                 }
+                // task-1421 follow-mode controls (only while following an MCP agent). ctrl+p pauses / resumes the
+                // terminal mirroring; ctrl+k stops following (removes the rendezvous so the server stops emitting);
+                // ANY other key while the agent is driving hands control to the user — the human and the agent never
+                // fight over the screen. The control keys are consumed; the take-over key still does its own job.
+                if (followSession) {
+                    if (key.ctrl && key.ch === 'k') {
+                        followSession.kill();
+                        draw();
+                        continue;
+                    }
+                    if (key.ctrl && key.ch === 'p') {
+                        if (followSession.isPaused)
+                            followSession.resume();
+                        else
+                            followSession.pause();
+                        draw();
+                        continue;
+                    }
+                    if (followSession.controlState === 'agent')
+                        followSession.userKey(); // take over, then fall through
+                }
                 // task-1413: a pending analyst config PROPOSAL owns the next key. `y` accepts and journals it as
                 // actor 'analyst' (ctrl+z undoes); any other key dismisses it. A stray key never persists a change.
                 // Two guards (defect c): the proposal does NOT steal a key while a TEXT INPUT is open — the GO-TO
@@ -5496,6 +5741,14 @@ export function interactive(state, io, depth, args, proc = process) {
                             draw();
                             continue;
                         }
+                        // 0.1.5: `/engine [auto|claude|codex]` switches the analyst CLI for new conversations; never sent to a model.
+                        const en0 = q.startsWith('/') ? parseEngineCommand(q) : null;
+                        if (en0) {
+                            state.aiInput = '';
+                            say(engineCommand(state, en0, io.env), typeof en0 === 'object' && 'error' in en0 ? 'warn' : 'info', 6);
+                            draw();
+                            continue;
+                        }
                         // task-1324: `/scan …` in the chat input is a command, never sent to claude.
                         const sc0 = q.startsWith('/') ? parseScanCommand(q) : null;
                         if (sc0) {