pi-umbra 0.1.0

package/node_modules/pi-umbra-skill-matcher/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "pi-umbra-skill-matcher",
+  "version": "0.1.0",
+  "description": "Type /huh and reach skill:huh. pi lists every skill under its bare name, which is not the name that dispatches.",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "autocomplete",
+    "skills"
+  ],
+  "author": "grkn",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grknbyk/pi-umbra.git",
+    "directory": "pi-umbra-skill-matcher"
+  },
+  "homepage": "https://github.com/grknbyk/pi-umbra/tree/main/pi-umbra-skill-matcher#readme",
+  "bugs": "https://github.com/grknbyk/pi-umbra/issues",
+  "type": "module",
+  "files": [
+    "extensions",
+    "checks",
+    "README.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  }
+}

package/node_modules/pi-umbra-theme/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grkn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pi-umbra-theme/README.md

@@ -0,0 +1,38 @@
+# pi-umbra-theme
+
+pi's look in one package: seven umbra themes and the terminal background they set, a status footer, a gutter beside model text, a frame around every tool call, and a working line that names the running tool.
+
+```
+pi-umbra-theme/
+├── checks
+│   ├── umbra-background.check.ts
+│   ├── umbra-footer.check.ts
+│   ├── umbra-gutter.check.ts
+│   ├── umbra-toolbox.check.ts
+│   └── umbra-working.check.ts
+├── extensions
+│   ├── umbra-background.ts
+│   ├── umbra-footer.ts
+│   ├── umbra-gutter.ts
+│   ├── umbra-toolbox.ts
+│   └── umbra-working.ts
+├── lib
+│   ├── umbra-format.ts
+│   └── umbra-settings.ts
+└── themes
+    ├── umbra-astral-veil.json
+    ├── umbra-deep-current.json
+    ├── umbra-ember-ash.json
+    ├── umbra-onyx-slate.json
+    ├── umbra-tidal-drift.json
+    ├── umbra-venom-dusk.json
+    └── umbra-violet-forge.json
+```
+
+## Install
+
+```sh
+pi install npm:pi-umbra-theme
+```
+
+MIT.

package/node_modules/pi-umbra-theme/checks/umbra-background.check.ts

