mulmoterminal 2.5.1 → 2.5.3

package/README.md

@@ -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). |
@@ -1144,6 +1145,8 @@ same-origin-guarded.
 | `GET /api/cost?cwd=&session=` | Estimated $ cost — session / today / month. |
 | `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**
 
@@ -1468,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/common/decisionLog.ts

@@ -0,0 +1,49 @@
+// A decision a human was asked to make, as it was actually asked and answered.
+//
+// The record is not something this app writes: Claude Code already stores every
+// `AskUserQuestion` in its transcript, options and chosen answer included. These types are the
+// shape we read it back in, shared because both the API and the UI decide from them (#997).
+
+/** One option the user was offered, with the reasoning shown alongside it — this is where the
+ *  consequence of the branch NOT taken is recorded. */
+export interface DecisionOption {
+  label: string;
+  description: string;
+}
+
+/** Where the answer came from. `free-text` means the user declined every option and wrote their
+ *  own answer, which is evidence about the QUESTION (wrong options, or a premise the asker and
+ *  the user did not share) rather than about the choice. `unanswered` is a question that was
+ *  asked and never resolved — the session was interrupted or abandoned. */
+export type DecisionAnswerKind = "option" | "free-text" | "unanswered";
+
+export interface DecisionQuestion {
+  question: string;
+  /** The short chip the UI showed above the question ("進め方", "Auth method"). */
+  header: string;
+  multiSelect: boolean;
+  options: DecisionOption[];
+  /** Verbatim, exactly as it came back. Null when nothing came back. */
+  answer: string | null;
+  answerKind: DecisionAnswerKind;
+}
+
+/** One `AskUserQuestion` call: the questions it asked together, and what each got back. */
+export interface DecisionRecord {
+  sessionId: string;
+  cwd: string | null;
+  /** ISO timestamp of the turn that asked. */
+  ts: string;
+  toolUseId: string;
+  questions: DecisionQuestion[];
+}
+
+export interface DecisionsResponse {
+  decisions: DecisionRecord[];
+  /** How many transcripts were read successfully. Bounded, so a caller can tell a quiet project
+   *  from a truncated scan. */
+  scanned: number;
+  /** How many could not be read at all. Reported rather than folded into `scanned`, because a
+   *  read that failed is missing decisions — not a session that had none. */
+  unreadable: number;
+}

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/themeVars.ts

@@ -0,0 +1,134 @@
+// A custom theme's colours, and the rules that turn a user's `themes` entry into something the
+// app can paint with. Shared across the build boundary for the same reason THEME_COLOR_KEYS is
+// (see themeColors.ts): the server VALIDATES a config against these keys and the client APPLIES
+// it, so a key known to one side and not the other would be accepted and then silently ignored.
+
+import { THEME_IDS, type ThemeId } from "./themeIds.js";
+
+// The CSS custom properties one theme sets, mirroring the `:root[data-theme=...]` blocks in
+// src/style.css. A theme with no `extends` has to supply every one of them — a half-painted
+// theme is worse than none, because the missing half falls back to whatever the previous theme
+// left on the element.
+export const THEME_VAR_KEYS = [
+  "--bg-base",
+  "--bg-deep",
+  "--bg-panel",
+  "--bg-subtle",
+  "--bg-elevated",
+  "--bg-input",
+  "--bg-hover",
+  "--bg-selected",
+  "--bg-selected-hover",
+  "--border",
+  "--accent",
+  "--accent-bg",
+  "--accent-bg-hover",
+  "--on-accent",
+  "--text",
+  "--text-secondary",
+  "--text-muted",
+  "--text-dim",
+  "--term-fg",
+  "--term-selection",
+] as const;
+
+export type ThemeVarKey = (typeof THEME_VAR_KEYS)[number];
+export type ThemeVars = Record<ThemeVarKey, string>;
+
+/** An id a user may give a custom theme: lowercase, digits and dashes, so it is safe both as a
+ *  `data-theme` attribute value and as something to type into a `.mulmoterminal.json`. */
+export const CUSTOM_THEME_ID_RE = /^[a-z][a-z0-9-]{0,31}$/;
+
+/** Whether a value could name a theme — built-in OR user-defined.
+ *
+ *  The result is `string`, deliberately NOT `ThemeId`: that is the CLOSED set of four built-ins,
+ *  and a guard claiming it while custom ids flow through would let downstream code treat a
+ *  four-way switch as exhaustive (Codex review on #996). Membership is not checked here — the
+ *  server drops an id that resolves to nothing, and termThemeFor() resolves what survives. */
+export function isThemeIdLike(value: unknown): value is string {
+  return typeof value === "string" && CUSTOM_THEME_ID_RE.test(value);
+}
+
+export function isBuiltinThemeId(id: string): id is ThemeId {
+  return (THEME_IDS as readonly string[]).includes(id);
+}
+
+/** Whether an id may be used for a CUSTOM theme. Built-in ids are refused rather than merged
+ *  into: someone reading the guide's description of Midnight has to get Midnight. */
+export function isUsableCustomThemeId(id: unknown): id is string {
+  return typeof id === "string" && CUSTOM_THEME_ID_RE.test(id) && !isBuiltinThemeId(id);
+}
+
+export interface CustomThemeInput {
+  id: string;
+  label: string;
+  /** A built-in theme to start from. Omitted means `colors` must be complete. */
+  extends?: ThemeId;
+  colors: Partial<ThemeVars>;
+}
+
+/** The full variable set for a theme: the base it extends, with its own colours on top.
+ *  `builtins` supplies the base sets so this stays pure — the client reads them from the
+ *  stylesheet's source of truth, the specs from a fixture. */
+export function resolveThemeVars(theme: CustomThemeInput, builtins: Record<ThemeId, ThemeVars>): ThemeVars | null {
+  const base = theme.extends ? builtins[theme.extends] : null;
+  const merged = { ...(base ?? {}), ...theme.colors } as Partial<ThemeVars>;
+  const missing = THEME_VAR_KEYS.filter((key) => !merged[key]);
+  // No base and an incomplete list is the one case we cannot paint: report it rather than
+  // leaving the gaps to whatever the previously applied theme put on the element.
+  return missing.length ? null : (merged as ThemeVars);
+}
+
+function channel(hex: string, at: number): number {
+  const value = parseInt(hex.slice(at, at + 2), 16) / 255;
+  return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+}
+
+/** `#rgb` / `#rgba` / `#rrggbb` / `#rrggbbaa` as `#rrggbb`, or null. The config schema accepts
+ *  every one of those forms, so anything reading a colour has to expand the short ones — a
+ *  luminance check that understood only the six-digit form would read `#fff` as unmeasurable and
+ *  call a white theme dark (Codex review on #996).
+ *
+ *  Alpha is dropped rather than composited: what a translucent `--bg-base` ends up looking like
+ *  depends on what is behind it, which nothing here can know. The opaque colour is the closest
+ *  honest answer, and `--bg-base` is the one variable where translucency makes least sense. */
+export function normalizeHexColor(color: string): string | null {
+  const hex = color.trim().toLowerCase();
+  if (!/^#[0-9a-f]{3,8}$/.test(hex)) return null;
+  const digits = hex.slice(1);
+  if (digits.length === 3 || digits.length === 4) {
+    return `#${[...digits.slice(0, 3)].map((d) => d + d).join("")}`;
+  }
+  if (digits.length === 6 || digits.length === 8) return `#${digits.slice(0, 6)}`;
+  return null;
+}
+
+/** Relative luminance (WCAG) of any hex colour the config accepts. Null for anything else. */
+export function relativeLuminance(color: string): number | null {
+  const hex = normalizeHexColor(color);
+  if (!hex) return null;
+  return 0.2126 * channel(hex, 1) + 0.7152 * channel(hex, 3) + 0.0722 * channel(hex, 5);
+}
+
+// Above this, the chrome is treated as a light theme. The status pills (ok / warn / err) come in
+// a dark-background set and a light-background set, and picking the wrong one leaves them
+// unreadable — which is why this is derived rather than declared: a theme author who never
+// thinks about it still gets legible pills.
+const LIGHT_LUMINANCE_THRESHOLD = 0.4;
+
+export function isLightTheme(vars: ThemeVars): boolean {
+  const luminance = relativeLuminance(vars["--bg-base"]);
+  return luminance !== null && luminance > LIGHT_LUMINANCE_THRESHOLD;
+}
+
+/** The xterm palette a theme's variables imply. xterm draws on a canvas and cannot read CSS
+ *  variables, so the same colours have to reach it as values — derived here rather than asked
+ *  for twice, since two copies of one colour is two chances to change only one. The 16 ANSI
+ *  colours are NOT derived: they come from the base theme, which is what `extends` is for. */
+export function termThemeFromVars(vars: ThemeVars): { background: string; foreground: string; selectionBackground: string } {
+  return {
+    background: vars["--bg-base"],
+    foreground: vars["--term-fg"],
+    selectionBackground: vars["--term-selection"],
+  };
+}

package/common/toolGroups.ts

@@ -0,0 +1,80 @@
+// 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 group the Canvas pane is made of. The launcher switch registers it, the panel's
+// availability is decided by it, and the server routes on it — named here rather than written
+// as `"render"` at each of those sites, so a rename cannot leave one of them silently pointing
+// at a group that no longer exists.
+export const CANVAS_TOOL_GROUP: ToolGroup = "render";
+
+// 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;
+
+// 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-BHMJcX-D.js → abnfDiagram-VRR7QNED-RjiYivmv-CkfTvNiT.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-C43vNJPp.js";import"./chunk-WYO6CB5R-BlzOfotS-C6J_J8TJ.js";import"./chunk-VAUOI2AC-CS9QJ4yz-CDhJXpTw.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-xCxis4AD.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-CscC8Qqr.js";import"./chunk-WYO6CB5R-BlzOfotS-CgOwOaF2.js";import"./chunk-VAUOI2AC-CS9QJ4yz-C1PM97Ei.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-CC-mdXDP.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-F7APysNp.js

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