chainlesschain 0.162.158 → 0.162.159

package/src/repl/bg-dashboard.js

@@ -0,0 +1,355 @@
+/**
+ * Background-agent dashboard — the interactive agent view behind
+ * `cc daemon view` (no id). Claude-Code `claude agents` parity: one live panel
+ * over every background session with grouping (Needs input / Working /
+ * Completed / Failed / Stopped), peek + reply, attach hand-off, stop, rename,
+ * pin, filter, and new-task dispatch.
+ *
+ * Design:
+ * - Pure model/render layer (`groupKey`, `buildDashboardModel`,
+ *   `renderDashboard`) — deterministic, unit-tested with injected `now`.
+ * - `runBgDashboard(deps)` controller — every effect (list/stop/rename/pin/
+ *   attach/dispatch/log/prompt IO) is an injected dep so tests drive it with
+ *   fakes; the command layer wires the real supervisor.
+ * - Raw ANSI on the alternate screen buffer (no TUI framework dependency);
+ *   line-input actions (reply/rename/dispatch) temporarily leave the alt
+ *   screen for a plain readline prompt, then re-enter.
+ */
+
+import chalk from "chalk";
+
+export const GROUP_ORDER = [
+  "needs-input",
+  "working",
+  "completed",
+  "failed",
+  "stopped",
+];
+
+export const GROUP_TITLES = {
+  "needs-input": "Needs input",
+  working: "Working",
+  completed: "Completed",
+  failed: "Failed",
+  stopped: "Stopped",
+};
+
+/**
+ * Group a session: running+idle phase = waiting for a follow-up (the closest
+ * analog of "needs input" — the worker finished a turn and a client can
+ * reply); running+turn = working; lost workers count as failed.
+ */
+export function groupKey(session) {
+  const status = session?.status;
+  if (status === "running") {
+    return session.phase === "idle" ? "needs-input" : "working";
+  }
+  if (status === "completed") return "completed";
+  if (status === "stopped") return "stopped";
+  return "failed"; // failed | lost | unknown
+}
+
+function formatAge(ms) {
+  const n = Math.max(0, Math.round(Number(ms || 0) / 1000));
+  if (n < 60) return `${n}s`;
+  const m = Math.floor(n / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60 ? `${m % 60}m` : ""}`;
+}
+
+export const FILTERS = ["all", "active", "needs-input"];
+
+function passesFilter(session, filter) {
+  if (filter === "active") return session.status === "running";
+  if (filter === "needs-input") return groupKey(session) === "needs-input";
+  return true;
+}
+
+/**
+ * Build the render model: grouped rows (pinned first inside each group,
+ * then newest first) plus a flat selection list in display order.
+ */
+export function buildDashboardModel(sessions, options = {}) {
+  const filter = options.filter || "all";
+  const now = typeof options.now === "number" ? options.now : Date.now();
+  const byGroup = new Map(GROUP_ORDER.map((k) => [k, []]));
+  for (const s of sessions || []) {
+    if (!s || !passesFilter(s, filter)) continue;
+    byGroup.get(groupKey(s))?.push(s);
+  }
+  for (const list of byGroup.values()) {
+    list.sort(
+      (a, b) =>
+        (b.pinned === true) - (a.pinned === true) ||
+        (b.startedAt || 0) - (a.startedAt || 0),
+    );
+  }
+  const groups = GROUP_ORDER.map((key) => ({
+    key,
+    title: GROUP_TITLES[key],
+    rows: byGroup.get(key) || [],
+  })).filter((g) => g.rows.length > 0);
+  const flat = groups.flatMap((g) => g.rows);
+  return { groups, flat, filter, now };
+}
+
+function rowLine(session, { selected, now }) {
+  const elapsed = session.endedAt
+    ? session.endedAt - session.startedAt
+    : now - session.startedAt;
+  const pin = session.pinned ? chalk.yellow("★ ") : "  ";
+  const marker = selected ? chalk.cyan("❯ ") : "  ";
+  const id = String(session.id || "").padEnd(24);
+  const title = session.title ? ` ${session.title}` : "";
+  const pr = session.pr?.number
+    ? chalk.magenta(
+        `  #${session.pr.number}${session.pr.state ? ` ${session.pr.state}` : ""}`,
+      )
+    : "";
+  const approvals = Number(session.pendingApprovals)
+    ? chalk.yellow(`  ⏳${session.pendingApprovals}`)
+    : "";
+  const ws = session.worktree || session.cwd || "";
+  const line = `${marker}${pin}${id} ${formatAge(elapsed).padStart(5)}  ${chalk.gray(ws)}${title}${pr}${approvals}`;
+  return selected ? chalk.bold(line) : line;
+}
+
+/**
+ * Render the dashboard to a string (no cursor positioning — the controller
+ * clears and repaints the alt screen).
+ */
+export function renderDashboard(model, options = {}) {
+  const selectedIndex = options.selectedIndex ?? 0;
+  const lines = [];
+  const total = model.flat.length;
+  lines.push(
+    chalk.bold("  Background agents") +
+      chalk.gray(
+        `  ${total} shown · filter: ${model.filter}` +
+          (options.message ? `  — ${options.message}` : ""),
+      ),
+  );
+  lines.push("");
+  if (total === 0) {
+    lines.push(chalk.gray("  No background agents match this filter."));
+    lines.push(
+      chalk.gray('  Press "d" to dispatch a new background task, "q" to quit.'),
+    );
+  }
+  let index = 0;
+  for (const group of model.groups) {
+    lines.push(chalk.bold(`  ${group.title} (${group.rows.length})`));
+    for (const session of group.rows) {
+      lines.push(
+        rowLine(session, { selected: index === selectedIndex, now: model.now }),
+      );
+      index++;
+    }
+    lines.push("");
+  }
+  if (options.peek) {
+    lines.push(chalk.bold(`  Peek: ${options.peek.id}`));
+    const text = (options.peek.log || "").trimEnd();
+    for (const l of text ? text.split("\n").slice(-15) : ["(no output)"]) {
+      lines.push(chalk.gray(`  │ ${l}`));
+    }
+    lines.push("");
+  }
+  lines.push(
+    chalk.gray(
+      "  ↑/↓ select · enter peek · r reply · a attach · s stop · n rename · x pin · d dispatch · f filter · q quit",
+    ),
+  );
+  return lines.join("\n");
+}
+
+const ESC = "\x1b";
+const ALT_ENTER = `${ESC}[?1049h${ESC}[?25l`;
+const ALT_EXIT = `${ESC}[?25h${ESC}[?1049l`;
+const CLEAR = `${ESC}[2J${ESC}[H`;
+
+/** Default terminal IO — swapped for a fake in tests. */
+export function defaultDashboardIo() {
+  return {
+    isTTY: Boolean(process.stdout.isTTY && process.stdin.isTTY),
+    write: (s) => process.stdout.write(s),
+    enterAlt: () => process.stdout.write(ALT_ENTER),
+    exitAlt: () => process.stdout.write(ALT_EXIT),
+    clear: () => process.stdout.write(CLEAR),
+    setRaw: (on) => {
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(on);
+      }
+    },
+    async listenKeys(onKey) {
+      const readline = await import("node:readline");
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.resume();
+      const handler = (str, key) => onKey(str, key || {});
+      process.stdin.on("keypress", handler);
+      return () => process.stdin.off("keypress", handler);
+    },
+    async promptLine(question) {
+      const readline = await import("node:readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      try {
+        return await new Promise((resolve) => rl.question(question, resolve));
+      } finally {
+        rl.close();
+      }
+    },
+  };
+}
+
+/**
+ * Interactive dashboard loop. All effects come from deps:
+ *   listAgents() → session[]           readLog(id, lines) → string
+ *   stopAgent(id)                      renameAgent(id, title)
+ *   pinAgent(id, pinned)               replyAgent(session, text)
+ *   attachAgent(session)               dispatchAgent(text)
+ *   io — see defaultDashboardIo()      refreshMs, now — timing seams
+ */
+export async function runBgDashboard(deps = {}) {
+  const io = deps.io || defaultDashboardIo();
+  const now = deps.now || (() => Date.now());
+  const refreshMs = deps.refreshMs ?? 2000;
+  const listAgents = deps.listAgents || (() => []);
+
+  let selected = 0;
+  let filterIndex = 0;
+  let peek = null;
+  let message = "";
+  let model = buildDashboardModel(listAgents(), {
+    filter: FILTERS[filterIndex],
+    now: now(),
+  });
+
+  const render = () => {
+    model = buildDashboardModel(listAgents(), {
+      filter: FILTERS[filterIndex],
+      now: now(),
+    });
+    if (selected >= model.flat.length)
+      selected = Math.max(0, model.flat.length - 1);
+    if (peek && !model.flat.some((s) => s.id === peek.id)) peek = null;
+    io.clear();
+    io.write(
+      renderDashboard(model, { selectedIndex: selected, peek, message }) + "\n",
+    );
+  };
+
+  const selectedSession = () => model.flat[selected] || null;
+
+  // Line-input actions leave the alt screen so readline behaves normally.
+  const promptOutside = async (question) => {
+    io.setRaw(false);
+    io.exitAlt();
+    try {
+      return await io.promptLine(question);
+    } finally {
+      io.enterAlt();
+      io.setRaw(true);
+    }
+  };
+
+  io.enterAlt();
+  io.setRaw(true);
+  const timer = setInterval(render, refreshMs);
+  timer.unref?.();
+  render();
+
+  let stopListening = () => {};
+  await new Promise((resolve) => {
+    const finish = () => resolve();
+    const onKey = async (str, key) => {
+      const name = key?.name || str;
+      const ctrlC = key?.ctrl && key.name === "c";
+      message = "";
+      try {
+        if (ctrlC || name === "q") return finish();
+        if (name === "down" || name === "j") {
+          selected = Math.min(model.flat.length - 1, selected + 1);
+        } else if (name === "up" || name === "k") {
+          selected = Math.max(0, selected - 1);
+        } else if (name === "return" || name === "p") {
+          const s = selectedSession();
+          peek =
+            s && peek?.id !== s.id
+              ? { id: s.id, log: deps.readLog ? deps.readLog(s.id, 15) : "" }
+              : null;
+        } else if (name === "f") {
+          filterIndex = (filterIndex + 1) % FILTERS.length;
+          selected = 0;
+        } else if (name === "x") {
+          const s = selectedSession();
+          if (s && deps.pinAgent) {
+            deps.pinAgent(s.id, s.pinned !== true);
+            message = s.pinned ? `unpinned ${s.id}` : `pinned ${s.id}`;
+          }
+        } else if (name === "s") {
+          const s = selectedSession();
+          if (s && deps.stopAgent) {
+            deps.stopAgent(s.id);
+            message = `stopped ${s.id}`;
+          }
+        } else if (name === "n") {
+          const s = selectedSession();
+          if (s && deps.renameAgent) {
+            const title = await promptOutside(`New title for ${s.id}: `);
+            if (title && title.trim()) {
+              deps.renameAgent(s.id, title.trim());
+              message = `renamed ${s.id}`;
+            }
+          }
+        } else if (name === "r") {
+          const s = selectedSession();
+          if (s && deps.replyAgent) {
+            const text = await promptOutside(`Reply to ${s.id}: `);
+            if (text && text.trim()) {
+              await deps.replyAgent(s, text.trim());
+              message = `sent to ${s.id}`;
+            }
+          }
+        } else if (name === "d") {
+          if (deps.dispatchAgent) {
+            const text = await promptOutside("New background task: ");
+            if (text && text.trim()) {
+              const id = await deps.dispatchAgent(text.trim());
+              message = id ? `dispatched ${id}` : "dispatched";
+            }
+          }
+        } else if (name === "a") {
+          const s = selectedSession();
+          if (s && deps.attachAgent) {
+            // Hand the terminal over to attach, then come back.
+            io.setRaw(false);
+            io.exitAlt();
+            stopListening();
+            try {
+              await deps.attachAgent(s);
+            } finally {
+              io.enterAlt();
+              io.setRaw(true);
+              stopListening = (await io.listenKeys(onKey)) || (() => {});
+            }
+          }
+        }
+      } catch (err) {
+        message = `error: ${err.message}`;
+      }
+      render();
+    };
+    io.listenKeys(onKey).then((stop) => {
+      stopListening = stop || (() => {});
+    });
+  });
+
+  clearInterval(timer);
+  stopListening();
+  io.setRaw(false);
+  io.exitAlt();
+}

