mulmoterminal 2.5.2 → 2.6.0

package/README.md

@@ -24,7 +24,7 @@ color-coded so you see at a glance which are **working**, which **need you**, an
 ping to your phone when a task finishes. One `npx` command, no Electron, no config.
 
 ```bash
-npx mulmoterminal        # starts on http://localhost:34567 and opens your browser
+npx mulmoterminal@latest        # starts on http://localhost:34567 and opens your browser
 ```
 
 > **Something looks wrong?** Type `/mulmoterminal-bug-report` in any MulmoTerminal session. The
@@ -146,17 +146,17 @@ Needs **Node ≥ 22.9**, plus these CLIs on your `PATH`:
 
 The server starts without any of the non-required rows; you just lose that row's feature,
 and the header/panel for it says so. `git` and `gh` are marked required because losing them
-costs whole views rather than one button. `npx mulmoterminal init` (below) reports which of
+costs whole views rather than one button. `npx mulmoterminal@latest init` (below) reports which of
 these it can find.
 
 ```bash
-npx mulmoterminal           # start on http://localhost:34567 and open the browser
+npx mulmoterminal@latest           # start on http://localhost:34567 and open the browser
 # or install globally:
 npm install -g mulmoterminal
 mulmoterminal
 ```
 
-**First-run setup (optional).** `npx mulmoterminal init` checks your environment (Node ≥ 22.9
+**First-run setup (optional).** `npx mulmoterminal@latest init` checks your environment (Node ≥ 22.9
 and every CLI in the table above), seeds the launcher's **directory
 presets** from the projects in your Claude Code history, and writes `~/.mulmoterminal/config.json`.
 It's **idempotent** — re-run it any time to refresh the presets; it overwrites the managed parts
@@ -166,7 +166,7 @@ and keeps your other settings. When `claude` is installed it can hand off to the
 **Google account (optional).** Link a Google account to enable the chat's `google` tool and the
 phone's `google.calendar.*` commands: read/create events on any calendar (not just your primary),
 list the calendars you've subscribed to, and read the colour palettes. Sign in from
-**Settings → Google account**, or run `npx mulmoterminal google login` — the CLI is the fallback
+**Settings → Google account**, or run `npx mulmoterminal@latest google login` — the CLI is the fallback
 for when you're driving MulmoTerminal from another machine, since consent finishes on a loopback
 listener and needs a browser **on the host**. Either way it needs a Desktop OAuth client JSON saved
 as `~/.secrets/client_secret_*.json`; the refresh token lands in `~/.config/mulmo/google-token.json`
@@ -200,11 +200,11 @@ directory you run the command from), `--port <n>` (default 34567), `--no-open`,
 `--version`, `--help`.
 
 ```bash
-npx mulmoterminal --cwd ./my-project   # work in a specific directory
+npx mulmoterminal@latest --cwd ./my-project   # work in a specific directory
 ```
 
 The published package ships the server (run via `tsx`) plus the pre-built web UI;