@@ -0,0 +1,158 @@
+// The one runnable check for umbra-background: the colour it picks, and the bytes it writes.
+// A pi upgrade that renames Theme.sourcePath, or an edit that drops the OSC 111 reset, fails
+// here instead of leaving someone's terminal recoloured after pi exits.
+//
+//   bun run umbra-background.check.ts
+import assert from "node:assert";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dir = mkdtempSync(join(tmpdir(), "umbra-"));
+const themePath = join(dir, "violet-forge.json");
+writeFileSync(themePath, JSON.stringify({ name: "violet-forge", export: { pageBg: "#191830" } }));
+const bareThemePath = join(dir, "bare.json");
+writeFileSync(bareThemePath, JSON.stringify({ name: "bare" }));
+
+const settingsPath = join(dir, "settings.json");
+const setSetting = (value: unknown) =>
+    writeFileSync(settingsPath, JSON.stringify(value === undefined ? {} : { piUmbraTheme: { background: value } }));
+process.env.PI_AGENT_DIR = dir;
+
+const written: string[] = [];
+const realWrite = process.stdout.write.bind(process.stdout);
+process.stdout.write = ((chunk: string) => {
+    if (typeof chunk === "string" && chunk.startsWith("\x1b]")) {
+        written.push(chunk);
+        return true;
+    }
+    return realWrite(chunk as never);
+}) as never;
+
+const { default: umbraBackground } = await import("../extensions/umbra-background.ts");
+
+type Handler = (event: unknown, ctx: unknown) => void;
+const handlers = new Map<string, Handler>();
+let command: { name: string; handler: (args: string, ctx: unknown) => Promise<void> } | undefined;
+const pi = {
+    on: (name: string, handler: Handler) => handlers.set(name, handler),
+    // Two arguments, matching pi: registerCommand(name, options). Recording only the options is
+    // what this check exists to keep honest - the one-object form is what crashed pi at "/".
+    registerCommand: (name: string, options: never) => (command = { name, ...(options as object) }),
+};
+umbraBackground(pi as never);
+
+const notices: string[] = [];
+// Real pi hands the extension a Theme with NO sourcePath; the file it was read from is only on
+// the list getAllThemes() returns, under the name `path`. The check used to invent a sourcePath
+// and then assert against its own invention, which is why it passed while nothing happened on
+// screen. Both shapes are exercised now, and the pi-shaped one is the default.
+const ctx = (sourcePath: string | undefined, mode = "tui") => ({
+    mode,
+    ui: {
+        theme: { name: "violet-forge", sourcePath },
+        getAllThemes: () => [],
+        notify: (m: string) => notices.push(m),
+    },
+});
+const piShapedCtx = (path: string | undefined, mode = "tui") => ({
+    mode,
+    ui: {
+        theme: { name: "violet-forge" },
+        getAllThemes: () => (path === undefined ? [] : [{ name: "violet-forge", path }]),
+        notify: (m: string) => notices.push(m),
+    },
+});
+
+const start = () => handlers.get("session_start")!;
+const shutdown = () => handlers.get("session_shutdown")!;
+
+// auto: the colour comes from the theme's own export.pageBg, and shutdown puts it back.
+setSetting(undefined);
+written.length = 0;
+start()({}, ctx(themePath));
+assert.deepEqual(written, ["\x1b]11;#191830\x07"], "auto must set the theme's pageBg");
+shutdown()({}, ctx(themePath));
+assert.equal(written[1], "\x1b]111\x07", "shutdown must reset the background");
+
+// A theme with no export.pageBg is left alone. Nothing is guessed.
+setSetting(undefined);
+written.length = 0;
+start()({}, ctx(bareThemePath));
+assert.deepEqual(written, [], "a theme without pageBg must write nothing");
+shutdown()({}, ctx(bareThemePath));
+assert.deepEqual(written, [], "nothing applied means nothing to reset");
+
+// off wins over the theme.
+setSetting("off");
+written.length = 0;
+start()({}, ctx(themePath));
+assert.deepEqual(written, [], "off must write nothing");
+
+// An explicit colour wins over the theme.
+setSetting("#0c0c0c");
+written.length = 0;
+start()({}, ctx(themePath));
+assert.deepEqual(written, ["\x1b]11;#0c0c0c\x07"], "an explicit hex must win");
+
+// Outside a TUI there is no terminal to recolour.
+setSetting(undefined);
+written.length = 0;
+start()({}, ctx(themePath, "print"));
+assert.deepEqual(written, [], "non-tui mode must write nothing");
+
+// The command takes a colour, a reset, and rejects anything else without writing.
+setSetting(undefined);
+written.length = 0;
+await command!.handler("#abcdef", ctx(themePath));
+assert.deepEqual(written, ["\x1b]11;#abcdef\x07"]);
+await command!.handler("off", ctx(themePath));
+assert.equal(written[1], "\x1b]111\x07");
+written.length = 0;
+await command!.handler("purple", ctx(themePath));
+assert.deepEqual(written, [], "a bad argument must not write to the terminal");
+
+// The shape real pi actually passes: no sourcePath anywhere, the file only on getAllThemes().
+setSetting(undefined);
+written.length = 0;
+start()({}, piShapedCtx(themePath));
+assert.deepEqual(written, ["]11;#191830"], "the theme file must be found via getAllThemes().path");
+shutdown()({}, piShapedCtx(themePath));
+
+// A theme pi does not list is left alone rather than guessed at.
+written.length = 0;
+start()({}, piShapedCtx(undefined));
+assert.deepEqual(written, [], "an unlisted theme writes nothing");
+
+// Switching themes in pi's own picker fires no event of any kind, so the extension watches the
+// theme name. This is the one case that has to wait on a real tick rather than a faked clock.
+setSetting(undefined);
+written.length = 0;
+const live = { name: "bare" };
+const liveCtx = {
+    mode: "tui",
+    ui: {
+        get theme() {
+            return live;
+        },
+        getAllThemes: () => [
+            { name: "bare", path: bareThemePath },
+            { name: "violet-forge", path: themePath },
+        ],
+        notify: (m: string) => notices.push(m),
+    },
+};
+start()({}, liveCtx);
+assert.deepEqual(written, [], "a theme with no export.pageBg writes nothing");
+live.name = "violet-forge";
+await new Promise((done) => setTimeout(done, 700));
+assert.deepEqual(written, ["]11;#191830"], "a theme switch must be followed without any event");
+shutdown()({}, liveCtx);
+written.length = 0;
+live.name = "bare";
+await new Promise((done) => setTimeout(done, 700));
+assert.deepEqual(written, [], "the watcher must stop at shutdown");
+
+process.stdout.write = realWrite;
+
+console.log("umbra-background: all checks passed");