package/src/repl/fast-mode.js

@@ -0,0 +1,103 @@
+/**
+ * Fast mode — latency profile for the agent REPL (gap-2026-07-11 P2#12).
+ *
+ * Claude Code's `/fast` binds Opus fast mode. cc is multi-provider, so "fast"
+ * is generalized to a latency profile the provider adapter applies to the next
+ * turn:
+ *   - drop extended thinking / shrink the reasoning budget (biggest latency win
+ *     and provider-agnostic),
+ *   - optionally swap to the provider's designated low-latency model — but only
+ *     when the user has NOT pinned a model this session (never override an
+ *     explicit choice), and always announce it,
+ *   - surface the cost/quality tradeoff so the user knows what they traded.
+ *
+ * Pure core (command parse, fast-model table, plan resolution, status/tradeoff
+ * rendering). The `/fast` controller in agent-repl owns turn state + config
+ * persistence (`cli.fastMode`).
+ */
+
+/** Provider → designated low-latency model. Only well-known ones. */
+export const KNOWN_FAST_MODELS = Object.freeze({
+  anthropic: "claude-haiku-4-5-20251001",
+  openai: "gpt-4o-mini",
+  deepseek: "deepseek-chat",
+  dashscope: "qwen-turbo",
+  mistral: "mistral-small-latest",
+  gemini: "gemini-2.0-flash",
+});
+
+export const FAST_TRADEOFF =
+  "Faster + cheaper, but lower reasoning depth — turn it off for hard/multi-step work.";
+
+/**
+ * Parse `/fast [on|off|status|toggle]`. Returns null when the input is not a
+ * `/fast` command, `{ error }` for a bad arg, else `{ action }`. Bare `/fast`
+ * toggles. Pure.
+ */
+export function parseFastCommand(input) {
+  const t = String(input || "").trim();
+  if (t !== "/fast" && !t.startsWith("/fast ")) return null;
+  const arg = t.slice("/fast".length).trim().toLowerCase();
+  if (!arg) return { action: "toggle" };
+  if (["on", "enable", "1"].includes(arg)) return { action: "on" };
+  if (["off", "disable", "0"].includes(arg)) return { action: "off" };
+  if (["status", "state"].includes(arg)) return { action: "status" };
+  if (arg === "toggle") return { action: "toggle" };
+  return { error: `Unknown /fast option "${arg}". Use: on | off | status` };
+}
+
+/**
+ * Resolve the effect of the current fast-mode state on the next turn.
+ * @param {object} o { enabled, provider, model, modelPinned }
+ *   modelPinned = the user chose the model this session (`/model x`), so we must
+ *   not swap it.
+ * @returns {{ enabled, thinking, model, swapped, note, tradeoff }}
+ * When disabled, returns the inputs unchanged with thinking left null (caller
+ * keeps its own thinking state). Pure.
+ */
+export function resolveFastPlan({
+  enabled = false,
+  provider = "",
+  model = "",
+  modelPinned = false,
+} = {}) {
+  if (!enabled) {
+    return {
+      enabled: false,
+      thinking: null,
+      model,
+      swapped: false,
+      note: "",
+      tradeoff: "",
+    };
+  }
+  const fast = KNOWN_FAST_MODELS[String(provider).toLowerCase()];
+  const canSwap = Boolean(fast) && !modelPinned && fast !== model;
+  const nextModel = canSwap ? fast : model;
+  let note;
+  if (canSwap) {
+    note = `Fast mode: low-latency model ${nextModel}, reasoning minimized.`;
+  } else if (modelPinned) {
+    note = `Fast mode: reasoning minimized (keeping your pinned model ${model}).`;
+  } else {
+    note = "Fast mode: reasoning minimized.";
+  }
+  return {
+    enabled: true,
+    thinking: "off",
+    model: nextModel,
+    swapped: canSwap,
+    note,
+    tradeoff: FAST_TRADEOFF,
+  };
+}
+
+/** Render a `/fast status` line. Pure. */
+export function renderFastStatus({ enabled, provider, model } = {}) {
+  if (!enabled) {
+    return "Fast mode: off. /fast on for a low-latency profile.";
+  }
+  const fast = KNOWN_FAST_MODELS[String(provider).toLowerCase()];
+  const modelBit = fast ? ` fast model: ${fast};` : "";
+  return `Fast mode: on —${modelBit} reasoning minimized. ${FAST_TRADEOFF}`;
+}