-`npx mulmoterminal` checks for the `claude` CLI, picks a free port, starts the
+`npx mulmoterminal@latest` checks for the `claude` CLI, picks a free port, starts the
 server, and opens the browser. For local development from a clone, see
 [Running](#running).
 
@@ -426,7 +426,7 @@ Requires **Node ≥ 22.9** (uses `node --env-file-if-exists`) and the `claude` C
 ## Configuration
 
 The server is configured entirely through environment variables, optionally
-loaded from a `.env` file. `npx mulmoterminal` reads the `.env` **in the
+loaded from a `.env` file. `npx mulmoterminal@latest` reads the `.env` **in the
 directory you run it from**; the npm scripts read the one in the repo root. The
 `.env` is optional — every variable below has a default, so the server runs
 without one.
@@ -441,7 +441,7 @@ the `claude` / `codex` sessions themselves.
 | `PORT`        | `34567`        | Backend HTTP/WebSocket port (prod: the URL you open). |
 | `CLIENT_PORT` | `6856`         | Vite dev-server port (dev only: the URL you open with `yarn dev`). |
 | `CLAUDE_BIN` | `claude`       | The Claude Code binary to spawn. On Windows a bare name is resolved on `PATH` before it reaches the PTY layer (which matches file names exactly): to the `.exe` when there is one, otherwise to the `.cmd` shim an npm-global install leaves, run through `cmd.exe`. |
-| `CLAUDE_CWD` | current dir    | Working directory each `claude` PTY runs in; determines which project's sessions the sidebar lists. Via `npx mulmoterminal` it defaults to the directory you ran the command from (override with `--cwd <dir>`, relative allowed); when the server is run directly it falls back to `~/mulmoclaude`. A value read from `.env` must be an absolute path (`~` is not expanded). |
+| `CLAUDE_CWD` | current dir    | Working directory each `claude` PTY runs in; determines which project's sessions the sidebar lists. Via `npx mulmoterminal@latest` it defaults to the directory you ran the command from (override with `--cwd <dir>`, relative allowed); when the server is run directly it falls back to `~/mulmoclaude`. A value read from `.env` must be an absolute path (`~` is not expanded). |
 | `CLAUDE_PERMISSION_MODE` | `auto` | Permission mode passed to each `claude` spawn. |
 | `MT_TITLE_MODEL` | `haiku` | Model used for the cell header's AI title (a cheap/fast model summarizing the recent turns). Accepts a `--model` alias or a full model id. |
 | `CODEX_BIN`  | `codex`        | The Codex CLI binary to spawn. |
@@ -488,6 +488,7 @@ The Settings modal (⚙) persists per-user UI choices to `~/.mulmoterminal/confi
 | `worklogIntervalHours` | Worklog cadence in hours (default `6`, clamped to `1`–`168`). |
 | `terminalSubmit` | Which bytes Claude reads as **submit** vs **newline**: `"cr"` (default — Enter submits, Shift+Enter makes a newline) or `"esc-cr"` (for a Claude Code rebound the other way). Applies to the keyboard **and** the phone remote-view submit, for **Claude sessions only** (shell/codex keep plain Enter). See the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#terminal-submit). |
 | `copyOnSelect` | `true` puts a **mouse selection on the clipboard the moment it settles**, with no key pressed (the PuTTY / iTerm2 behaviour). **Off by default** — it changes the clipboard when you may only have meant to highlight something. No Settings UI: edit the file and reload the tab. Composes with the `copy` keymap action rather than replacing it. Over plain `http://` the browser gives a page no clipboard access, so a fallback asks xterm to copy instead; see the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#copy-on-select). |
+| `decisionDigest` | Keep a **Markdown digest of the decisions this project's sessions asked for**, refreshed at startup and every few hours, so an agent can read what has already been decided before asking something similar. Written to `~/.mulmoterminal/decisions/<project>.md` (never into your repository) and served to agents by the bundled `mulmoterminal-decisions` skill. **Off by default** — it is a vision-stage idea, and it writes a file that would otherwise not exist. The digest holds dated facts, never inferred rules. |
 | `issueWorkComments` | Let a cell **comment on the issue it is working on**: once when it starts, and again when its PR merges (closing the issue if GitHub has not already). The comment names the working **directory** it happened in — the folder name only, never the path — so a reader can tell which clone. **Off by default**; it writes to GitHub, often on somebody else's issue. Needs `gh` logged in. See the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#issue-work-comments). |
 | `prWorkdirFooter` | Ends a PR body with `work in <clone>` — the directory name of the clone the work happened in, so a PR says which of several side-by-side checkouts produced it. Applies to **both** paths that open PRs here: **⧉ Open PR** appends it to the PR it creates, and every Claude session is told to end the bodies it writes with the same line (the name is resolved by the server, so a session inside a managed worktree still names the main checkout). **On by default**; set `false` to opt out — read per PR and per session spawn, so no restart is needed (there is no Settings control for it). Appending is idempotent: an existing PR never gets a second copy. |
 | `fontFamily` | The **terminal font** every session renders in — a CSS font-family stack, e.g. `"'Cica', 'MS Gothic', monospace"`. No Settings UI: edit the file, then **restart** (this config is read once at startup). Unset uses the built-in stack (JetBrains Mono / Fira Code / Menlo / Consolas, then CJK faces for Japanese, Korean and Chinese). Unlike the per-browser font **size**, this is one value for the whole host — it names fonts, and which fonts exist is a property of the machine. A directory can override it. See the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#font-family). |
@@ -1145,6 +1146,7 @@ same-origin-guarded.
 | `GET /api/transcript/timeline?session=&cwd=` | Per-session activity timeline (tools run). |
 | `GET /api/transcript/last-turn?session=&cwd=&agent=` | A session's last completed exchange (`prompt`, `reply`) plus the `text` to paste into another terminal. `agent=codex` reads the codex rollout instead of the Claude transcript. |
 | `GET /api/decisions?cwd=&limit=` | The decisions a human was asked to make in this project, newest first — each question with the options it offered, their descriptions, and the answer. `answerKind` says whether the answer was one of the options, text the user wrote instead (the question was wrong), or never given. Read out of Claude's own transcripts; writes nothing. `scanned` reports how many transcripts were read (the scan is capped) and `unreadable` how many could not be, so a partial answer is visible rather than implied. A `cwd` that is not an existing directory answers an empty response rather than falling back to the default workspace. |
+| `GET /api/decisions/digest?cwd=` | The same decisions as Markdown, for an agent to read (`{ enabled, markdown }`). `enabled: false` means the `decisionDigest` setting is off — a different answer from an empty digest, so a reader can tell "switched off" from "nothing decided here". |
 
 **Git & worktrees**
 
@@ -1469,7 +1471,7 @@ server/
   mcp/            per-session MCP broker
   backends/       wiki, collections, feeds, accounting, notifier,
                   translation, whisper, remote-host, html, files
-  skills/         bundled skills (mulmoterminal-config, mulmoterminal-bug-report)
+  skills/         bundled skills (mulmoterminal-config, mulmoterminal-bug-report, mulmoterminal-decisions)
   fix-pty-perms.js              postinstall: fixes node-pty binary permissions
 src/
   App.vue                       Layout; owns the active session + single/grid view

package/bin/mulmoterminal.js

@@ -155,7 +155,10 @@ async function runInit(initArgs) {
     return;
   }
   if (hasClaude) log("Later: run `claude` in any project and use  /mulmoterminal-config");
-  log("Setup done. Start MulmoTerminal:  npx mulmoterminal");
+  // Pinned to @latest: an unpinned `npx` reuses whatever it already has cached, so the very
+  // command printed for someone to type next would start an older version than the one they
+  // just set up with.
+  log("Setup done. Start MulmoTerminal:  npx mulmoterminal@latest");
 }
 
 // `npx mulmoterminal google <command>` — Google account linking. Consent needs a

