@corenel/term 0.2.9 → 0.4.0

package/dist/{chunk-QZJTOVZL.js → chunk-HUVRQX53.js}

@@ -1,10 +1,13 @@
 import {
   emptyState,
   parseTodos
-} from "./chunk-L4KCEKIT.js";
+} from "./chunk-2MGDL3I4.js";
 import {
-  parseCommand
-} from "./chunk-VTJEWHM3.js";
+  formatHelpText,
+  isKnownCommandWord,
+  parseCommand,
+  unknownCommandMessage
+} from "./chunk-5RPHYXND.js";
 import {
   WRITE_TOOL_NAMES,
   buildWritePreview
@@ -24,6 +27,76 @@ import {
 import { runAgent } from "@corenel/harness/core/loop";
 import { priceUsageWith } from "@corenel/harness/core/pricing";
 
+// src/mcpText.ts
+function mcpStatusWord(v) {
+  if (v.error) return "unreachable";
+  if (!v.signedIn) return "sign-in needed";
+  if (v.connected) return "connected";
+  return "cached";
+}
+function ageWord(fetchedAt, now) {
+  if (fetchedAt === null) return "never fetched";
+  const ms = Math.max(0, now - fetchedAt);
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 1) return "fetched just now";
+  if (mins < 60) return `fetched ${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `fetched ${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `fetched ${days}d ago`;
+}
+function formatMcpServers(views, now) {
+  if (views.length === 0) {
+    return "No mcp servers configured. /mcp add <name> <url> to add one.";
+  }
+  const nameWidth = Math.max(...views.map((v) => v.name.length));
+  const statusWidth = Math.max(...views.map((v) => mcpStatusWord(v).length));
+  const lines = views.map((v) => {
+    const tools = `${v.toolCount} tool${v.toolCount === 1 ? "" : "s"}`;
+    const hosted = v.hosted ? "  hosted" : "";
+    const error = v.error ? `  (${v.error})` : "";
+    return `  ${v.name.padEnd(nameWidth)}  ${mcpStatusWord(v).padEnd(statusWidth)}  ${tools}, ${ageWord(v.fetchedAt, now)}${hosted}${error}`;
+  });
+  return [
+    `${views.length} mcp server${views.length === 1 ? "" : "s"} configured:`,
+    ...lines
+  ].join("\n");
+}
+
+// src/contextText.ts
+function fmtBytes(bytes) {
+  return `${Math.round(bytes / 1024)} KB`;
+}
+function formatContext(s) {
+  const lines = [];
+  if (s.sentTokens === null) {
+    lines.push("no model call has completed yet this conversation -- nothing sent to size.");
+  } else if (s.contextWindow === null) {
+    lines.push(`${s.sentTokens} tokens sent on the last model call -- context window unknown for this model.`);
+  } else {
+    const pct = Math.round(s.sentTokens / s.contextWindow * 100);
+    lines.push(`${s.sentTokens} / ${s.contextWindow} tokens (${pct}%) sent on the last model call.`);
+  }
+  lines.push("");
+  const loaded = s.loadedToolNames.length ? `, ${s.loadedToolNames.length} MCP tool${s.loadedToolNames.length === 1 ? "" : "s"} loaded (${s.loadedToolNames.join(", ")})` : "";
+  lines.push(`tools: ${s.toolCount} available${loaded}`);
+  lines.push("");
+  if (s.offloaded.length === 0) {
+    lines.push("offloaded: none");
+  } else {
+    lines.push(`offloaded (${s.offloaded.length}, recall with /expand):`);
+    for (const o of s.offloaded) lines.push(`  ${o.name}  ${fmtBytes(o.bytes)}`);
+  }
+  lines.push("");
+  if (s.checkpoints.length === 0) {
+    lines.push("compaction: none this conversation");
+  } else {
+    lines.push(`compaction seams (${s.checkpoints.length}):`);
+    for (const c of s.checkpoints) lines.push(`  ${c.collapsed} messages collapsed into a checkpoint`);
+  }
+  return lines.join("\n");
+}
+
 // src/markdown.ts
 var FENCE = /^```(\w*)\s*$/;
 var HEADING = /^(#{1,6})\s+(.*)$/;
@@ -83,34 +156,14 @@ function stripInline(s) {
 }
 
 // src/session.ts
-var HELP_TEXT = [
-  "Type a request and press enter.",
-  "",
-  "  /tools          what the agent can do, and what it can change",
-  "  /policy         how this session is governed -- levels, caps, and what actually confines it",
-  "  /expand #3      re-print a tool result in full (#3 is the id on its row)",
-  "  /resume [id]    reopen an earlier conversation",
-  "  /clear          forget the conversation",
-  "  /exit           leave",
-  "",
-  "  /mode [id]      switch the agent mode, or list what is configured",
-  "  /persona [id]   switch persona, or list what is configured",
-  "  /skill [name]   apply a skill to your NEXT message only, or list what is installed",
-  "  /strategy [name] run a saved strategy from .prompd/strategies, or list what is saved",
-  "",
-  /* Deliberately not 'esc stops a turn': this text is shared, and Escape is
-   * an Ink-only key -- the readline fallback has no key handler at all, so
-   * there Ctrl-C is the only way to stop a turn. Name the one that is true
-   * on both faces, and mark the other as what it is. */
-  "Ctrl-C stops a turn; twice leaves. Ctrl-D leaves. In the full terminal face, esc also stops a turn."
-].join("\n");
 var DELTA_FLUSH_MS = 50;
 var TOOL_DELTA_CAP = 4e3;
 var TermSession = class {
   constructor(deps) {
     this.deps = deps;
+    this.state = emptyState(deps.model);
   }
-  state = emptyState();
+  state;
   listeners = /* @__PURE__ */ new Set();
   nextOrd = 1;
   idSeq = 0;
@@ -176,6 +229,13 @@ var TermSession = class {
    * reach a renderer. */
   pendingSkill = null;
   wantsExit = false;
+  /** The last line that was WARNED ABOUT rather than sent, because its first
+   * word after `/` looked like a command but wasn't one -- see `submit`. Set
+   * on the warn, cleared the moment anything else happens (a different line,
+   * a real command, an empty line): only an EXACT resubmission of this same
+   * text counts as "I meant it, send it anyway". `null` means nothing is
+   * pending. */
+  lastRejectedLine = null;
   attachPermission(p) {
     this.permission = p;
   }
@@ -428,6 +488,11 @@ var TermSession = class {
       }
       case "offload":
         this.pendingOffload = { refId: e.id, bytes: e.bytes };
+        this.set({ offloaded: [...this.state.offloaded, { id: e.id, name: e.name, bytes: e.bytes }] });
+        break;
+      case "checkpoint":
+        this.note("info", `checkpoint  ${e.collapsed} messages collapsed into CHECKPOINT.md`);
+        this.set({ checkpoints: [...this.state.checkpoints, { collapsed: e.collapsed, checkpoint: e.checkpoint }] });
         break;
       case "permission":
       case "permission-audit":
@@ -459,9 +524,18 @@ var TermSession = class {
            * rates, and costUsd stays 0, which the face reads as "no cost to
            * show". Rates are read per event, not captured once, because the
            * host may still be hydrating them when the first turn runs. */
-          costUsd: this.state.costUsd + (priceUsageWith(e.usage, this.deps.rates?.() ?? null) ?? 0)
+          costUsd: this.state.costUsd + (priceUsageWith(e.usage, this.deps.rates?.() ?? null) ?? 0),
+          // `/context`'s fill answer: OVERWRITTEN, not accumulated like
+          // `usage`/`turnUsage` above -- this is "what's in the window right
+          // now" (the last call's prompt size), not a running total. The loop
+          // emits one `usage` event per model call, so the LAST one to land
+          // is always the most recent call, tool round-trips included.
+          sentTokens: e.usage.promptTokens
         });
         break;
+      case "tools-loaded":
+        this.set({ toolNames: e.names });
+        break;
       case "artifact":
         this.note("info", `artifact  ${e.kind}${e.title ? `  ${e.title}` : ""}`);
         break;
@@ -481,15 +555,63 @@ var TermSession = class {
         break;
     }
   }
-  /** Route one line: a command runs here; anything else is a turn. */
+  /** Whether calling `submit(text)` right now would warn-and-refuse rather
+   * than run a command or send a message -- i.e. `text`'s first word after a
+   * leading `/` looks like a command attempt but isn't one, AND this isn't
+   * already the resend of a line that was just warned about. PURE: does not
+   * touch `lastRejectedLine` or commit anything, so a caller can check it
+   * before deciding what to do with the input box (see ink/index.tsx's
+   * onSubmit, which must NOT clear the box for the line this reports true
+   * for) without racing `submit`'s own mutation of the same state. */
+  willReject(text) {
+    const line = text.trim();
+    if (!line || !line.startsWith("/")) return false;
+    if (parseCommand(line)) return false;
+    const word = line.slice(1).split(/\s+/)[0] ?? "";
+    if (!word || isKnownCommandWord(word)) return false;
+    return this.lastRejectedLine !== line;
+  }
+  /** Route one line: a command runs here; anything else is a turn -- UNLESS
+   * the first word after a leading `/` looks like a command attempt and
+   * isn't one (see commands.ts's `isKnownCommandWord`), in which case the
+   * FIRST Enter on that exact text warns and stops rather than paying for a
+   * model call on a typo (`/context` before Feature 2 added it, `/toosl`,
+   * `/hepl`, ...). A SECOND Enter on the identical, unchanged line is taken
+   * as "I meant it" and sent as an ordinary message -- tracked in
+   * `lastRejectedLine`, which both faces share automatically since it lives
+   * here rather than in either face's own state: the Ink face keeps the text
+   * in the input box (ink/index.tsx checks `willReject` before clearing it)
+   * so retyping Enter resubmits the SAME string; the readline face has no
+   * input box to hold onto, so there the "second Enter" is the user
+   * retyping the line themselves -- an honest equivalent, not a shortcut. */
   async submit(text) {
     const line = text.trim();
-    if (!line) return;
+    if (!line) {
+      this.lastRejectedLine = null;
+      return;
+    }
     const cmd = parseCommand(line);
     if (cmd) {
+      this.lastRejectedLine = null;
       await this.runCommand(cmd);
       return;
     }
+    if (line.startsWith("/")) {
+      const word = line.slice(1).split(/\s+/)[0] ?? "";
+      if (word && !isKnownCommandWord(word)) {
+        if (this.lastRejectedLine === line) {
+          this.lastRejectedLine = null;
+        } else {
+          this.lastRejectedLine = line;
+          this.note("warn", unknownCommandMessage(word));
+          return;
+        }
+      } else {
+        this.lastRejectedLine = null;
+      }
+    } else {
+      this.lastRejectedLine = null;
+    }
     await this.queueOrRun(line);
   }
   /** Run `line` as a turn now, or queue it, exactly like `submit` does for
@@ -522,7 +644,15 @@ var TermSession = class {
           // conversation's cost to this one.
           costUsd: 0,
           todos: [],
-          pendingSkill: null
+          pendingSkill: null,
+          // /context's accumulators are per-conversation facts (what was
+          // sent, what got offloaded, what got compacted) -- same reasoning
+          // as costUsd just above. `toolNames` (the MCP set) is NOT reset
+          // here: it describes what is currently LOADED, independent of the
+          // conversation that gets forgotten.
+          sentTokens: null,
+          offloaded: [],
+          checkpoints: []
         });
         if (droppedSkill) this.note("info", `cleared -- the armed skill "${droppedSkill.label}" was dropped too`);
         return;
@@ -537,8 +667,11 @@ var TermSession = class {
         }
         this.note("info", formatPolicy(this.deps.policy, this.deps.policySource, this.deps.tools));
         return;
+      case "context":
+        this.note("info", formatContext(this.contextSnapshot()));
+        return;
       case "help":
-        this.note("info", HELP_TEXT);
+        this.note("info", formatHelpText());
         return;
       case "expand": {
         if (cmd.ord === void 0) {
@@ -551,6 +684,9 @@ var TermSession = class {
       case "resume":
         await this.resume(cmd.id);
         return;
+      case "model":
+        await this.runModelCommand(cmd.id);
+        return;
       case "mode":
         await this.switchIdentity({
           kind: "mode",
@@ -573,6 +709,9 @@ var TermSession = class {
       case "strategy":
         await this.runStrategyCommand(cmd.id);
         return;
+      case "mcp":
+        await this.runMcpCommand(cmd.sub, cmd.args ?? [], cmd.unknown);
+        return;
     }
   }
   /** Runs a host-supplied config-workspace call (`listModes`, `listSkills`,
@@ -597,11 +736,17 @@ var TermSession = class {
       return { ok: false };
     }
   }
-  /** Shared `/mode` and `/persona` shape: no id lists what's configured, an
+  /** Shared `/mode`/`/persona` shape: no id lists what's configured, an
    * unknown id reports the valid options (never silently no-ops, never sends
-   * a typo through to the model), a real id applies immediately -- "applies"
-   * meaning `deps.system` will pick it up on the NEXT `resolveSystem()` call,
-   * not this instant (see the field docs on TermSessionDeps.system). */
+   * a typo through to the model), a real id applies immediately.
+   *
+   * "applies" means `deps.system` will pick it up on the NEXT
+   * `resolveSystem()` call, not this instant (see the field docs on
+   * TermSessionDeps.system) -- `opts.apply` (the host's `setMode`/
+   * `setPersona`) is the whole story there.
+   *
+   * `/model` does NOT go through here -- see `runModelCommand`: the model is
+   * fixed for a session, so there is nothing for it to apply. */
   async switchIdentity(opts) {
     if (!opts.list || !opts.apply) {
       this.note("warn", `/${opts.kind} is not available in this session`);
@@ -623,6 +768,36 @@ var TermSession = class {
     opts.apply(found.id);
     this.note("info", `${opts.kind} set to ${found.label} -- takes effect on your next message`);
   }
+  /** `/model` -- READ-ONLY. No id lists what's available (see `listModels`'s
+   * field doc for why); an id refuses rather than switching, because the
+   * model is fixed for the life of a session -- `resolveContextWindow(model)`
+   * runs once at launch and sizes rung-2 compaction from it, so a downward
+   * switch would leave compaction believing it has a bigger window than the
+   * model actually has and the conversation would meet the context wall as a
+   * fatal 400 instead of compacting in time. Changing the model requires
+   * reprocessing the session, which is not implemented (docs/BACKLOG.md
+   * section 5) -- the remedy is a restart with `--model <id>`, not this
+   * command. Routed through `safeCall` for the listing, same guard every
+   * other identity command uses. */
+  async runModelCommand(id) {
+    const list = this.deps.listModels;
+    if (!list) {
+      this.note("warn", "/model is not available in this session");
+      return;
+    }
+    const listed = await this.safeCall("model", list);
+    if (!listed.ok) return;
+    const entries = listed.value;
+    if (!id) {
+      const names = entries.map((e) => e.id).join(", ");
+      this.note("info", names ? `models: ${names}` : `models: not known here -- the catalogue is fetched, so this is empty offline or before it answers. This session is on ${this.deps.model} either way.`);
+      return;
+    }
+    this.note(
+      "warn",
+      `the model is fixed for a session -- its context window, compaction sizing and pricing are all derived from it at start, and switching it mid-session cannot be done safely. Restart with --model ${id} to use it.`
+    );
+  }
   async armSkillCommand(id) {
     if (!this.deps.listSkills || !this.deps.armSkill) {
       this.note("warn", "/skill is not available in this session");
@@ -681,6 +856,306 @@ var TermSession = class {
     this.note("info", `running strategy "${resolved.value.name}"`);
     await this.queueOrRun(resolved.value.prompt);
   }
+  /** Like `safeCall`, but for `/mcp`'s own host calls -- a SEPARATE wrapper,
+   * not a shared message, because the failure shape is different in kind.
+   * `safeCall`'s "not available -- could not read the config workspace"
+   * framing was written for `/mode`/`/persona`: there, a throw really does
+   * mean the config workspace itself is broken. An MCP host call throwing is
+   * usually something else entirely -- `McpAdmin`'s write methods
+   * (packages/cli/src/mcpAdmin.ts) return `Promise<void>` with no result
+   * channel, so a REFUSAL (a duplicate name, a daemon saying no, a failed
+   * sign-in) surfaces as a thrown Error too, indistinguishable by shape from
+   * a real transport failure. Telling the user the command is "not
+   * available" when it ran and was refused is actively wrong -- it says "try
+   * nothing" when the honest answer is "try something else, here is why this
+   * attempt didn't work". So this wrapper names the ACTION and reports the
+   * underlying reason verbatim, and leaves `safeCall` untouched for the four
+   * callers whose failure really is "could not read the config workspace". */
+  async safeMcpCall(action, fn) {
+    try {
+      return { ok: true, value: await fn() };
+    } catch (e) {
+      this.note("warn", `/mcp ${action} failed: ${e instanceof Error ? e.message : String(e)}`);
+      return { ok: false };
+    }
+  }
+  /** `/mcp` and its subcommands -- what is connected, and sign in or add one.
+   * `listMcpServers` gates the whole command, the same way `deps.policy` gates
+   * `/policy`: a host that wires none of the five deps reports `/mcp` itself
+   * unavailable rather than half-working. Each mutating subcommand ALSO checks
+   * its own specific dep, so a host that wires read-only `listMcpServers` still
+   * gets a working `/mcp list` instead of every subcommand failing alike.
+   *
+   * `unknown` carries a subcommand `parseCommand` did not recognize -- see
+   * commands.ts's `mcp` case. It is rejected BY NAME rather than aliased to
+   * `list` (a typo must never produce ordinary-looking output with nothing
+   * to say it was not understood) and rather than reaching here as `null`
+   * from the parser (which would send it to the model as a chat message --
+   * worse still: a silent misfire that LOOKS like an answer). */
+  async runMcpCommand(sub, args, unknown) {
+    const listMcpServers = this.deps.listMcpServers;
+    if (!listMcpServers) {
+      this.note("warn", "/mcp is not available in this session");
+      return;
+    }
+    if (unknown) {
+      this.note("warn", `unknown /mcp subcommand "${unknown}" -- try: list, add, remove, login, refresh, forget`);
+      return;
+    }
+    switch (sub ?? "list") {
+      case "list": {
+        const listed = await this.safeMcpCall("list", listMcpServers);
+        if (!listed.ok) return;
+        this.note("info", formatMcpServers(listed.value, Date.now()));
+        return;
+      }
+      case "add": {
+        const [name, url] = args;
+        if (!name || !url) {
+          this.note("warn", "usage: /mcp add <name> <url>");
+          return;
+        }
+        const addMcpServer = this.deps.addMcpServer;
+        if (!addMcpServer) {
+          this.note("warn", "/mcp add is not available in this session");
+          return;
+        }
+        const added = await this.safeMcpCall("add", () => addMcpServer(name, url));
+        if (!added.ok) return;
+        this.note("info", `added mcp server "${name}"`);
+        return;
+      }
+      case "remove": {
+        const [name] = args;
+        if (!name) {
+          this.note("warn", "usage: /mcp remove <name>");
+          return;
+        }
+        const removeMcpServer = this.deps.removeMcpServer;
+        if (!removeMcpServer) {
+          this.note("warn", "/mcp remove is not available in this session");
+          return;
+        }
+        const removed = await this.safeMcpCall("remove", () => removeMcpServer(name));
+        if (!removed.ok) return;
+        this.note("info", `removed mcp server "${name}"`);
+        return;
+      }
+      case "login": {
+        const [name] = args;
+        if (!name) {
+          this.note("warn", "usage: /mcp login <name>");
+          return;
+        }
+        const loginMcpServer = this.deps.loginMcpServer;
+        if (!loginMcpServer) {
+          this.note("warn", "/mcp login is not available in this session");
+          return;
+        }
+        const loggedIn = await this.safeMcpCall("login", () => loginMcpServer(name, (url) => this.note("info", `sign in at: ${url}`)));
+        if (!loggedIn.ok) return;
+        this.note("info", `signed in to "${name}"`);
+        return;
+      }
+      case "refresh": {
+        const [name] = args;
+        const refreshMcpServer = this.deps.refreshMcpServer;
+        if (!refreshMcpServer) {
+          this.note("warn", "/mcp refresh is not available in this session");
+          return;
+        }
+        const refreshed = await this.safeMcpCall("refresh", () => refreshMcpServer(name));
+        if (!refreshed.ok) return;
+        this.note("info", name ? `refreshed "${name}"` : "refreshed all mcp servers");
+        return;
+      }
+      case "forget": {
+        const [name] = args;
+        if (!name) {
+          this.note("warn", "usage: /mcp forget <name>");
+          return;
+        }
+        const forgetMcpServer = this.deps.forgetMcpServer;
+        if (!forgetMcpServer) {
+          this.note("warn", "/mcp forget is not available in this session");
+          return;
+        }
+        const forgotten = await this.safeMcpCall("forget", () => forgetMcpServer(name));
+        if (!forgotten.ok) return;
+        this.note("info", `forgot the client registration for "${name}" -- the next /mcp login will register afresh`);
+        return;
+      }
+    }
+  }
+  /* ---- the Ink `/mcp` manager overlay ------------------------------------
+   *
+   * Reachable ONLY from `packages/term/src/ink/index.tsx` -- the readline
+   * face keeps sending bare `/mcp` through `submit()` -> `runMcpCommand`'s
+   * `'list'` case exactly as before (it has no key handler to drive anything
+   * richer, and no code path here changes for it). These methods are a
+   * SEPARATE entry point the Ink face uses instead of `submit()` once the
+   * overlay is open, so it can move a selection and re-render without a
+   * round trip through command parsing -- but every mutating action still
+   * calls the exact same host deps (`removeMcpServer`, `loginMcpServer`,
+   * `listMcpServers`) that `runMcpCommand` above uses, so the overlay is
+   * presentation over that one dispatch, never a second implementation of
+   * it. `McpManager.servers` is a snapshot fetched here and re-fetched after
+   * a mutation succeeds -- the overlay itself caches nothing (see
+   * ink/McpOverlay.tsx). */
+  /** `/mcp` with no argument, from the Ink face only -- see the module doc
+   * above. Fetches the current servers and opens the manager. */
+  async openMcpManager() {
+    const listMcpServers = this.deps.listMcpServers;
+    if (!listMcpServers) {
+      this.note("warn", "/mcp is not available in this session");
+      return;
+    }
+    const listed = await this.safeMcpCall("list", listMcpServers);
+    if (!listed.ok) return;
+    this.set({ modal: { kind: "mcp", servers: listed.value, selected: 0, login: null } });
+  }
+  /** esc, or any other reason the overlay should close -- a no-op unless the
+   * manager is actually the modal open right now, so it can never steal a
+   * permission or question modal's close. */
+  closeMcpManager() {
+    if (this.state.modal?.kind === "mcp") this.set({ modal: null });
+  }
+  /* ---- the Ink `/help` overlay -------------------------------------------
+   *
+   * Same split as `/mcp` above: `ink/index.tsx` intercepts a bare `/help`
+   * before it reaches `submit()` and calls this instead; the readline face
+   * has no overlay to open, so its `/help` keeps going through `submit()` ->
+   * the `'help'` case in `runCommand` -> `note('info', formatHelpText())`,
+   * unchanged -- both that text and this overlay render from the same
+   * `TERM_COMMANDS` table (see commands.ts's `formatHelpText` and
+   * ink/HelpOverlay.tsx), never a hand-written copy either face could fall
+   * behind. This method needs no host dep and nothing to fetch -- opening it
+   * is just setting the modal. */
+  /** `/help` with no argument, from the Ink face only -- see the module doc
+   * above. */
+  openHelp() {
+    this.set({ modal: { kind: "help" } });
+  }
+  /** esc, or any other reason the overlay should close -- a no-op unless the
+   * help overlay is actually the modal open right now, so it can never steal
+   * a permission, question, or MCP modal's close. */
+  closeHelp() {
+    if (this.state.modal?.kind === "help") this.set({ modal: null });
+  }
+  /* ---- the Ink `/context` overlay ----------------------------------------
+   *
+   * Same split as `/help`/`/mcp` above: `ink/index.tsx` intercepts a bare
+   * `/context` before it reaches `submit()` and calls `openContext` instead;
+   * the readline face's `/context` keeps going through `submit()` -> the
+   * `'context'` case in `runCommand` -> `note('info', formatContext(...))`,
+   * unchanged. Unlike the MCP manager, there is nothing to FETCH here --
+   * every field `formatContext` needs already lives on `TuiState` (or is a
+   * host-supplied getter), kept current by `handleEvent`'s `usage`/
+   * `offload`/`checkpoint`/`tools-loaded` cases -- so opening the overlay is
+   * just setting the modal, and it stays live: a turn that lands while it is
+   * open updates the numbers the next time `App` re-renders, with no
+   * re-fetch and no re-open. */
+  /** The data `formatContext` (contextText.ts) needs, assembled from
+   * `TuiState`'s own accumulators and the two host-supplied static facts
+   * (`deps.tools.length`, `deps.contextWindow()`) -- called fresh by both
+   * `runCommand`'s `'context'` case and the Ink overlay's render, never
+   * cached, so neither face can show a stale window size after `/context`'s
+   * OWN state changes mid-turn. */
+  contextSnapshot() {
+    return {
+      sentTokens: this.state.sentTokens,
+      contextWindow: this.deps.contextWindow?.() ?? null,
+      offloaded: this.state.offloaded,
+      checkpoints: this.state.checkpoints,
+      toolCount: this.deps.tools.length,
+      loadedToolNames: this.state.toolNames
+    };
+  }
+  /** `/context` with no argument, from the Ink face only -- see the module
+   * doc above. Needs no host dep and nothing to fetch -- opening it is just
+   * setting the modal. */
+  openContext() {
+    this.set({ modal: { kind: "context" } });
+  }
+  /** esc, or any other reason the context overlay should close -- a no-op
+   * unless the context overlay is actually the modal open right now, so it
+   * can never steal a permission, question, help, or MCP modal's close. */
+  closeContext() {
+    if (this.state.modal?.kind === "context") this.set({ modal: null });
+  }
+  /** Up/down inside the overlay -- wraps, and does nothing with zero rows. */
+  moveMcpSelection(delta) {
+    const modal = this.state.modal;
+    if (modal?.kind !== "mcp" || modal.servers.length === 0) return;
+    const selected = (modal.selected + delta + modal.servers.length) % modal.servers.length;
+    this.set({ modal: { ...modal, selected } });
+  }
+  /** `x` inside the overlay -- removes the selected row via the same
+   * `removeMcpServer` dep `/mcp remove` uses, then refreshes the list. */
+  async removeMcpSelection() {
+    const modal = this.state.modal;
+    if (modal?.kind !== "mcp") return;
+    const server = modal.servers[modal.selected];
+    if (!server) return;
+    await this.runMcpCommand("remove", [server.name]);
+    await this.refreshMcpManager();
+  }
+  /** `l` inside the overlay -- signs the selected row in via the same
+   * `loginMcpServer` dep `/mcp login` uses. The consent URL genuinely
+   * arrives before the sign-in itself completes (a daemon message, or a
+   * synchronous callback locally), so `modal.login.url` is updated live as
+   * it arrives rather than buffered until the whole call resolves. */
+  async loginMcpSelection() {
+    const modal = this.state.modal;
+    if (modal?.kind !== "mcp" || modal.login) return;
+    const server = modal.servers[modal.selected];
+    if (!server) return;
+    const loginMcpServer = this.deps.loginMcpServer;
+    if (!loginMcpServer) {
+      this.note("warn", "/mcp login is not available in this session");
+      return;
+    }
+    this.set({ modal: { ...modal, login: { server: server.name, url: null } } });
+    const result = await this.safeMcpCall("login", () => loginMcpServer(server.name, (url) => {
+      const cur = this.state.modal;
+      if (cur?.kind === "mcp" && cur.login?.server === server.name) {
+        this.set({ modal: { ...cur, login: { server: server.name, url } } });
+      }
+    }));
+    const after = this.state.modal;
+    if (after?.kind !== "mcp") return;
+    this.set({ modal: { ...after, login: null } });
+    if (result.ok) {
+      this.note("info", `signed in to "${server.name}"`);
+      await this.refreshMcpManager();
+    }
+  }
+  /** `r` inside the overlay -- refreshes the selected row via the same
+   * `refreshMcpServer` dep `/mcp refresh` uses, then refreshes the list so
+   * the updated tool count and age show without the user reopening the
+   * overlay. Same shape as `removeMcpSelection` above. */
+  async refreshMcpSelection() {
+    const modal = this.state.modal;
+    if (modal?.kind !== "mcp") return;
+    const server = modal.servers[modal.selected];
+    if (!server) return;
+    await this.runMcpCommand("refresh", [server.name]);
+    await this.refreshMcpManager();
+  }
+  /** Re-fetches `listMcpServers` and replaces the overlay's snapshot,
+   * clamping the selection into range -- used after add/remove/login
+   * succeed so the overlay never shows a server list that mutation just
+   * made stale. */
+  async refreshMcpManager() {
+    const listMcpServers = this.deps.listMcpServers;
+    if (!listMcpServers) return;
+    const listed = await this.safeMcpCall("list", listMcpServers);
+    if (!listed.ok) return;
+    const cur = this.state.modal;
+    if (cur?.kind !== "mcp") return;
+    const selected = Math.min(cur.selected, Math.max(listed.value.length - 1, 0));
+    this.set({ modal: { ...cur, servers: listed.value, selected } });
+  }
   /** Save after the turn, never during: a half-written turn is a lie on disk. */
   async persist() {
     const p = this.deps.persistence;
@@ -797,6 +1272,7 @@ ${line}` : line;
         signal: ac.signal,
         ...this.permission ? { permission: this.permission } : {},
         ...this.deps.compression ? { compression: this.deps.compression } : {},
+        ...this.deps.compaction ? { compaction: this.deps.compaction } : {},
         onEvent: (e) => {
           if (this.activeTurn === mine) this.handleEvent(e);
         }
@@ -913,6 +1389,9 @@ ${line}` : line;
 };
 
 export {
+  mcpStatusWord,
+  ageWord,
+  formatContext,
   parseMarkdown,
   DELTA_FLUSH_MS,
   TOOL_DELTA_CAP,