package/node_modules/pi-umbra-theme/checks/umbra-footer.check.ts

@@ -0,0 +1,72 @@
+// The one runnable check for footer.ts: it renders every frame, so an API drift in ctx,
+// footerData or the theme fails silently as a blank or a thrown line nobody sees. This
+// drives the extension through a stub pi and asserts the six columns land on one line
+// of exactly the width asked for.
+//
+// Run it with:  bun run umbra-footer.check.ts     (or: node --experimental-strip-types footer.check.ts)
+import assert from "node:assert/strict";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import footer from "../extensions/umbra-footer.ts";
+
+const handlers: Record<string, (event: unknown, ctx: unknown) => unknown> = {};
+const pi = { on: (name: string, fn: (event: unknown, ctx: unknown) => unknown) => (handlers[name] = fn) };
+
+let factory: ((tui: unknown, theme: unknown, footerData: unknown) => { render(width: number): string[] }) | undefined;
+let renders = 0;
+const usage = { input: 6800, output: 33, cacheRead: 128_000, cacheWrite: 0, cost: { total: 1.23 } };
+const ctx = {
+	model: { name: "MiniMax: MiniMax M3 (CC)" },
+	thinkingLevel: "medium",
+	getContextUsage: () => ({ tokens: 147_000, contextWindow: 1_000_000 }),
+	sessionManager: {
+		getCwd: () => "C:/Users/grkn/.pi",
+		getBranch: () => [{ type: "message", message: { role: "assistant", usage } }],
+	},
+	ui: { setFooter: (f: typeof factory) => (factory = f) },
+};
+const tui = { requestRender: () => renders++ };
+const theme = { fg: (_color: string, text: string) => text };
+const footerData = {
+	onBranchChange: () => () => {},
+	getExtensionStatuses: () => new Map<string, string>([["ponytail", "ponytail: full"]]),
+	getGitBranch: () => "main",
+};
+
+footer(pi as never);
+assert.ok(handlers.session_start && handlers.agent_end, "registers session_start and agent_end");
+await handlers.session_start({}, ctx);
+assert.ok(factory, "session_start installs the footer");
+const view = factory!(tui, theme, footerData);
+
+const [line, ...rest] = view.render(160);
+assert.equal(rest.length, 0, "one line - the rule above it belongs to the editor, not to this");
+assert.equal(visibleWidth(line), 160, "fills the width exactly, one column of padding left and two right");
+for (const column of ["MiniMax M3 [medium]", "147k/1000k", "$1.23", "R128k W0 CH95.0%", "↑ 6.8k ↓ 33", "ponytail:full", "🗀  C:/Users/grkn/.pi", "⎇ main"]) {
+	assert.ok(line.includes(column), `shows ${column}`);
+}
+assert.ok(!line.includes("MiniMax:") && !line.includes("(CC)"), "provider prefix and parenthetical stripped");
+
+// A narrow terminal takes as many rows as the groups need. The count is not the assertion - the
+// assertion is that nothing is cut off the end and nothing runs past the edge. Truncating instead
+// always lost whichever group came last, and the groups are ordered by how often they are read.
+const rows = view.render(40);
+assert.ok(rows.length > 1, "narrow: one row cannot hold all of it");
+for (const row of rows) {
+	assert.ok(visibleWidth(row) <= 40, `narrow: a row ran past the edge: ${JSON.stringify(row)}`);
+}
+const joined = rows.join("\n");
+for (const column of ["MiniMax M3 [medium]", "147k/1000k", "$1.23", "R128k W0 CH95.0%", "ponytail:full", "🗀  C:/Users/grkn/.pi", "⎇ main"]) {
+	assert.ok(joined.includes(column), `narrow: ${column} survives the wrap`);
+}
+
+// The lag fix: agent_end re-reads the branch and asks for a repaint itself.
+const before = renders;
+await handlers.agent_end({}, ctx);
+assert.equal(renders, before + 1, "agent_end requests exactly one repaint");
+
+// A free model prices every turn at zero, and then the cost column must be absent.
+usage.cost.total = 0;
+await handlers.agent_end({}, ctx);
+assert.ok(!view.render(160)[0].includes("$"), "zero cost hides the $ column");
+
+console.log("umbra-footer.check.ts ok - one row at 160, wraps at 40 with nothing lost, repaint on agent_end");