package/common/keymap.ts

@@ -37,7 +37,21 @@ export const isKeymapAction = (value: unknown): value is KeymapAction => typeof
 //     ^C. A handler that has already swallowed the key cannot change its mind.
 export const TERMINAL_SCOPED_ACTIONS: readonly KeymapAction[] = ["copy", "paste"];
 
-export type Keymap = Partial<Record<KeymapAction, string>>;
+// A key that puts BYTES into the focused terminal instead of running an app action (#1005) —
+// Cmd+Right as Ctrl+E for end-of-line, say, or Alt+B for word-back.
+//
+// A LIST, where every action above is a single field, because the two are shaped differently:
+// an action is one behaviour that a key is pointed at, while every send binding carries its own
+// payload. `{ "send": "\u0005" }` could only ever name one key.
+//
+// `bytes` goes to the PTY verbatim. Control characters are written the way JSON writes them
+// (`"\u0005"` is Ctrl+E); nothing here interprets or re-escapes them.
+export interface SendBinding {
+  key: string;
+  bytes: string;
+}
+
+export type Keymap = Partial<Record<KeymapAction, string>> & { send?: SendBinding[] };
 
 // A parsed binding. `key` is matched against `KeyboardEvent.key` exactly as the browser
 // reports it, so it is case-sensitive for printable characters ("a" and "A" differ, the
