@cruxy/cli 1.2.0 → 1.3.0

package/dist/cli/commands/usage.js

@@ -3,13 +3,20 @@ import { loadConfig } from "../../config/index.js";
 import { shouldUseColor, usageError } from "../../errors/index.js";
 import { themeForColor } from "../../theme/index.js";
 import { logger } from "../../utils/logger.js";
-import { loadUsage, summarizeRuns, renderSummary, } from "../../usage/index.js";
+import { loadUsage, runCountLabel, selectRuns, usageReport, } from "../../usage/index.js";
 /**
- * `cruxy usage` (C.22) — show LOCAL token usage and (when priced) cost, read
+ * `cruxy usage` (C.22) — show LOCAL token usage, weighted tokens and cost, read
  * back from `~/.cruxy/usage`. Read-only and local: it prints your own accounting
- * and transmits nothing. Every figure is real — a request the provider never
- * reported usage for is shown as unreported, never a fabricated number, and cost
- * appears only for tiers you have priced.
+ * and transmits nothing (this command makes no request of its own; it only reads
+ * figures the gateway already sent on chat responses). Every figure is real — a
+ * request the provider never reported usage for is shown as unreported, never a
+ * fabricated number.
+ *
+ * The report itself lives in `usage/report.ts` (P6 track 2). This file is now
+ * only the commander half: flags in, scope out, lines printed. `/usage` renders
+ * the SAME report from inside a session, so the two surfaces cannot drift — and
+ * in particular cannot end up disagreeing about what the weighted figure means,
+ * which is the part that has to be said identically every time.
  */
 export function usageCommand() {
     return new Command("usage")
@@ -24,44 +31,25 @@ export function usageCommand() {
         const { data, error } = loadUsage();
         if (error)
             throw error;
-        const scoped = selectRuns(data.runs, opts);
-        if (scoped.length === 0) {
-            logger.print(t.muted("no usage recorded yet"));
-            if (!config.usage.enabled) {
-                logger.print(t.muted("usage tracking is off (usage.enabled = false)"));
-            }
-            return;
-        }
-        const summary = summarizeRuns(scoped, {
-            prices: config.usage.prices,
-            currency: config.usage.currency,
-        });
-        const scopeLabel = opts.session
-            ? "current session"
-            : opts.last
-                ? `last ${scoped.length} run${scoped.length === 1 ? "" : "s"}`
-                : `all ${scoped.length} run${scoped.length === 1 ? "" : "s"}`;
-        logger.print(t.heading(`usage — ${scopeLabel}`));
-        logger.print(renderSummary(summary, t));
-        // State when NO price is configured, so an absent cost never reads as $0.
-        // Self-contained: set a number, see cost — copy-pasteable commands, no
-        // docs lookup and no jargon needed.
-        if (!summary.priced) {
-            logger.print(t.muted([
-                "cost omitted — no prices set. To see cost, set your per-million-token",
-                "rates for each tier (kavi, vaani, mira):",
-                "  cruxy config set usage.prices.kavi.input 0.5",
-                "  cruxy config set usage.prices.kavi.output 1.5",
-            ].join("\n")));
+        const scope = resolveScope(data.runs, opts);
+        const scoped = selectRuns(data.runs, scope);
+        for (const line of usageReport(scoped, t, {
+            scopeLabel: scopeLabel(opts, scoped.length),
+            trackingEnabled: config.usage.enabled,
+            legacyPriceConfig: config.usage.currency !== undefined ||
+                config.usage.prices !== undefined,
+        })) {
+            logger.print(line);
         }
     });
 }
 /**
- * Narrow the stored runs to the requested scope. `--last N` keeps the newest N;
- * `--session` keeps the runs sharing the most recent run's session id; no flag
- * keeps everything retained. `--session` and `--last` are mutually exclusive.
+ * Turn the flags into a {@link UsageScope}. `--session` is INFERRED here — from
+ * the newest run's session id — because a command line has no session of its
+ * own to ask. (`/usage` inside a session does not infer: it knows its id.)
+ * `--session` and `--last` are mutually exclusive.
  */