package/node_modules/pi-umbra-theme/checks/umbra-gutter.check.ts

@@ -0,0 +1,59 @@
+// The one runnable check for umbra-gutter. The interesting part is not that a prefix is added —
+// it is that adding it does not destroy the Markdown underneath. A fence that stops being a
+// fence, or a blank line that splits one answer into two quote blocks, is the failure this
+// catches.
+//
+//   bun run umbra-gutter.check.ts
+import assert from "node:assert";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const directory = mkdtempSync(join(tmpdir(), "umbra-gutter-"));
+process.env.PI_AGENT_DIR = directory;
+const settingsPath = join(directory, "settings.json");
+const enableGutter = (enabled: boolean) =>
+    writeFileSync(settingsPath, JSON.stringify({ piUmbraTheme: { messages: { assistantPrefix: enabled } } }));
+
+enableGutter(true);
+const { default: umbraGutter, asQuote } = await import("../extensions/umbra-gutter.ts");
+
+type Transformer = (markdown: string, context: { messageType: string }) => string;
+const register = () => {
+    let transformer: Transformer | undefined;
+    umbraGutter({ registerMarkdownTransformer: (fn: Transformer) => (transformer = fn) } as never);
+    return transformer;
+};
+
+const transform = register();
+assert.ok(transform !== undefined, "an enabled gutter must register a transformer");
+
+// A fenced code block has to survive, markers and all. This is the whole reason it is a quote.
+const fenced = "Here:\n\n```ts\nconst x = 1;\n```\n";
+const quotedFence = transform("Here:\n\n```ts\nconst x = 1;\n```", { messageType: "assistant" });
+assert.equal(quotedFence, "> Here:\n>\n> ```ts\n> const x = 1;\n> ```", `fence broke: ${quotedFence}`);
+assert.ok(quotedFence.includes("> ```ts"), "the opening fence must stay a fence inside the quote");
+assert.equal(fenced.match(/```/g)?.length, quotedFence.match(/```/g)?.length, "no fence may be lost");
+
+// A blank line must carry the marker, or the answer splits into two separate quote blocks.
+assert.equal(asQuote("a\n\nb"), "> a\n>\n> b");
+assert.equal(asQuote("a\n   \nb"), "> a\n>\n> b", "whitespace-only lines count as blank");
+
+// Only model text is touched. Your own lines and the thinking block are left alone.
+const mine = "@src/app.ts bunu sadeleştir";
+assert.equal(transform(mine, { messageType: "user" }), mine);
+assert.equal(transform(mine, { messageType: "assistant-thinking" }), mine);
+
+// An empty answer stays empty rather than becoming a lone quote marker.
+assert.equal(transform("", { messageType: "assistant" }), "");
+assert.equal(transform("   ", { messageType: "assistant" }), "   ");
+
+// Turkish text passes through byte for byte; the gutter is a prefix, not a rewrite.
+const turkish = "Işıkçı şoföre çağrı yaptı.";
+assert.equal(transform(turkish, { messageType: "assistant" }), `> ${turkish}`);
+
+// Off means off: nothing is registered at all, so there is no render cost to pay.
+enableGutter(false);
+assert.equal(register(), undefined, "a disabled gutter must register nothing");
+
+console.log("umbra-gutter: all checks passed");