@@ -108,6 +122,26 @@ export function actionForKey(keymap: Keymap, e: KeymapKeyEvent): KeymapAction |
   return null;
 }
 
+const isSendBinding = (value: unknown): value is SendBinding =>
+  typeof value === "object" && value !== null && typeof (value as SendBinding).key === "string" && typeof (value as SendBinding).bytes === "string";
+
+// The bytes this keydown should put into the terminal, or null when it is not a send binding.
+//
+// Only reachable for keys the GRID did not claim: its handler listens on `window` in the capture
+// phase and calls stopPropagation(), so an action and a send binding on one keystroke is not a
+// race — the action always wins and the send silently never fires. validateKeymap warns about it
+// for that reason.
+//
+// First match wins, so a keystroke listed twice uses the earlier entry.
+export function sendBytesFor(keymap: Keymap, e: KeymapKeyEvent & { type: string; isComposing?: boolean }): string | null {
+  if (e.type !== "keydown" || e.isComposing) return null;
+  for (const entry of keymap.send ?? []) {
+    const binding = parseKeyBinding(entry.key);
+    if (binding && matchesBinding(binding, e)) return entry.bytes;
+  }
+  return null;
+}
+
 // What is wrong with one `keymap` entry. `fatal` separates a typo the user clearly meant to
 // work (a binding we cannot parse — the shortcut would silently never fire) from an action
 // name we simply do not know, which is what a config written for a NEWER version looks like
@@ -127,38 +161,74 @@ export function validateKeymap(input: unknown): KeymapProblem[] {
     return [{ action: "keymap", binding: input, reason: "`keymap` must be an object of action -> key binding", fatal: true }];
   }
   const entries = Object.entries(input as Record<string, unknown>);
-  const bound = new Map<string, { action: KeymapAction; binding: string }[]>();
+  // A claim on one keystroke. `rank` is DISPATCH order, so the winner can be named: every action
+  // outranks every send binding, because the grid's handler runs in the capture phase and stops
+  // the event before the terminal — see sendBytesFor.
+  const bound = new Map<string, Claim[]>();
+  const claim = (parsed: KeyBinding, entry: Claim): void => {
+    const key = canonicalBinding(parsed); // as PARSED: "Shift+PageUp" and "shift+pageup" are one keystroke
+    bound.set(key, [...(bound.get(key) ?? []), entry]);
+  };
   const problems = entries.flatMap(([action, binding]): KeymapProblem[] => {
+    if (action === "send") return sendProblems(binding, claim);
     if (!isKeymapAction(action)) {
-      return [{ action, binding, reason: `unknown action (known: ${KEYMAP_ACTIONS.join(", ")})`, fatal: false }];
+      return [{ action, binding, reason: `unknown action (known: ${KEYMAP_ACTIONS.join(", ")}, send)`, fatal: false }];
     }
     if (typeof binding !== "string") return [{ action, binding, reason: "binding must be a string", fatal: true }];
     const parsed = parseKeyBinding(binding);
     if (parsed === null) {
       return [{ action, binding, reason: 'unparseable key binding — expected e.g. "PageDown" or "Shift+PageUp"', fatal: true }];
     }
-    // Grouped as PARSED, since "Shift+PageUp" and "shift+pageup" are one keystroke.
-    const key = canonicalBinding(parsed);
-    bound.set(key, [...(bound.get(key) ?? []), { action, binding }]);
+    claim(parsed, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action) });
     return [];
   });
   return [...problems, ...duplicateWarnings(bound)];
 }
 
