mulmoterminal 4.7.6 → 4.8.1

package/README.md

@@ -692,6 +692,14 @@ and not built*. The window is **since the last run** (tracked in
 work. It reads and reconciles progress against `vision.md` / `milestones.md` (creating
 empty ones if absent) so a long-running goal isn't forgotten.
 
+A run due while the server was **off** is not lost: built-in scheduled tasks record their
+runs in `config/scheduler/state.json` and **catch up at startup**, each by its own missed-run
+policy. The worklog's is `run-once` — a single run covering everything since the last, so
+several missed windows don't become several batches summarising the same period. Whether
+they ran, and when they run next, is in `GET /api/scheduler/tasks`; the history is in
+`GET /api/scheduler/logs` (`?taskId=&since=&limit=`, newest first) and on disk under
+`data/scheduler/logs/`.
+
 Output lands in the wiki: one **weekly page** per ISO week
 (`data/wiki/pages/dev-log-YYYY-www.md` — filenames are lowercase, or the wiki can't open
 them), each tagged `worklog`. To browse them, open the **作業ログ 一覧** hub page
@@ -778,7 +786,7 @@ Settings → Directory settings names both files and lists which keys the local
 | `icon`       | An **image** marking this directory — shown in the cell header, the cockpit roster, the filmstrip thumbnails, the launcher's directory chips, and the phone's terminal list and terminal screen. Either a path **relative to this directory** (an absolute path, or a `../` that escapes it, is rejected), an `http(s)://` URL, or a `data:image/…` URI. PNG / JPEG / **GIF (animated plays)** / WebP / AVIF / SVG / ICO / BMP. Not to be confused with a header **button's** `icon`, which is a Material Symbols name. **Omit it and the repository's own favicon is used** (`public/favicon.svg`, `apple-touch-icon.png`, a web manifest — see `autoDirIcon`); `false` means no icon here and stops that search. |
 | `badgeColor` | Badge background color (`#rrggbb`); text auto-contrasts. |
 | `headerColor` | Header **background** color (`#rrggbb`) — the grid cell's header row and the terminal's own header row (grid row 2). While a terminal is working/blocked the status tint still shows; the custom color applies when idle. |
-| `headerTextColor` | Header **text** color (`#rrggbb`) — the dir path, title, and prompt. |
+| `headerTextColor` | Header **text** color (`#rrggbb`) — everything written on the header: the dir path, title and prompt, plus the model/context badge, the token counts and any custom chip. **Omit it and a readable colour is derived from `headerColor`**, while that colour is what shows (a working/blocked cell paints its own header tint, so its text returns to the theme's). |
 | `cellColor` | Cell **body background** color (`#rrggbb`) — the frame around the terminal. |
 | `cellBorderColor` | Cell **border** color (`#rrggbb`). The status frame (working/blocked) still overrides it while active. |
 | `dotColor` | **Idle** status-dot color (`#rrggbb`). The working/waiting colors are unchanged so the activity signal stays intact. |
@@ -1130,9 +1138,9 @@ absent from the answer — which is how a caller learns work cannot start on it.
 Each grid cell's header shows two badges for its session, refreshed when a turn finishes
 (from `GET /api/session/:id`):
 
-![A live Claude cell — the header shows the model·context and token badges this section describes](https://raw.githubusercontent.com/receptron/mulmoterminal/main/docs/guide/images/grid-cell-live.png)
+![A live Claude cell's header, close up — the model·context and token badges this section describes](https://raw.githubusercontent.com/receptron/mulmoterminal/main/docs/guide/images/grid-cell-live.png)
 
-*Both badges, live on a real Claude session: **`Opus · ctx 5%`** (model family + how full its context window is) and **`⇡427k ⇣1.8k`** (cumulative input / output tokens for the session). They sit in the header's first row alongside the **status dot**, directory, and **git chip** (`⎇ main ●2`), with what the agent is doing to the right; the icon buttons and the **timeline** (🕘) of tool calls are on the second row.*
+*Both badges, live on a real Claude session: **`Sonnet · ctx 9%`** (model family + how full its context window is) and **`⇡1.8M ⇣6.9k`** (cumulative input / output tokens for the session). They sit in the header's first row alongside the **status dot** and the **git chip** (`⎇ main ●2`), with what the agent is doing to the right; the working directory, the icon buttons and the **timeline** (🕘) of tool calls are on the second row.*
 
 - **Context badge** — e.g. `Opus · ctx 35%`: the model family plus how full its context
   window is (the *last* turn's input + cache tokens ÷ the model's window — **1M** for

package/common/chromeFromColor.ts

@@ -15,7 +15,7 @@
 // Snapping every role to absolute values drifts by ΔE 20 at the dark end of the hue wheel; making
 // every role a relative offset drifts by ΔE 15 at the pale end. Both were tried; this is the mix
 // that fits. Anyone retuning these numbers should re-measure rather than reason about them.
-import { readableTextColor } from "./contrast.js";
+import { contrastRatio, readableTextColor, relativeLuminance } from "./contrast.js";
 
 export interface ChromeColors {
   badgeColor: string;
@@ -36,6 +36,37 @@ const BUTTON = { s: 0.67, l: 0.89 };
 
 const clamp01 = (n: number): number => Math.min(1, Math.max(0, n));
 
+// The inks a header background can be written in. Black is softened to a near-black so a pale
+// header does not read as a printed page; white is left pure, since anything softer loses contrast
+// on the dark end where it is chosen.
+const DARK_INK = "#1b2430";
+const PURE_DARK_INK = "#000000";
+const LIGHT_INK = "#ffffff";
+
+// WCAG AA for normal text. These chips run to 10px, so the large-text 3:1 bar does not apply.
+const AA_CONTRAST = 4.5;
+const DARK_INK_LUMINANCE = relativeLuminance(0x1b, 0x24, 0x30);
+
+// The softening is a PREFERENCE, and it costs contrast: on a mid-tone background that cost is what
+// drops the text below AA — `#e8341c` measures 3.68:1 against the softened ink and 4.94:1 against
+// pure black (Codex on #1592, which is right and was worth measuring). So it is applied only while
+// it is free. Falling back always works: at the worst background — the luminance where black and
+// white are equally readable — the pure ink still reaches 4.58:1.
+function inkFor(rgb: [number, number, number]): string {
+  if (readableTextColor(rgb[0], rgb[1], rgb[2]) === "#fff") return LIGHT_INK;
+  const background = relativeLuminance(rgb[0], rgb[1], rgb[2]);
+  return contrastRatio(background, DARK_INK_LUMINANCE) >= AA_CONTRAST ? DARK_INK : PURE_DARK_INK;
+}
+
+/** Which ink a header background wants, or null when it isn't a colour we can read. Exported so a
+ *  directory that declares only `headerColor` derives the SAME text colour this file gives a
+ *  repo.json brand colour (src/components/cellHeaderStyle.ts) — two answers to one question is how
+ *  one directory ends up written in two different colours. */
+export function headerTextColorFor(background: string): string | null {
+  const rgb = parseHex(background);
+  return rgb ? inkFor(rgb) : null;
+}
+
 /** The seven colours for a brand colour, or null when it isn't a colour we can read. */
 export function chromeFromColor(primary: string, background?: string | null): ChromeColors | null {
   const rgb = parseHex(primary);
@@ -50,7 +81,7 @@ export function chromeFromColor(primary: string, background?: string | null): Ch
     headerColor: normalizeHex(primary),
     // Never taken from the file — see the spec's "text colour is never declared". Deriving it is
     // also what makes two conforming tools agree.
-    headerTextColor: readableTextColor(rgb[0], rgb[1], rgb[2]) === "#000" ? "#1b2430" : "#ffffff",
+    headerTextColor: inkFor(rgb),
     // `background` is the surface the brand colour sits on, which is exactly what a cell body is.
     // Gated on it PARSING, not on it being present: an unusable value here used to win the branch,
     // survive as a non-colour, and then be dropped downstream — leaving no surface at all, neither

package/common/collectionNotifyTarget.ts

@@ -19,6 +19,12 @@ export interface CollectionNotifyTarget {
   slug: string;
   /** Absent on a collection-level bell — those can't accent a specific record. */
   itemId?: string | undefined;
+  /** The record's project, as the opaque id the API takes. ABSENT MEANS THE WORKSPACE — both
+   *  because that is what a workspace bell has always written and because it is the only thing
+   *  MulmoClaude, which has one root, can write. A slug is unique within a root and nowhere
+   *  else, so a reader that ignores this accents the same-named record of whichever project is
+   *  on screen. */
+  project?: string | undefined;
 }
 
 /** Narrow a notification's opaque `pluginData` to its collection navigate target,
@@ -31,7 +37,11 @@ export function collectionNotifyTargetOf(pluginData: unknown): CollectionNotifyT
   if (!isRecord(action)) return null;
   const { target } = action;
   if (!isRecord(target)) return null;
-  const { view, slug, itemId } = target;
+  const { view, slug, itemId, project } = target;
   if (view !== COLLECTION_NOTIFY_VIEW || typeof slug !== "string" || slug.length === 0) return null;
-  return { slug, itemId: typeof itemId === "string" && itemId.length > 0 ? itemId : undefined };
+  return {
+    slug,
+    itemId: typeof itemId === "string" && itemId.length > 0 ? itemId : undefined,
+    project: typeof project === "string" && project.length > 0 ? project : undefined,
+  };
 }

package/common/collectionPortability.ts

@@ -0,0 +1,84 @@
+// "Would this collection survive a clone?" — the wire shape, shared because BOTH sides decide
+// from it: the server produces the report (server/backends/collectionSelfContainment.ts) and the
+// Collections pane renders it, colouring by severity and blocking on `portable`.
+//
+// In `common/` rather than mirrored, for the reason the layout rule gives: a second copy of a
+// union is how a writer and a reader drift while both keep compiling. The RULES stay server-side
+// — they read the filesystem and shell out to git — and only their result crosses.
+import { isRecord } from "./isRecord.js";
+import { isUnknownArray } from "./isUnknownArray.js";
+
+/** Why a collection would not survive a clone. Stable strings — a client branches on these, and
+ *  the prose is free to be rewritten without breaking it. */
+export type SelfContainmentCode =
+  /** The skill lives in `~/.claude/skills`, i.e. on this machine and not in the repo. */
+  | "user-scope"
+  /** Records are one SQLite file: git cannot merge it. */
+  | "sqlite-store"
+  /** Records are rows of a CSV read through DuckDB — a runtime the clone must also have. */
+  | "csv-runtime"
+  /** Something the records need is git-ignored: the schema travels, they do not. */
+  | "data-ignored"
+  /** No `primaryKey`, so ids are 4 random bytes and two machines can mint the same one. */
+  | "no-primary-key"
+  /** The project is not a git repo, so there is nothing to clone and most checks do not apply. */
+  | "not-a-repo";
+
+/** `blocker` stops the clone working; `warning` costs something on the other machine; `info` is
+ *  context. Only a blocker makes `portable` false. */
+export type SelfContainmentSeverity = "blocker" | "warning" | "info";
+
+export interface SelfContainmentFinding {
+  /** One of `SelfContainmentCode` in practice, typed as a plain string on the WIRE on purpose: a
+   *  newer server may report a code this build has never heard of, and narrowing here would drop
+   *  a real finding behind a version skew. Nothing branches on it — the pane renders `message`
+   *  and colours by `severity` — so widening costs nothing. A spec pins that everything the
+   *  server produces IS in the union. */
+  code: string;
+  severity: SelfContainmentSeverity;
+  /** What breaks on the other machine, in the terms the person will see it. */
+  message: string;
+}
+
+export interface SelfContainmentReport {
+  slug: string;
+  /** True when nothing BLOCKS the clone. Warnings can still be present. */
+  portable: boolean;
+  findings: SelfContainmentFinding[];
+}
+
+/** The severity IS narrowed, unlike the code: it decides how the row is rendered AND whether the
+ *  finding is a blocker, so an unrecognised one cannot be shown honestly. A predicate rather than
+ *  a list membership test, so the narrowing is the type system's rather than an assertion's. */
+export function isSelfContainmentSeverity(value: unknown): value is SelfContainmentSeverity {
+  return value === "blocker" || value === "warning" || value === "info";
+}
+
+function asFinding(value: unknown): SelfContainmentFinding | null {
+  if (!isRecord(value)) return null;
+  const { code, severity, message } = value;
+  if (typeof code !== "string" || typeof message !== "string") return null;
+  if (!isSelfContainmentSeverity(severity)) return null;
+  return { code, severity, message };
+}
+
+/** Narrow a fetched body to the report, or null when it is not one. The body arrives as
+ *  `unknown` — a truncated response, an error page, an older server — so every level is checked
+ *  rather than trusted. */
+export function asSelfContainmentReport(body: unknown): SelfContainmentReport | null {
+  if (!isRecord(body)) return null;
+  const { slug, portable, findings } = body;
+  if (typeof slug !== "string" || typeof portable !== "boolean" || !isUnknownArray(findings)) return null;
+  const parsed: SelfContainmentFinding[] = [];
+  for (const entry of findings) {
+    const finding = asFinding(entry);
+    // ONE UNREADABLE FINDING REJECTS THE WHOLE REPORT. Skipping it would be the worse failure:
+    // if the dropped finding was the only blocker, the caller is handed `findings: []` and tells
+    // the user "nothing to fix — it travels" about a collection that does not. A report we cannot
+    // fully read is not a clean bill of health, and "could not run the check" is the honest
+    // answer — visible and actionable, where a false all-clear is neither.
+    if (!finding) return null;
+    parsed.push(finding);
+  }
+  return { slug, portable, findings: parsed };
+}

package/common/pathSegments.ts

@@ -0,0 +1,23 @@
+// Splitting a filesystem path into its parts, on EITHER separator.
+//
+// `path.sep` is not the answer here: these paths come from a config file and from a saved
+// directory list, so a Windows path can be read on a mac (a synced config, a bug report, a test
+// fixture) and a POSIX one on Windows. Code that splits on "/" alone does not fail loudly on
+// `C:\Users\me\project` — it returns the WHOLE STRING as one segment, which is how a "label"
+// becomes an absolute path.
+//
+// That is a privacy contract in one place: the phone's project listing sends a label and never a
+// path, precisely so a command or an artifact cannot publish the user's home directory. A
+// one-separator split turns that guarantee off on Windows without changing a line of the code
+// that states it.
+
+/** The non-empty parts of a path, splitting on `/` and `\` alike. A drive letter (`C:`) stays a
+ *  segment of its own — it is not a directory name, and nothing here wants it as one. */
+export function pathSegments(value: string): string[] {
+  return value.split(/[/\\]+/).filter((segment) => segment.length > 0);
+}
+
+/** The last part of a path — its directory or file name — or the input when it has none. */
+export function lastSegment(value: string): string {
+  return pathSegments(value).at(-1) ?? value;
+}

package/common/toolGroups.ts

@@ -31,6 +31,20 @@ export const isToolGroup = (value: unknown): value is ToolGroup => TOOL_GROUPS.s
 // front of the spend (same reasoning as presentDocument below).
 export const CANVAS_TOOL_GROUPS: readonly ToolGroup[] = ["render", "media"];
 
+// The groups the COLLECTIONS pane is made of. `data` is the group manageCollection and
+// presentCollection belong to, and the pane is a window onto exactly that store — a directory
+// that never registered the group has no collection tools, so the pane is a door onto a room the
+// agent beside it cannot enter.
+//
+// Named here rather than written as `"data"` at the call site for the same reason
+// CANVAS_TOOL_GROUPS is: a rename must not leave a literal pointing at a group that is gone.
+export const COLLECTIONS_TOOL_GROUPS: readonly ToolGroup[] = ["data"];
+
+/** Does this session/directory have the collection tools? Same shape as `hasCanvasGroup`, and
+ *  validated the same way — an unknown group name from a newer server must not count. */
+export const hasCollectionsGroup = (groups: unknown): boolean =>
+  Array.isArray(groups) && groups.some((group) => isToolGroup(group) && COLLECTIONS_TOOL_GROUPS.includes(group));
+
 // 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.

package/dist/assets/{abnfDiagram-N423BO3Z-D0pzqjdS-mU_JC_gy.js → abnfDiagram-N423BO3Z-D0pzqjdS-CTSEh1uL.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-CvsWqFln-Tc7ZSrRz.js";import{_ as n,g as r}from"./mermaid-parser.core-C1baW7NG-CxIKaNt7.js";import"./chunk-I66GZJ75-DSPCVCny-DUUEhGIc.js";import"./chunk-3NCLNEKW-CBztX243-DYiY7RPy.js";import{n as i,r as a,t as o}from"./chunk-6Q2QTUOP-Cx8nz5_t-CnRVqq3q.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-CvsWqFln-Tc7ZSrRz.js";import{_ as n,g as r}from"./mermaid-parser.core-C1baW7NG-m5_U2vyD.js";import"./chunk-I66GZJ75-DSPCVCny-DxpV96_X.js";import"./chunk-3NCLNEKW-CBztX243-DK2bYr2d.js";import{n as i,r as a,t as o}from"./chunk-6Q2QTUOP-Cx8nz5_t-BmPIYTTz.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-Cqhmai3f-DYURJf3a.js

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