-function selectRuns(runs, opts) {
+function resolveScope(runs, opts) {
     if (opts.session && opts.last !== undefined) {
         throw usageError("pass only one of --session or --last", [
             "cruxy usage --session   (the most recent session)",
@@ -73,16 +61,28 @@ function selectRuns(runs, opts) {
         if (!Number.isInteger(n) || n <= 0) {
             throw usageError(`--last must be a positive integer (got "${opts.last}")`);
         }
-        return runs.slice(-n);
+        return { last: n };
     }
     if (opts.session) {
         const latest = runs[runs.length - 1];
+        // Nothing stored: an empty scope over an empty store is already empty, and
+        // the report renders the "nothing yet" answer.
         if (!latest)
-            return [];
-        // Runs without a session id can't be grouped; scope to the latest run alone.
-        if (latest.sessionId === undefined)
-            return [latest];
-        return runs.filter((r) => r.sessionId === latest.sessionId);
+            return {};
+        // Runs without a session id can't be grouped; scope to the latest alone by
+        // asking for the last 1 rather than for an `undefined` session, which would
+        // match every other ungrouped run in the store.
+        return latest.sessionId === undefined
+            ? { last: 1 }
+            : { sessionId: latest.sessionId };
     }
-    return [...runs];
+    return {};
+}
+/** The heading's scope phrase, matching the flag the user actually passed. */
+function scopeLabel(opts, count) {
+    if (opts.session)
+        return "current session";
+    if (opts.last)
+        return `last ${runCountLabel(count)}`;
+    return `all ${runCountLabel(count)}`;
 }

package/dist/cli/onboard.js

@@ -2,6 +2,7 @@ import { resolveApiKey } from "../config/index.js";
 import { createDefaultDeps, defaultOnboardingIO, isFirstRun, runOnboarding, } from "../onboarding/index.js";
 import { createRenderer } from "../render/index.js";
 import { sessionWorkspace } from "../workspace/index.js";
+import { DEFAULT_MODE } from "../agent/index.js";
 import { buildAgentSession } from "./session-factory.js";
 /**
  * CLI-layer glue between the entry points and the onboarding module (U.6). Keeps
@@ -25,7 +26,7 @@ export async function runFirstWinTask(config, cwd, prompt) {
     const renderer = createRenderer();
     // The onboarding first-win is inherently single-root (it runs before any
     // `--root` is parsed), so it acts over a trivial workspace on its cwd.
-    const session = buildAgentSession(config, apiKey, sessionWorkspace(cwd), true, false, renderer);
+    const session = buildAgentSession(config, apiKey, sessionWorkspace(cwd), true, DEFAULT_MODE, renderer);
     try {
         await session.send(prompt, renderer);
     }

package/dist/cli/program.js

@@ -4,7 +4,10 @@ import { PRODUCT_MASTHEAD } from "../brand/index.js";
 import { logger } from "../utils/logger.js";
 import { shouldUseColor, usageError } from "../errors/index.js";
 import { themeForColor } from "../theme/index.js";
-import { runCommand } from "./commands/run.js";
+import { detectCapabilities } from "../render/index.js";
+import { supportsTui } from "../tui/index.js";
+import { executeRun, runCommand } from "./commands/run.js";
+import { suggestCommand } from "./suggest.js";
 import { configCommand } from "./commands/config.js";
 import { indexCommand } from "./commands/index.js";
 import { skillsCommand } from "./commands/skills.js";
@@ -28,7 +31,8 @@ export function buildProgram() {
         .version(APP_VERSION, "-v, --version", "print the cruxy version")
         .option("-c, --config <path>", "use a specific config file")
         .option("--log-level <level>", "debug | info | warn | error | silent")
-        .option("--verbose", "shorthand for --log-level debug");
+        .option("--verbose", "shorthand for --log-level debug")
+        .option("--resume [id]", "resume a saved session by id; omit the id to pick from recent sessions");
     // Apply global options as early as possible.
     program.hook("preAction", (thisCommand) => {
         const opts = thisCommand.opts();
@@ -51,17 +55,40 @@ export function buildProgram() {
     program.addCommand(memoryCommand());
     program.addCommand(usageCommand());
     program.addCommand(mcpCommand());
-    // Default action: bare `cruxy` -> entrypoint. An unrecognized first operand
-    // means an unknown command (Commander runs the default action with it as an
-    // operand rather than erroring), so reject it as a usage error.
-    program.action(async (_opts, command) => {
-        if (command.args.length > 0) {
-            throw usageError(`unknown command: ${command.args[0]}`, [
-                "run `cruxy --help` to see available commands",
-            ]);
+    // Default action: bare `cruxy` opens the TUI; `cruxy <message>` opens it and
+    // runs that message as the first turn. Operands reach here only when they
+    // matched no subcommand, so a bare token is a MESSAGE by default — only a
+    // near-miss for a real command name is refused (see `suggestCommand`).
+    program.arguments("[message...]");
+    program.action(async (messageParts, opts, command) => {
+        const operands = messageParts ?? command.args;
+        if (operands.length === 1) {
+            const known = command.commands.map((c) => c.name());
+            const meant = suggestCommand(operands[0], known);
+            if (meant !== null) {
+                throw usageError(`unknown command: ${operands[0]}`, [
+                    `did you mean \`cruxy ${meant}\`?`,
+                    "run `cruxy --help` to see available commands",
+                ]);
+            }
         }
-        // First-run with no key (and a TTY) → guided setup, with the first-win demo.
-        // Otherwise fall through to the banner (an already-set-up user, or non-TTY).
+        // Nothing to do and nowhere to do it: no message, and an environment that
+        // cannot host the TUI (a pipe, CI, TERM=dumb, a screen reader). Print
+        // guidance and exit 0 — a bare `cruxy` in a script has always succeeded,
+        // and a foundation change must not turn that into a failure.
+        //
+        // `--resume` is excluded: it names something specific to do, so it must
+        // reach the run pipeline (and fail loud on a bad id) rather than being
+        // answered with a banner.
+        if (operands.length === 0 &&
+            opts.resume === undefined &&
+            !supportsTui(detectCapabilities())) {
+            printGuidance();
+            return;
+        }
+        // First-run with no key (and a TTY) → guided setup, with the first-win
+        // demo. `executeRun` runs the same check for the keyed path; doing it here
+        // first keeps a brand-new user out of a TUI they cannot yet use.
         const { config } = loadConfig();
         const onboarding = maybeRunOnboarding(config, {
             ttyInteractive: Boolean(process.stdin.isTTY),
@@ -72,12 +99,15 @@ export function buildProgram() {
             await onboarding;
             return;
         }
-        const t = themeForColor(shouldUseColor(process.stdout));
-        logger.print(t.accent(`${APP_NAME} v${APP_VERSION}`));
-        logger.print(t.muted("an agentic coding CLI\n"));
-        logger.print("The interactive REPL lands in C.3 (terminal UI).");
-        logger.print(`For now try:  ${t.strong('cruxy run "<task>"')}  or  ${t.strong("cruxy config path")}`);
-        logger.print(`See all commands:  ${t.strong("cruxy --help")}`);
+        // The TUI is a REQUEST: on a pipe, a screen reader, or TERM=dumb the
+        // factory declines it and this is exactly the pre-existing REPL/one-shot
+        // path, with the pre-existing renderers.
+        await executeRun(operands, {
+            root: [],
+            tui: true,
+            commandName: "cruxy",
+            ...(opts.resume !== undefined ? { resume: opts.resume } : {}),
+        });
     });
     // Throw CommanderError instead of calling process.exit, and suppress
     // Commander's own "error:" line — so parse errors (unknown command/option,
@@ -87,6 +117,18 @@ export function buildProgram() {
     routeErrorsToBoundary(program);
     return program;
 }
+/**
+ * The banner for an environment that cannot open the TUI and was given nothing
+ * to run. Exits 0 — this is guidance, not a failure.
+ */
+function printGuidance() {
+    const t = themeForColor(shouldUseColor(process.stdout));
+    logger.print(t.accent(`${APP_NAME} v${APP_VERSION}`));
+    logger.print(t.muted("an agentic coding CLI\n"));
+    logger.print(`Start a session:   ${t.strong("cruxy")}            ${t.muted("(needs a terminal)")}`);
+    logger.print(`Run one task:      ${t.strong('cruxy "<task>"')}`);
+    logger.print(`See all commands:  ${t.strong("cruxy --help")}`);
+}
 /** Recursively make a command (and its subcommands) throw on error, silently. */
 function routeErrorsToBoundary(command) {
     command.exitOverride();

package/dist/cli/repl.js

@@ -1,12 +1,38 @@
 import readline from "node:readline";
 import { makeReplCompleter } from "../components/index.js";
-import { resolveSlash } from "../hooks/index.js";
-import { runGatedShell } from "../tools/shell/exec.js";
-import { addRootToWorkspace } from "../workspace/index.js";
 import { themeForColor } from "../theme/index.js";
-import { formatError, fromUnknown, isVerbose, shouldUseColor, } from "../errors/index.js";
+import { shouldUseColor } from "../errors/index.js";
 import { createRenderer, fit, resolveColumns, } from "../render/index.js";
+import { SHARED_COMMANDS, SHARED_HELP, dispatchCommand, printCommandError, } from "./session-commands.js";
+import { defaultComponentIO, selectList } from "../components/index.js";
 import { logger } from "../utils/logger.js";
+/**
+ * The REPL's picker (P6 track 1): the standalone stderr frame every U.7
+ * component builds by default, over its own raw-mode reader.
+ *
+ * Safe here specifically because of how {@link readLine} works — the readline
+ * interface is created per line and CLOSED before dispatch runs, so nothing else
+ * holds stdin at this point. That is the same property the approval prompt has
+ * always relied on; this is not a new claim on the terminal.
+ *
+ * Declines on a non-interactive stdin rather than letting `resolveNonInteractive`
+ * throw: `/model` with no argument is a request to browse, and a piped session
+ * answering it with a fatal `CRUXY_E_INTERACTIVE_REQUIRED` would kill a REPL over
+ * a command that has a perfectly good text form.
+ */
+const replPicker = async (items, opts) => {
+    const io = defaultComponentIO();
+    if (!io.interactive)
+        return null;
+    const result = await selectList(items, {
+        title: opts.title,
+        toLabel: opts.toLabel,
+        ...(opts.initialIndex === undefined
+            ? {}
+            : { initialIndex: opts.initialIndex }),
+    }, io);
+    return result.kind === "selected" ? result.value : null;
+};
 /** The REPL prompts on stdout; its chrome resolves against stdout's color. */
 const theme = themeForColor(shouldUseColor(process.stdout));
 /** Fit a committed REPL line to stdout's current width (U.12), id/status-first. */
@@ -15,32 +41,26 @@ function fitOut(line) {
 }
 const PROMPT = `${theme.accent("cruxy")} ${theme.muted(theme.glyph.caret)} `;
 /**
- * The REPL's slash commands — the autocomplete candidate set (U.7). Keep in
- * sync with the dispatch below and the HELP text.
+ * Where the REPL's command output goes: straight to the logger, fitted to
+ * stdout's width. The TUI supplies its own; everything else about a command is
+ * shared (see `session-commands.ts`).
+ */
+const replOutput = {
+    print: (line = "") => logger.print(line),
+    theme,
+    fit: fitOut,
+};
+/**
+ * The REPL's slash commands — the autocomplete candidate set (U.7). Derived from
+ * the shared list so a command added there is completable here without a second
+ * edit; this shell adds nothing of its own.
  */
-export const REPL_COMMANDS = [
-    "/help",
-    "/clear",
-    "/compact",
-    "/reload",
-    "/plan",
-    "/jobs",
-    "/logs",
-    "/cancel",
-    "/exit",
-    "/quit",
-];
-const HELP = `Commands:
-  /help          show this help
-  /clear         clear the conversation history (keep the session)
-  /compact       summarize older history to free up context now
-  /reload        re-read project instructions (CRUXY.md)
-  /plan          toggle plan mode (propose a plan before executing)
-  /jobs          list background jobs and their status
-  /logs <id>     show a background job's log
-  /cancel <id>   cancel a background job
-  /exit, /quit   leave cruxy
-  Ctrl+D         leave cruxy`;
+export const REPL_COMMANDS = SHARED_COMMANDS;
+const HELP = [
+    "Commands:",
+    ...SHARED_HELP,
+    "  Ctrl+D           leave cruxy",
+].join("\n");
 const defaultIO = () => ({
     input: process.stdin,
     output: process.stdout,
@@ -83,86 +103,11 @@ function readLine(io, prompt) {
         });
     });
 }
-/**
- * Run a shell-bound custom slash command (C.19) through the SAME gated +
- * sandboxed path as `run_command` (`runGatedShell` over the session's tool
- * context) — never a privileged route. Prints the result like a shell run; a
- * gate rejection or a thrown coded error (e.g. sandbox) is surfaced, not fatal.
- */
-async function runSlashShell(spec, session) {
-    logger.print(theme.muted(`running /${spec.name}${theme.glyph.ellipsis}`));
-    try {
-        const outcome = await runGatedShell(spec.command ?? "", session.toolContext);
-        if (!outcome.approved) {
-            logger.print(theme.muted(outcome.rejection ?? "command denied by the user"));
-            return;
-        }
-        const e = outcome.exec;
-        if (e.timedOut) {
-            logger.print(theme.warning("timed out"));
-            return;
-        }
-        if (e.spawnError !== undefined) {
-            logger.print(theme.danger(e.spawnError));
-            return;
-        }
-        logger.print(`exit code ${e.exitCode ?? e.signal ?? "unknown"}\n${e.output}`);
-    }
-    catch (err) {
-        printReplError(err);
-    }
-}
-/**
- * Render a non-fatal error inline (classified + formatted, the same 4-part
- * shape as the fatal boundary) and return to the prompt — the REPL must survive
- * a failed turn rather than exit.
- */
-function printReplError(err) {
-    const cruxy = fromUnknown(err);
-    logger.print(formatError(cruxy, {
-        verbose: isVerbose(),
-        color: shouldUseColor(process.stdout),
-    }));
-}
-/**
- * `/add-root <name> <path>` (C.26 step 5) — an explicit, human-only way to
- * declare another workspace root. This is a REPL command, NOT a model tool: the
- * model can only reach the tool registry, and nothing named `add_root` is
- * registered there, so the allowlist argument is unchanged. It validates the
- * addition (TTY-only; same existence/name/overlap refusal as `--root`) and, on
- * success, tells the user to relaunch with `--root` to activate it — a
- * mid-session hot-swap would leave the checkpoint gate + hook router (both wired
- * from the session-start workspace) half-attributed, so activation is deferred
- * to a clean relaunch. A newly declared root always starts untrusted.
- */
-async function handleAddRoot(input, session) {
-    const parts = input
-        .slice("/add-root".length)
-        .trim()
-        .split(/\s+/)
-        .filter(Boolean);
-    if (parts.length !== 2) {
-        logger.print(theme.muted("usage: /add-root <name> <path>"));
-        return;
-    }
-    const [name, rootPath] = parts;
-    const ctx = session.toolContext;
-    const current = ctx.workspace;
-    try {
-        const next = await addRootToWorkspace(current, { name, path: rootPath }, { cwd: ctx.cwd, tty: Boolean(process.stdin.isTTY) });
-        const abs = next.rootByName(name).absPath;
-        logger.print(theme.muted(`validated root "${name}" (${abs}). relaunch with \`--root ${name}=${rootPath}\` to activate it — ` +
-            `it starts untrusted (its hooks and project memory stay inert until you run \`cruxy hooks/memory trust\`).`));
-    }
-    catch (err) {
-        printReplError(err);
-    }
-}
 /**
  * Service any background-job approvals that piled up (C.28) — the auto-surface
  * point. Called when the foreground is idle (between turns), so a paused job's
- * gated action is decided through the SAME U.3 prompt as a foreground one, one at
- * a time. No pending → a no-op (nothing printed). The job resumes on approval.
+ * gated action is decided through the SAME U.3 prompt as a foreground one, one
+ * at a time. No pending → a no-op (nothing printed). The job resumes on approval.
  */
 async function drainJobApprovals(session) {
     const jobs = session.jobs;
@@ -171,78 +116,6 @@ async function drainJobApprovals(session) {
     logger.print(theme.muted(`\n${theme.glyph.bullet} a background job needs your approval:`));
     await jobs.serviceApprovals();
 }
-/** Render the background-job list (`/jobs`). */
-function handleJobsList(session) {
-    const jobs = session.jobs;
-    if (!jobs) {
-        logger.print(theme.muted("background jobs are disabled — enable with `cruxy config set jobs.enabled true`"));
-        return;
-    }
-    const list = jobs.list();
-    if (list.length === 0) {
-        logger.print(theme.muted("no background jobs this session"));
-        return;
-    }
-    for (const j of list) {
-        const status = j.status === "failed" ? theme.danger(j.status) : theme.accent(j.status);
-        const pending = j.pendingApproval
-            ? theme.muted(` — needs approval: ${j.pendingApproval}`)
-            : "";
-        const err = j.error ? theme.muted(` (${j.error})`) : "";
-        // Fit id-first so the job id + status always survive; the label/notes tail
-        // truncates with an honest ellipsis at narrow width (U.12).
-        logger.print(fitOut(`${theme.strong(j.id)}  ${status}  ${j.label}${pending}${err}`));
-    }
-}
-/** Print one job's log (`/logs <id>`). */
-function handleJobLogs(input, session) {
-    const jobs = session.jobs;
-    if (!jobs) {
-        logger.print(theme.muted("background jobs are disabled"));
-        return;
-    }
-    const id = input.slice("/logs".length).trim();
-    if (!id) {
-        logger.print(theme.muted("usage: /logs <id>"));
-        return;
-    }
-    try {
-        const log = jobs.logs(id);
-        if (log.dropped > 0) {
-            logger.print(theme.muted(`… ${log.dropped} earlier line(s) rolled off`));
-        }
-        for (const line of log.lines) {
-            const text = line.stream === "err" ? theme.danger(line.text) : line.text;
-            logger.print(fitOut(text));
-        }
-        logger.print(theme.muted(`(${log.status})`));
-    }
-    catch (err) {
-        printReplError(err);
-    }
-}
-/** Cancel a job (`/cancel <id>`). */
-async function handleJobCancel(input, session) {
-    const jobs = session.jobs;
-    if (!jobs) {
-        logger.print(theme.muted("background jobs are disabled"));
-        return;
-    }
-    const id = input.slice("/cancel".length).trim();
-    if (!id) {
-        logger.print(theme.muted("usage: /cancel <id>"));
-        return;
-    }
-    try {
-        const cancelled = jobs.cancel(id);
-        logger.print(theme.muted(cancelled
-            ? `cancelling ${id} (its process tree is killed; any checkpoint survives for rollback)`
-            : `${id} is already finished`));
-    }
-    catch (err) {
-        printReplError(err);
-    }
-}
 /**
  * Drive an interactive multi-turn session: prompt, read a line, dispatch slash
  * commands or run a turn, repeat. Assistant text and tool-call progress stream
@@ -279,80 +152,25 @@ async function replLoop(session, io, renderer, checkpoints, slashCommands = [])
         const trimmed = line.trim();
         if (trimmed === "")
             continue; // empty line → reprompt, no model call
-        if (trimmed === "/exit" || trimmed === "/quit") {
-            logger.print(theme.muted("bye"));
-            return;
-        }
-        if (trimmed === "/clear") {
-            session.clear();
-            logger.print(theme.muted("history cleared"));
-            continue;
-        }
-        if (trimmed === "/compact") {
-            try {
-                const n = await session.compact();
-                logger.print(theme.muted(n ? `compacted ${n} older messages` : "nothing to compact yet"));
-            }
-            catch (err) {
-                printReplError(err);
-            }
-            continue;
-        }
-        if (trimmed === "/reload") {
-            const loaded = session.reloadProjectInstructions();
-            logger.print(theme.muted(loaded
-                ? "reloaded project instructions (CRUXY.md)"
-                : "no project instructions found"));
-            continue;
-        }
-        if (trimmed === "/plan") {
-            session.setPlanMode(!session.getPlanMode());
-            const on = session.getPlanMode();
-            logger.print(theme.muted(on
-                ? "plan mode on — the next prompt proposes a plan for approval"
-                : "plan mode off"));
-            continue;
-        }
         if (trimmed === "/help") {
             logger.print(HELP);
             continue;
         }
-        if (trimmed === "/jobs") {
-            handleJobsList(session);
-            continue;
-        }
-        if (trimmed === "/logs" || trimmed.startsWith("/logs ")) {
-            handleJobLogs(trimmed, session);
-            continue;
-        }
-        if (trimmed === "/cancel" || trimmed.startsWith("/cancel ")) {
-            await handleJobCancel(trimmed, session);
-            continue;
-        }
-        if (trimmed === "/add-root" || trimmed.startsWith("/add-root ")) {
-            await handleAddRoot(trimmed, session);
-            continue;
-        }
-        // Custom slash commands (C.19) — consulted AFTER builtins, so a custom
-        // command can never shadow /help, /exit, etc. A `prompt` command expands to
-        // text fed to the agent (safe); a `shell` command runs through the SAME
-        // gate + sandbox as any command (never a bypass). Unknown "/…" input falls
-        // through to a normal turn, preserving prior behavior.
-        const slash = resolveSlash(trimmed, slashCommands);
-        if (slash.kind === "prompt") {
-            try {
-                checkpoints?.beginRun(slash.prompt);
-                await session.send(slash.prompt, renderer);
-            }
-            catch (err) {
-                printReplError(err);
-            }
-            continue;
+        // Every other command is the SHARED implementation (P5 track 5) — the same
+        // one the TUI dispatches through, so the two shells cannot drift again.
+        const outcome = await dispatchCommand(line, {
+            session,
+            out: replOutput,
+            slashCommands,
+            tty: Boolean(process.stdin.isTTY),
+            pick: replPicker,
+        });
+        if (outcome.kind === "exit") {
+            logger.print(theme.muted("bye"));
+            return;
         }
-        if (slash.kind === "shell") {
-            await runSlashShell(slash.spec, session);
+        if (outcome.kind === "handled")
             continue;
-        }
         // A real turn. Assistant text streams through the renderer delta by delta
         // (leading blank lines trimmed, code fences highlighted); the agent loop
         // closes each segment with one newline, so the next prompt lands on its own
@@ -361,11 +179,11 @@ async function replLoop(session, io, renderer, checkpoints, slashCommands = [])
         try {
             // Each REPL turn is its own undo unit (C.32): a fresh checkpoint latch,
             // so `cruxy rollback` reverts exactly one turn's mutations.
-            checkpoints?.beginRun(trimmed);
-            await session.send(line, renderer);
+            checkpoints?.beginRun(outcome.text);
+            await session.send(outcome.text, renderer);
         }
         catch (err) {
-            logger.error(err.message);
+            printCommandError(replOutput, err);
         }
     }
 }