-// Two actions on one keystroke: only one can fire, so the others silently never work.
+interface Claim {
+  label: string;
+  binding: string;
+  rank: number;
+}
+
+// Everything wrong with the `send` list, claiming the keystrokes that are well-formed.
+//
+// Fatal throughout, for the reason the module header gives: a send binding is invisible until
+// the key is pressed, so a dropped one is indistinguishable from a shortcut that "doesn't work".
+// Empty `bytes` is fatal too — it would take the key away from the terminal and put nothing back.
+function sendProblems(input: unknown, claim: (parsed: KeyBinding, entry: Claim) => void): KeymapProblem[] {
+  if (!Array.isArray(input)) {
+    return [{ action: "send", binding: input, reason: "`send` must be an array of { key, bytes }", fatal: true }];
+  }
+  return input.flatMap((entry, i): KeymapProblem[] => {
+    const label = `send[${i}]`;
+    if (!isSendBinding(entry)) return [{ action: label, binding: entry, reason: "expected { key: string, bytes: string }", fatal: true }];
+    const parsed = parseKeyBinding(entry.key);
+    if (parsed === null) {
+      return [{ action: label, binding: entry.key, reason: 'unparseable key binding — expected e.g. "Cmd+ArrowRight"', fatal: true }];
+    }
+    if (entry.bytes === "") {
+      return [{ action: label, binding: entry.key, reason: "`bytes` is empty — the key would be taken from the terminal and nothing sent", fatal: true }];
+    }
+    // Ranked after every action, matching who actually wins (see the `bound` comment above).
+    claim(parsed, { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i });
+    return [];
+  });
+}
+
+// Two claims on one keystroke: only one can fire, so the others silently never work.
 //