package/node_modules/pi-umbra-theme/checks/umbra-toolbox.check.ts

@@ -0,0 +1,71 @@
+// The one runnable check for umbra-toolbox. Two things can go wrong and both are silent: the
+// frame can misalign because a line's colour codes were counted as width, and the patch can be
+// applied to a `render` that is no longer the method it was written against.
+//
+//   bun run umbra-toolbox.check.ts
+import assert from "node:assert";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+
+const directory = mkdtempSync(join(tmpdir(), "umbra-toolbox-"));
+process.env.PI_AGENT_DIR = directory;
+writeFileSync(
+    join(directory, "settings.json"),
+    JSON.stringify({ piUmbraTheme: { tools: { chrome: "boxed" } } }),
+);
+
+const { frame, framedWidth, usableWidth } = await import("../extensions/umbra-toolbox.ts");
+
+const plain = (text: string) => text;
+const RED = "\x1b[31m";
+const OFF = "\x1b[39m";
+const WIDTH = 20;
+
+// The frame is exactly `width` columns wide, on every row, whatever the content was.
+const framed = frame(["abc", `${RED}de${OFF}`], WIDTH, plain);
+assert.equal(framed.length, 4, "two content rows plus a top and a bottom");
+assert.equal(framed[0], `╭${"─".repeat(18)}╮`);
+assert.equal(framed[3], `╰${"─".repeat(18)}╯`);
+assert.equal(framed[1], `│ abc${" ".repeat(13)} │`, `row misaligned: ${JSON.stringify(framed[1])}`);
+
+// Colour must not steal columns. The painted row has to close at the same place as the plain one.
+const colouredRow = framed[2] ?? "";
+const stripped = colouredRow.replace(/\x1b\[[0-9;]*m/g, "");
+assert.equal(stripped.length, WIDTH, `coloured row is ${stripped.length} columns, not ${WIDTH}`);
+assert.ok(colouredRow.endsWith(" │"), "the right border must survive the colour codes");
+
+// pi's tool component opens with a blank spacer. It belongs outside the box, not as an empty
+// first row inside it.
+const spaced = frame(["", "body", ""], WIDTH, plain);
+assert.equal(spaced[0], "", "a leading blank stays above the frame");
+assert.equal(spaced[1], `╭${"─".repeat(18)}╮`, "the frame starts after the blank");
+assert.equal(spaced[spaced.length - 1], "", "a trailing blank stays below the frame");
+
+// Nothing to frame, or nowhere to draw it: return pi's own lines untouched rather than a box
+// around nothing or a box wider than the terminal.
+assert.deepEqual(frame(["", "  "], WIDTH, plain), ["", "  "], "all-blank input is left alone");
+assert.deepEqual(frame(["body"], 8, plain), ["body"], "a terminal too narrow keeps pi's own row");
+
+// A line already wider than the inner column is not padded, and must not be silently cut either:
+// pi drew it, and losing characters is worse than a frame that bulges.
+const wide = frame(["x".repeat(40)], WIDTH, plain);
+assert.ok((wide[1] ?? "").includes("x".repeat(40)), "an over-wide line keeps all its characters");
+
+// pi must be asked for the inner width. Ask it for the full width and every full-width line it
+// draws ends up four columns past the right border, which is a frame that leaks rather than holds.
+// The last column belongs to the scrollbar, so the frame stops one short of it and the content
+// gives up that column too. Getting this sum wrong is what pushes a full row past the edge.
+assert.equal(framedWidth(80), 79, "the frame leaves the scrollbar its column");
+assert.equal(usableWidth(80), 75, "the border, its padding and that margin take five columns");
+assert.equal(usableWidth(80) + 4 + 1, 80, "content plus frame plus margin is exactly the width");
+assert.equal(usableWidth(8), 8, "below MIN_WIDTH nothing is framed, so nothing is taken");
+
+// The guard: this is the shape the wrapper was written against. If a pi upgrade changes it, the
+// extension must stand down rather than patch something else.
+const render: unknown = ToolExecutionComponent?.prototype?.render;
+assert.equal(typeof render, "function", "pi still has ToolExecutionComponent.prototype.render");
+assert.equal((render as (width: number) => string[]).length, 1, "render still takes one argument");
+
+console.log("umbra-toolbox: all checks passed");

package/node_modules/pi-umbra-theme/checks/umbra-working.check.ts

@@ -0,0 +1,120 @@
+// The status line, without a terminal. Everything worth checking is a pure function of the turn
+// state, so the event wiring is the only part left untested - and that part is four assignments.
+//
+//   bun run umbra-working.check.ts
+import assert from "node:assert";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { compact, elapsed } from "../lib/umbra-format.ts";
+import { type Turn, entryFor, indicatorFor, labelFor, newTurn, statusLine } from "../extensions/umbra-working.ts";
+
+const ON = { tokens: true, elapsed: true };
+const TOOLS = ["read", "ls", "find", "grep", "write", "edit", "bash", "powershell"];
+const KEYS = [...TOOLS, "thinking", "idle", "custom"];
+
+// pi's eight typed tools collapse into four words. The mapping is the whole point of the file, so
+// every name in `ToolCallEvent` is named here rather than sampled.
+assert.equal(labelFor("read"), "Reading");
+assert.equal(labelFor("ls"), "Listing");
+assert.equal(labelFor("find"), "Listing");
+assert.equal(labelFor("grep"), "Listing");
+assert.equal(labelFor("write"), "Editing");
+assert.equal(labelFor("edit"), "Editing");
+assert.equal(labelFor("bash"), "Shell");
+assert.equal(labelFor("powershell"), "Shell");
+assert.equal(labelFor("thinking"), "Thinking");
+assert.equal(labelFor("idle"), "Working");
+
+// CustomToolCallEvent - anything an extension registered - lands on one entry, animation included.
+assert.equal(labelFor("fabric_exec"), "Tool call");
+assert.equal(labelFor("ask_user_question"), "Tool call");
+assert.deepEqual(indicatorFor("fabric_exec").frames, indicatorFor("custom").frames);
+
+// --- frames ----------------------------------------------------------------------------------
+// Every glyph must measure one column: a two-column frame shifts the whole status line on every
+// tick, which is what ruled the trigrams out of Listing.
+for (const key of KEYS) {
+	const { frames } = indicatorFor(key);
+	assert.ok(frames.length >= 4, `${key} needs enough frames to read as motion`);
+	for (const frame of frames) assert.equal(visibleWidth(frame), 1, `${key}: ${frame} is not one column`);
+}
+
+// Tools that share a word share its animation, and no two words look alike - otherwise the glyph
+// says nothing the word did not already say.
+assert.deepEqual(indicatorFor("find").frames, indicatorFor("ls").frames, "one word, one animation");
+assert.deepEqual(indicatorFor("powershell").frames, indicatorFor("bash").frames);
+const distinct = new Set(KEYS.map((key) => indicatorFor(key).frames.join("")));
+assert.equal(distinct.size, 7, "seven words, seven animations");
+
+// Listing bounces rather than sweeping one way: a vertical sweep that resets jumps the full cell
+// height and reads as a stutter.
+assert.deepEqual(indicatorFor("ls").frames, ["⎺", "⎻", "⎼", "⎽", "⎼", "⎻"]);
+assert.deepEqual(indicatorFor("write").frames, ["▖", "▘", "▝", "▗"]);
+
+// The sets are 4, 6 and 8 long, so a fixed per-frame interval would run them at three speeds. One
+// full turn is the number held steady and the interval is derived from it.
+assert.equal(indicatorFor("write").intervalMs, 120, "4 frames");
+assert.equal(indicatorFor("read").intervalMs, 80, "6 frames");
+assert.equal(indicatorFor("idle").intervalMs, 60, "8 frames");
+for (const key of KEYS) {
+	const { frames, intervalMs } = indicatorFor(key);
+	assert.equal(frames.length * intervalMs, 480, `${key} must take the same time to come round`);
+}
+
+// --- settings --------------------------------------------------------------------------------
+// Fields merge one by one, so naming a tool keeps the animation it already had.
+const renamed = { tools: { fabric_exec: { label: "Fabric" } } };
+assert.equal(labelFor("fabric_exec", renamed), "Fabric");
+assert.deepEqual(indicatorFor("fabric_exec", renamed).frames, indicatorFor("custom").frames);
+assert.equal(labelFor("read", renamed), "Reading", "an override must leave the other tools alone");
+
+// A frames array replaces rather than merges, and the turn holds, so a shorter set runs slower per
+// frame instead of running the whole animation faster.
+const shell = { tools: { bash: { frames: ["$", "#", "%"] } } };
+assert.deepEqual(indicatorFor("bash", shell).frames, ["$", "#", "%"]);
+assert.equal(indicatorFor("bash", shell).intervalMs, 160, "3 frames, same 480ms turn");
+assert.deepEqual(indicatorFor("powershell", shell).frames, indicatorFor("powershell").frames, "not its twin");
+assert.deepEqual(indicatorFor("bash", { tools: { bash: { frames: [] } } }).frames.length, 4, "empty is no override");
+
+// `cycleMs` is one full turn, so it survives a change of frame count.
+assert.equal(indicatorFor("read", { tools: { read: { cycleMs: 1200 } } }).intervalMs, 200);
+assert.deepEqual(entryFor("bash", { tools: { bash: { label: "Bash", cycleMs: 240 } } }), {
+	label: "Bash",
+	cycleMs: 240,
+	frames: indicatorFor("bash").frames,
+});
+
+// --- the line --------------------------------------------------------------------------------
+const at = (turn: Partial<Turn>): Turn => ({ ...newTurn(0), ...turn });
+
+// A turn that has produced nothing yet shows no arrow, because "↓ 0 tokens" is noise.
+assert.equal(statusLine(at({}), 1_000, ON), "Working… (1s)");
+assert.equal(statusLine(at({ key: "read", settled: 180 }), 5_000, ON), "Reading… (5s · ↓ 180 tokens)");
+assert.equal(statusLine(at({ key: "bash", settled: 1_200 }), 12_000, ON), "Shell… (12s · ↓ 1.2k tokens)");
+assert.equal(statusLine(at({ key: "fabric_exec" }), 1_000, ON), "Tool call… (1s)");
+assert.equal(statusLine(at({ key: "fabric_exec" }), 1_000, ON, renamed), "Fabric… (1s)");
+
+// Streaming output counts before the message ends, or the number stands still mid-answer.
+assert.equal(statusLine(at({ settled: 100, streaming: 80 }), 5_000, ON), "Working… (5s · ↓ 180 tokens)");
+
+// "thought for" belongs to the Thinking line alone and counts from zero at the block, so the two
+// numbers on that line are the turn and this thought - not the turn twice.
+const thinking = at({ key: "thinking", thinkingAt: 9_000, settled: 50 });
+assert.equal(statusLine(thinking, 12_000, ON), "Thinking… (12s · ↓ 50 tokens · thought for 3s)");
+assert.doesNotMatch(statusLine(at({ key: "read", thinkingAt: 9_000 }), 12_000, ON), /thought for/);
+assert.doesNotMatch(statusLine(at({ key: "thinking" }), 12_000, ON), /thought for/);
+
+// Switches, and the both-off case, which must still say what is happening.
+assert.equal(statusLine(at({ settled: 180 }), 5_000, { tokens: false, elapsed: true }), "Working… (5s)");
+assert.equal(statusLine(at({ settled: 180 }), 5_000, { tokens: true, elapsed: false }), "Working… (↓ 180 tokens)");
+assert.equal(statusLine(at({ settled: 180 }), 5_000, { tokens: false, elapsed: false }), "Working…");
+
+// Past a minute, seconds alone stop reading as a duration.
+assert.equal(elapsed(59_400), "59s");
+assert.equal(elapsed(60_000), "1m 0s");
+assert.equal(elapsed(205_000), "3m 25s");
+assert.equal(elapsed(-5), "0s", "a clock that went backwards must not print a negative");
+assert.equal(compact(695), "695");
+assert.equal(compact(7_013), "7.0k");
+assert.equal(compact(224_310), "224k");
+
+console.log(`umbra-working.check.ts ok - ${KEYS.length} keys, frames 8 cases, settings 9, line 12, format 7`);