package/src/repl/fullscreen-tui.js

@@ -0,0 +1,197 @@
+/**
+ * Fullscreen / no-flicker TUI helpers (gap-2026-07-11 P1#10).
+ *
+ * cc's REPL streams to the scrollback buffer with chalk. On long conversations
+ * that scrollback grows without bound and every repaint re-emits the whole
+ * screen, which flickers and jumps. Claude Code's fullscreen renderer fixes
+ * this with the alternate screen buffer + a windowed, diff-based repaint:
+ *
+ *   - `/tui fullscreen` enters the alternate screen buffer (`?1049h`), so the
+ *     user's scrollback is preserved and the view is a fixed window.
+ *   - only the messages that fit the viewport are painted; older ones move to
+ *     "transcript mode" (searchable, scrollable) instead of re-emitting.
+ *   - repaints diff against the previously painted lines and rewrite only the
+ *     rows that changed — no full clear, so no flicker.
+ *   - `CC_NO_FLICKER=1` forces fullscreen on at startup.
+ *
+ * This module is the pure, testable core (mode resolution, alt-screen escape
+ * sequences, message windowing, diff repaint, transcript search, OSC-8
+ * hyperlinks). The controller (a thin `/tui` handler in agent-repl) owns the
+ * TTY writes and config persistence.
+ */
+
+const ESC = "\x1b";
+
+export const TUI_MODES = Object.freeze(["default", "fullscreen"]);
+export const DEFAULT_TUI_MODE = "default";
+
+/** Alternate screen buffer control sequences. */
+export const ALT_SCREEN_ENTER = `${ESC}[?1049h${ESC}[H`;
+export const ALT_SCREEN_LEAVE = `${ESC}[?1049l`;
+export const HIDE_CURSOR = `${ESC}[?25l`;
+export const SHOW_CURSOR = `${ESC}[?25h`;
+
+/**
+ * Resolve the effective TUI mode. Precedence:
+ *   explicit arg > CC_NO_FLICKER env > persisted setting > default.
+ * `CC_NO_FLICKER=1` forces fullscreen and cannot be overridden by the setting,
+ * but an explicit `/tui default` this session still wins (arg is highest).
+ * Returns a canonical mode name; unknown args fall through to the next source.
+ * Pure.
+ */
+export function resolveTuiMode({
+  arg = null,
+  env = false,
+  setting = null,
+} = {}) {
+  const canon = (v) => {
+    const n = String(v || "")
+      .toLowerCase()
+      .trim();
+    return TUI_MODES.includes(n) ? n : null;
+  };
+  const fromArg = canon(arg);
+  if (fromArg) return fromArg;
+  if (envNoFlicker(env)) return "fullscreen";
+  const fromSetting = canon(setting);
+  if (fromSetting) return fromSetting;
+  return DEFAULT_TUI_MODE;
+}
+
+/** Whether a CC_NO_FLICKER-style value means "on". Pure. */
+export function envNoFlicker(value) {
+  const n = String(value == null ? "" : value)
+    .toLowerCase()
+    .trim();
+  return n === "1" || n === "true" || n === "on" || n === "yes";
+}
+
+/**
+ * Window a list of message lines to the visible viewport. Everything above the
+ * window is "in transcript" (hidden but searchable). The newest lines always
+ * stay visible (tail-anchored), leaving `reserveBottom` rows for the prompt.
+ * @param {string[]} lines  already-rendered transcript lines
+ * @param {object} opts { rows, reserveBottom }
+ * @returns {{ visible:string[], hiddenCount:number, firstVisible:number }}
+ * Pure.
+ */
+export function windowLines(lines, { rows = 24, reserveBottom = 2 } = {}) {
+  const all = Array.isArray(lines) ? lines : [];
+  const capacity = Math.max(1, rows - Math.max(0, reserveBottom));
+  if (all.length <= capacity) {
+    return { visible: all.slice(), hiddenCount: 0, firstVisible: 0 };
+  }
+  const firstVisible = all.length - capacity;
+  return {
+    visible: all.slice(firstVisible),
+    hiddenCount: firstVisible,
+    firstVisible,
+  };
+}
+
+/**
+ * Compute the minimal cursor-addressed repaint to turn `prev` lines into
+ * `next`. Only rows that differ are rewritten (no full-screen clear → no
+ * flicker). Rows that shrank get a clear-to-end-of-line. Returns the escape
+ * string to write; empty string when nothing changed.
+ *
+ * `origin` is the 1-based screen row where line 0 is painted.
+ * Pure.
+ */
+export function diffRepaint(prev, next, { origin = 1 } = {}) {
+  const a = Array.isArray(prev) ? prev : [];
+  const b = Array.isArray(next) ? next : [];
+  const max = Math.max(a.length, b.length);
+  let out = "";
+  for (let i = 0; i < max; i++) {
+    const before = a[i];
+    const after = b[i] ?? "";
+    if (before === after) continue;
+    const row = origin + i;
+    // Move to row start, clear the line, write the new content.
+    out += `${ESC}[${row};1H${ESC}[2K${after}`;
+  }
+  return out;
+}
+
+/**
+ * Search transcript messages for a query. Each message is `{role, text}`.
+ * Returns matches with the message index, a 0-based line offset within the
+ * message, and a trimmed snippet. Case-insensitive unless `caseSensitive`.
+ * Pure.
+ */
+export function searchTranscript(
+  messages,
+  query,
+  { caseSensitive = false } = {},
+) {
+  const q = String(query || "");
+  if (!q) return [];
+  const needle = caseSensitive ? q : q.toLowerCase();
+  const matches = [];
+  const msgs = Array.isArray(messages) ? messages : [];
+  for (let mi = 0; mi < msgs.length; mi++) {
+    const text = String(msgs[mi]?.text ?? "");
+    const lines = text.split("\n");
+    for (let li = 0; li < lines.length; li++) {
+      const hay = caseSensitive ? lines[li] : lines[li].toLowerCase();
+      const col = hay.indexOf(needle);
+      if (col >= 0) {
+        matches.push({
+          index: mi,
+          line: li,
+          column: col,
+          role: msgs[mi]?.role || "",
+          snippet: lines[li].trim().slice(0, 200),
+        });
+      }
+    }
+  }
+  return matches;
+}
+
+/**
+ * OSC-8 terminal hyperlink. When the terminal supports it, renders clickable
+ * `text` linking to `url`; otherwise degrades to `text (url)` (or just text
+ * when they're equal). Pure.
+ */
+export function formatHyperlink(text, url, { supported = true } = {}) {
+  const label = String(text ?? "");
+  const href = String(url ?? "");
+  if (!href) return label;
+  if (!supported) {
+    return label && label !== href ? `${label} (${href})` : href;
+  }
+  return `${ESC}]8;;${href}${ESC}\\${label || href}${ESC}]8;;${ESC}\\`;
+}
+
+/**
+ * Whether the environment likely supports OSC-8 hyperlinks. Conservative:
+ * honors FORCE_HYPERLINK / NO_HYPERLINK overrides, otherwise trusts known
+ * terminals. Pure over the passed env object.
+ */
+export function supportsHyperlinks(env = {}) {
+  if (envNoFlicker(env.FORCE_HYPERLINK)) return true;
+  if (env.NO_HYPERLINK != null && env.NO_HYPERLINK !== "") return false;
+  const term = String(env.TERM_PROGRAM || "").toLowerCase();
+  if (
+    term.includes("iterm") ||
+    term.includes("wezterm") ||
+    term.includes("vscode") ||
+    term.includes("hyper")
+  ) {
+    return true;
+  }
+  if (env.WT_SESSION) return true; // Windows Terminal
+  if (env.KITTY_WINDOW_ID) return true;
+  return false;
+}
+
+/** One-line status describing the current TUI mode. Pure. */
+export function renderTuiStatus(mode) {
+  const m = TUI_MODES.includes(mode) ? mode : DEFAULT_TUI_MODE;
+  if (m === "fullscreen") {
+    return "TUI: fullscreen (alternate screen, windowed no-flicker repaint). /tui default to exit.";
+  }
+  return "TUI: default (streaming scrollback). /tui fullscreen for a no-flicker window.";
+}

package/src/repl/slash-command-registry.js

@@ -35,7 +35,13 @@ export class SlashCommandRegistry {
   }
 
   getCommand(name) {
-    return this._commands.get(name);
+    const direct = this._commands.get(name);
+    if (direct) return direct;
+    // Alias resolution: a command registered with aliases answers to them too.
+    for (const cmd of this._commands.values()) {
+      if (cmd.aliases && cmd.aliases.includes(name)) return cmd;
+    }
+    return undefined;
   }
 
   getAllCommands() {
@@ -43,7 +49,7 @@ export class SlashCommandRegistry {
   }
 
   hasCommand(name) {
-    return this._commands.has(name);
+    return Boolean(this.getCommand(name));
   }
 
   _registerBuiltinCommands() {
@@ -188,8 +194,10 @@ export class SlashCommandRegistry {
       ],
     ];
 
+    // Claude-Code 2.1.205 parity: /checkup is an alias of /doctor.
+    const ALIASES = { "/doctor": ["/checkup"] };
     for (const [name, description, handler] of commands) {
-      this.register(name, { description, handler });
+      this.register(name, { description, handler, aliases: ALIASES[name] });
     }
   }
 }