-// The winner is decided the way `actionForKey` decides it — first in KEYMAP_ACTIONS order —
-// NOT by which came first in the config file. Reporting the config-order winner would name
-// the wrong action whenever the two orders disagree, which is worse than not naming one.
-function duplicateWarnings(bound: Map<string, { action: KeymapAction; binding: string }[]>): KeymapProblem[] {
+// The winner is the one DISPATCH picks, not the one written first in the config file. Reporting
+// the config-order winner would name the wrong entry whenever the two orders disagree, which is
+// worse than not naming one.
+function duplicateWarnings(bound: Map<string, Claim[]>): KeymapProblem[] {
   return [...bound.values()].flatMap((claims) => {
     if (claims.length < 2) return [];
-    const byDispatch = [...claims].sort((a, b) => KEYMAP_ACTIONS.indexOf(a.action) - KEYMAP_ACTIONS.indexOf(b.action));
-    const [winner, ...losers] = byDispatch;
-    return losers.map(({ action, binding }) => ({
-      action,
+    const [winner, ...losers] = [...claims].sort((a, b) => a.rank - b.rank);
+    return losers.map(({ label, binding }) => ({
+      action: label,
       binding,
-      reason: `same keystroke as \`${winner.action}\` — only \`${winner.action}\` will fire`,
+      reason: `same keystroke as \`${winner.label}\` — only \`${winner.label}\` will fire`,
       fatal: false,
     }));
   });
@@ -172,8 +242,16 @@ const canonicalBinding = (b: KeyBinding): string => `${b.shift ? "S" : ""}${b.al
 // rest of the config treats one bad entry.
 export function sanitizeKeymap(input: unknown): Keymap {
   if (typeof input !== "object" || input === null || Array.isArray(input)) return {};
-  const entries = Object.entries(input as Record<string, unknown>).filter(
+  const raw = input as Record<string, unknown>;
+  const entries = Object.entries(raw).filter(
     (entry): entry is [KeymapAction, string] => isKeymapAction(entry[0]) && typeof entry[1] === "string" && parseKeyBinding(entry[1]) !== null,
   );
-  return Object.fromEntries(entries);
+  const send = sanitizeSendBindings(raw.send);
+  return { ...Object.fromEntries(entries), ...(send.length ? { send } : {}) };
 }
+
+// An entry survives only if it names a parseable key AND carries bytes to send. An empty `send`
+// is dropped entirely rather than kept as `[]`, so an absent and an emptied list look the same
+// to everything downstream.
+const sanitizeSendBindings = (input: unknown): SendBinding[] =>
+  Array.isArray(input) ? input.filter(isSendBinding).filter((entry) => entry.bytes !== "" && parseKeyBinding(entry.key) !== null) : [];

package/common/prPhase.ts

@@ -20,9 +20,19 @@ export interface WorkItem {
   prUrl: string | null;
   issue: number | null;
   issueUrl: string | null;
+  // Titles, for the surfaces that have room for words rather than a number — the phone's session
+  // list above all, where "#987" alone says nothing about which request is running (#1014).
+  prTitle: string | null;
+  issueTitle: string | null;
 }
 
-export const EMPTY_WORK_ITEM: Readonly<WorkItem> = { phase: "none", pr: null, prUrl: null, issue: null, issueUrl: null };
+export const EMPTY_WORK_ITEM: Readonly<WorkItem> = { phase: "none", pr: null, prUrl: null, issue: null, issueUrl: null, prTitle: null, issueTitle: null };
+
+// One line for a surface with room for one: what the work is FOR beats what was done about it, so
+// the issue's title wins when there is one. Null when neither side has a title to show.
+export function workItemHeadline(item: WorkItem): string | null {
+  return item.issueTitle ?? item.prTitle ?? null;
+}
 
 // GitHub's closing keywords, as GitHub itself matches them: any of these, then optional
 // whitespace/colon, then #N. Anything else in the body is a mention, not a link — a PR that

package/common/toolGroups.ts

@@ -0,0 +1,98 @@
+// The GUI MCP is served at one URL per GROUP of tools, so a user can turn a subset on for a
+// directory with Claude Code's own per-folder MCP config (`.mcp.json` / `claude mcp add -s
+// local`) instead of a MulmoTerminal setting. `.mcp.json` only switches whole SERVERS on and
+// off — splitting the URL is what turns that into tool granularity.
+//
+// These names appear in the URL path AND in the server id users write in their own config
+// (`mulmoterminal-<group>`), so they are effectively public API: renaming one breaks every
+// config already written against it.
+
+// The groups, ordered by how much damage a call can do.
+//   render   — draws into the Canvas panel and stops there. No side effect outside it.
+//   data     — reads/writes the workspace's structured data (collections, accounting).
+//   media    — generation that is slow, costly, and lands files on disk.
+//   external — reaches a third-party account or API.
+export const TOOL_GROUPS = ["render", "data", "media", "external"] as const;
+
+export type ToolGroup = (typeof TOOL_GROUPS)[number];
+
+export const isToolGroup = (value: unknown): value is ToolGroup => TOOL_GROUPS.some((group) => group === value);
+
+// The groups the Canvas pane is made of. The launcher offers a switch per group, the panel's
+// availability is decided by them, and the server routes on them — named here rather than
+// written as `"render"` / `"media"` at each of those sites, so a rename cannot leave one of them
+// silently pointing at a group that no longer exists.
+//
+// `media` is in because its tools DRAW: generateImage and presentMulmoScript land in the same
+// panel a render tool does. It is a separate switch rather than part of one because the two
+// differ in what a call costs — render stops at the pane, media is slow, paid and writes files —
+// and that is exactly the line the grouping exists to draw. Neither media tool is in
+// AUTO_ALLOWED_TOOLS, so enabling the group still leaves Claude Code's permission prompt in
+// front of the spend (same reasoning as presentDocument below).
+export const CANVAS_TOOL_GROUPS: readonly ToolGroup[] = ["render", "media"];
+
+// Does a session/directory reach the Canvas at all? Asked of the group list the server reports,
+// whose members arrive as plain strings — validated rather than cast, since an unknown name from
+// a newer server must not count as a canvas group.
+export const hasCanvasGroup = (groups: unknown): boolean =>
+  Array.isArray(groups) && groups.some((group) => isToolGroup(group) && CANVAS_TOOL_GROUPS.includes(group));
+
+// Which group each GUI tool belongs to.
+//
+// A tool that is absent belongs to NO group and is therefore reachable only through the
+// all-tools URL (`/api/mcp/:sessionId`, the single view). That is the deliberate failure
+// mode: forgetting to classify a newly added plugin withholds it from the group URLs rather
+// than leaking it into one — the map can go stale, but only ever closed.
+//
+// `spawnBackgroundChat` is absent ON PURPOSE, not by omission: it starts another session,
+// which is neither drawing, data, media, nor an external call, and a grid cell has no
+// business doing it silently.
+// A Map, not a plain object — the same reason the plugin dispatch map is one: object index
+// access reads through the prototype chain, so `constructor` / `__proto__` / `toString` would
+// resolve to an Object.prototype member and report a truthy "group". Map.get only ever returns
+// own entries.
+const GROUP_BY_TOOL = new Map<string, ToolGroup>([
+  ["presentDocument", "render"],
+  ["presentForm", "render"],
+  ["presentChart", "render"],
+  ["presentHtml", "render"],
+
+  // presentCollection RENDERS, but it renders collection data and only makes sense next to
+  // manageCollection — a cell offered the view without the store gets a tool it cannot fill.
+  ["presentCollection", "data"],
+  ["manageCollection", "data"],
+  ["manageAccounting", "data"],
+
+  ["generateImage", "media"],
+  ["presentMulmoScript", "media"],
+
+  ["google", "external"],
+  ["readXPost", "external"],
+  ["searchX", "external"],
+]);
+
+export const groupOfTool = (toolName: string): ToolGroup | null => GROUP_BY_TOOL.get(toolName) ?? null;
+
+// Every tool in a group, in the order declared above. The Canvas panel's empty state names them,
+// so a tool added to a group here reaches that list without a second edit — the list had been
+// written out by hand and named two of the four.
+export const toolsInGroup = (group: ToolGroup): string[] => [...GROUP_BY_TOOL].filter(([, g]) => g === group).map(([name]) => name);
+
+// The MCP server id a group is expected to be registered under. `--allowedTools` matches on
+// `mcp__<server id>__<tool>`, and the id comes from the USER's config key — so this is a
+// convention the enable-it-for-this-folder affordance has to write, and a user who registers
+// the same URL under another name simply gets permission prompts (nothing breaks).
+export const toolGroupServerId = (group: ToolGroup): string => `mulmoterminal-${group}`;
+
+// The tools MulmoTerminal pre-approves via `--allowedTools`, so they run without a permission
+// prompt. A list of TOOLS, not of groups: a group says which tools a directory can reach, and
+// that is not the same question as which may run unattended.
+//
+// `presentDocument` is the case that forces them apart, and it is deliberately ABSENT. Its
+// execute runs `fillImages` before saving, which resolves every image placeholder in the
+// markdown through the image backend — a PAID generation call. Auto-allowing it would let a
+// model spend money silently under a switch the UI presents as "let the agent draw", so it
+// keeps Claude Code's prompt (answer it once per project and the prompt stops).
+//
+// The three below save an artifact and draw it, and call nothing external.
+export const AUTO_ALLOWED_TOOLS: readonly string[] = ["presentForm", "presentChart", "presentHtml"];

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-CFwKVB03.js → abnfDiagram-VRR7QNED-RjiYivmv-2UuooAL1.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-Brzfja-q-ch1VcTiG.js";import{_ as n,g as r}from"./mermaid-parser.core-DxEa8E3F-DvKDRZGq.js";import"./chunk-WYO6CB5R-BlzOfotS-DenoOpP3.js";import"./chunk-VAUOI2AC-CS9QJ4yz-r_1UiH65.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-DDn-QIzL.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};
+import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-Brzfja-q-ch1VcTiG.js";import{_ as n,g as r}from"./mermaid-parser.core-DxEa8E3F-3f1dQMCy.js";import"./chunk-WYO6CB5R-BlzOfotS-cPQQuq_p.js";import"./chunk-VAUOI2AC-CS9QJ4yz-xhVI0AT_.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-DvOpObYg.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};

package/dist/assets/architecture-TIHT7OUA-0NsD2xW1-BgkdTJQE.js

@@ -0,0 +1 @@
+import{f as e}from"./mermaid-parser.core-DxEa8E3F-3f1dQMCy.js";export{e as createArchitectureServices};