pi-umbra 0.2.0 → 0.3.0

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/bar/bar-line.ts

@@ -0,0 +1,262 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import { LINGER_MS, type BranchView, type RunState } from "../skills/delegate/state.ts";
+
+// Every column the widget below the input box occupies, as pure functions over one run
+// snapshot: the flat live list of reference 3, `○ main` on top and one row per agent, with
+// Claude Code's `❯` on the row the user is on. A phased run draws the same list; the panel is
+// where its phases are.
+//
+// All of it lives here rather than in the component because the arithmetic is the part that can
+// be wrong in a way that hurts: a composed line one column too wide wraps in the terminal, and
+// a wrapped line above the editor pushes the input box down by a row. Pure functions can be
+// walked across every width by bar.check.ts with no terminal, no theme and no pi — and pi
+// cannot even be imported by a check, because loading it drags in the experimental server.
+// The one thing this file borrows from pi is `ThemeColor`, as a type-only import, which is
+// erased before anything runs.
+//
+// Widths are measured before colour goes on. Every piece returned by the two layout functions
+// is plain text whose width is exactly what it will occupy, and renderLines() below only ever
+// concatenates them in order — which is also why a row hands back `dotAt`, the one cell that
+// takes the status colour, instead of a pre-coloured glyph.
+
+export const MARK = 2; // "❯ " in front of the row the cursor is on, blank in front of the rest
+export const PAD = 1; // one column of gutter each side, matching the rows pi draws itself
+const COL_GAP = 3; // list: agent name -> activity, as in reference 3
+const MIN_ACTIVITY = 10; // ditto for the activity sentence, which is the point of the list
+const HEAD_CAP = 28; // ditto for the list's marker + dot + name column
+const MIN_INNER = 8; // under this nothing but a stub of the main row fits
+
+/** Reference 1 shows "idle 53s", so a branch counts as quiet well before a minute. */
+export const IDLE_MS = 15_000;
+/** How long a finished run stays on screen before the widget draws nothing again. */
+export { LINGER_MS };
+
+/** "45s", "3m 52s" — the reference-2 and reference-3 spelling, with the space. Reference 1
+ *  writes "3m15s" instead; that clock lives in panel.ts, where the columns are tighter. */
+export const clock = (ms: number) => {
+	const seconds = Math.max(0, Math.round(ms / 1000));
+	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+};
+
+// A dash, not "0": a provider that reports usage only at completion leaves the sum at zero for
+// minutes, and a fake number in the column the user glances at is worse than an honest gap.
+export const compact = (tokens: number) =>
+	tokens <= 0 ? "–" : tokens < 1000 ? `${tokens}` : `${(tokens / 1000).toFixed(1)}k`;
+
+// RunState carries no end time — liveness is per branch — so the last beacon write in the run
+// stands in for one. It is what freezes the elapsed clock, so a finished run stops counting.
+export const endedAt = (run: RunState) => (run.live ? 0 : Math.max(0, ...run.branches.map((branch) => branch.updatedAt)));
+
+/** Past its linger window a finished run is the same thing as no run at all: one bare `○ main`
+ *  row. Both shapes ask that question, so they ask it through one function. */
+export const faded = (run: RunState | undefined, now: number): boolean => {
+	if (!run || run.total === 0) return true;
+	const ended = endedAt(run);
+	return ended > 0 && now - ended > LINGER_MS;
+};
+
+// ---------- REFERENCE 3: the flat live list ----------
+
+/** One row of reference 3. `head` is the nesting marker, the status dot and the agent name,
+ *  padded so every row's activity starts in the same column; `dotAt` is the one cell inside it
+ *  that takes the status colour, or -1 on a row that has no dot. `branch` is undefined on the
+ *  `○ main` row, and is what tone() below reads to pick that cell's colour. */
+export type ListRow = {
+	head: string;
+	dotAt: number;
+	activity: string;
+	fill: string;
+	right: string;
+	branch?: BranchView;
+};
+
+// Reference 3's nesting marker, two columns per level with `└ ` on the last. Same shape as
+// panel.ts's, because the panel is the zoomed-in view of these same rows.
+const nest = (depth: number) => (depth > 0 ? `${"  ".repeat(depth - 1)}└ ` : "");
+
+// Filled while the branch is working, hollow when it is pending, quiet or finished. `○ main`
+// is hollow for the same reason the reference draws it hollow: the session is not a branch.
+const working = (branch: BranchView) =>
+	branch.alive && branch.status === "running" && branch.idleMs < IDLE_MS;
+
+const dot = (branch: BranchView) => (working(branch) ? "●" : "○");
+
+/** What the row says it is doing. A branch that was killed never got to write "done", so its
+ *  own `activity` is frozen on whatever it was mid-way through — a row reading "Running cd"
+ *  on a process that has been dead for four minutes. The exit file already knows better. */
+export const said = (branch: BranchView): string => {
+	if (branch.timedOut) return "Timed out";
+	if (branch.status === "error") return branch.error ? `Failed: ${branch.error}` : "Failed";
+	// Killed by hand or by a parent going away: a non-zero exit with no error text of its own.
+	if (branch.settled && branch.exitCode !== null && branch.exitCode !== 0 && !branch.report) return "Stopped";
+	return branch.activity ?? "";
+};
+
+// Chosen once for the whole list rather than per row, so the right-hand block is one column
+// instead of four ragged ones. Same order of sacrifice as the bar: the tokens go first, then
+// the arrow, and the clock last.
+const rowRight = (branch: BranchView, tier: number) => {
+	const time = clock(branch.elapsedMs);
+	if (tier === 0) return `${time} · ↓ ${compact(branch.tokens ?? 0)} tokens`;
+	if (tier === 1) return `${time} · ↓ ${compact(branch.tokens ?? 0)}`;
+	if (tier === 2) return time;
+	return "";
+};
+
+const widest = (values: string[]) => Math.max(0, ...values.map(visibleWidth));
+
+/** Reference 3, whole. Always at least one row, because a widget that renders zero lines
+ *  un-mounts itself and the input box drops a line the moment it does.
+ *
+ *  `max` is the row budget the component computes from the terminal height. Anything past it
+ *  collapses into a final "+N more", so the list has a ceiling but never a hidden agent. */
+export const layoutList = (width: number, run: RunState | undefined, now: number, max: number): ListRow[] => {
+	const inner = width - PAD * 2;
+	const main = "○ main";
+	// Sub-8 columns is not a terminal anyone reads a table in, and one stub row still holds the
+	// height the input box is sitting on.
+	if (inner < MIN_INNER) {
+		return [{ head: truncateToWidth(main, Math.max(0, inner), "…", true), dotAt: 0, activity: "", fill: "", right: "" }];
+	}
+
+	// readRun() already orders parents immediately above their children by launch order, so
+	// taking a prefix keeps the tree readable and, more importantly, keeps a row from sliding
+	// under the eye when a sibling settles. Sorting the live ones to the top would do that.
+	const all = !run || faded(run, now) ? [] : run.branches;
+	// The overflow row spends the budget's last slot rather than adding to it, so a run of forty
+	// branches is exactly as tall as a run of `max` and never one row taller.
+	const room = Math.max(0, max - 1); // rows left after `○ main`
+	const shown = all.length <= room ? all : all.slice(0, Math.max(0, room - 1));
+	const hidden = room > 0 ? all.length - shown.length : 0;
+	const overflow = hidden > 0 ? `+${hidden} more` : "";
+
+	const heads = shown.map((branch) => `${nest(branch.depth)}${dot(branch)} ${branch.name}`);
+	const headWidth = Math.min(inner, HEAD_CAP, Math.max(1, widest([main, ...heads, overflow])));
+
+	// One tier for the list, not one per row: the widest that still leaves the activity
+	// sentence a readable column next to the longest head.
+	let tier = 0;
+	let rightWidth = 0;
+	for (; tier < 3; tier++) {
+		rightWidth = widest(shown.map((branch) => rowRight(branch, tier)));
+		if (headWidth + COL_GAP + MIN_ACTIVITY + rightWidth <= inner) break;
+	}
+	if (tier === 3) rightWidth = 0;
+	// Clamped after the choice as well as before it: on a narrow terminal even the bare clock
+	// can be too wide, and an over-wide row is the one failure that moves the input box.
+	rightWidth = Math.min(rightWidth, Math.max(0, inner - headWidth));
+	const activityBudget = inner - headWidth - COL_GAP - rightWidth;
+
+	const row = (headText: string, at: number, text: string, right: string): ListRow => {
+		const head = truncateToWidth(headText, headWidth, "…", true);
+		const activity =
+			text && activityBudget >= MIN_ACTIVITY ? " ".repeat(COL_GAP) + truncateToWidth(text, activityBudget) : "";
+		// Padded on the left, so the clocks sit under each other instead of only the right edge
+		// lining up. Spaces take no colour, so this stays one string the component can dim.
+		const padded = " ".repeat(Math.max(0, rightWidth - visibleWidth(right))) + right;
+		const fill = Math.max(0, inner - headWidth - visibleWidth(activity) - visibleWidth(padded));
+		return { head, dotAt: at, activity, fill: " ".repeat(fill), right: padded };
+	};
+
+	// `○ main` is the session itself and always sits at the top, with no activity and no
+	// counters — exactly as the reference draws it. The widget factory is handed a tui and a
+	// theme and nothing else, so there is no ExtensionContext here to ask for the session's own
+	// usage, and a number the row could not stand behind is worse than the blank the screen
+	// actually shows.
+	const rows: ListRow[] = [row(main, 0, "", "")];
+	shown.forEach((branch, index) => {
+		// SAFETY: heads is built by mapping `shown` in order, so this index is populated.
+		const head = heads[index] as string;
+		rows.push({ ...row(head, visibleWidth(nest(branch.depth)), said(branch), rowRight(branch, tier)), branch });
+	});
+	// No dot on the overflow row: it stands for agents rather than being one.
+	if (overflow) rows.push(row(overflow, -1, "", ""));
+	return rows;
+};
+
+// ---------- THE FRAME ----------
+
+// The list's ceiling: `○ main` plus eight agents. Past that a "+N more" row stands in, so the
+// widget can never eat the screen it is sitting on top of.
+export const MAX_ROWS = 9;
+
+// The same distinctions panel.ts draws, because the panel is the zoomed-in view of these rows:
+// a timed-out branch answered nothing but did not crash, and a soft report is not a success.
+const tone = (branch: BranchView | undefined): ThemeColor => {
+	if (!branch) return "dim";
+	if (branch.timedOut) return "warning";
+	if (branch.status === "error" || (branch.exitCode !== null && branch.exitCode !== 0)) return "error";
+	if (branch.report === "PARTIAL" || branch.report === "NEED_STRONGER" || branch.report === "ASKING") return "warning";
+	if (branch.settled) return "success";
+	return branch.alive && branch.idleMs < IDLE_MS ? "accent" : "dim";
+};
+
+/** Everything on screen, in one string. A frame identical to the last one is never requested:
+ *  pi coalesces renders at 16 ms, but the cheapest frame is the one nobody asks for, and an
+ *  idle session whose reader ticks once a second would otherwise repaint a blank row for as
+ *  long as pi stays open. Width is deliberately absent — a resize repaints everything anyway. */
+export const renderKey = (run: RunState | undefined, now: number): string => {
+	if (!run || faded(run, now)) return "-";
+	const at = endedAt(run) || now;
+	const head = [run.name, run.description, run.done, run.total, run.tokens, Math.round((at - run.startedAt) / 1000)];
+	const rows = run.branches.map((branch) =>
+		[
+			branch.stem,
+			branch.depth,
+			branch.status,
+			said(branch),
+			branch.tokens,
+			Math.round(branch.elapsedMs / 1000),
+			branch.alive ? 1 : 0,
+			branch.idleMs < IDLE_MS ? 1 : 0,
+		].join(","),
+	);
+	return [...head, ...rows].join("|");
+};
+
+/** `theme.fg`, narrowed to the one method used, so the frame can be composed without a TUI. */
+export type Paint = (color: ThemeColor, text: string) => string;
+
+/**
+ * The whole frame, always the list. `cursor` is the stem the `❯` sits on; undefined puts it on
+ * `○ main`, which is where the user is while they type.
+ */
+export const renderLines = (
+	width: number,
+	run: RunState | undefined,
+	now: number,
+	budget: number,
+	paint: Paint,
+	panelIsOpen = false,
+	cursor?: string,
+): string[] => {
+	const total = Math.max(0, width);
+
+	// Nothing running: draw nothing at all, not a bare `○ main`. pi renders the belowEditor
+	// container with spacerWhenEmpty and leadingSpacer both false, so zero lines really is zero
+	// rows and the footer above it does not move when a run starts or ends. That was not true
+	// while this slot sat above the editor - there, appearing and disappearing would have
+	// shifted the input box under the user's hands, which is why the idle row existed.
+	if (faded(run, now)) return [];
+
+	// The panel already draws all of this, and it took the editor's slot to do it. The width
+	// guard rides along: below two gutters plus a couple of columns there is nothing to say, and
+	// a blank line of the right height beats a two-column line in a one-column terminal.
+	if (panelIsOpen || total < PAD * 2 + 4) return [" ".repeat(total)];
+
+	// The `❯` column comes off the list's width, so a marked row is exactly as wide as the rest.
+	return layoutList(total - MARK, run, now, budget).map((row) => {
+		// `head` is plain text, and everything left of the dot is `└`, a space, or a name
+		// matching ^[a-z0-9][a-z0-9._-]*$ — so a visible column and a code-unit index are the
+		// same number here and slicing cannot cut a character in half.
+		const head =
+			row.dotAt >= 0
+				? paint("dim", row.head.slice(0, row.dotAt)) +
+					paint(tone(row.branch), row.head.slice(row.dotAt, row.dotAt + 1)) +
+					paint(row.branch ? "text" : "dim", row.head.slice(row.dotAt + 1))
+				: paint("dim", row.head);
+		const mark = (row.branch ? row.branch.stem === cursor : !cursor && row.dotAt === 0) ? paint("accent", "❯ ") : "  ";
+		return " ".repeat(PAD) + mark + head + paint("muted", row.activity) + row.fill + paint("dim", row.right) + " ".repeat(PAD);
+	});
+};

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/bar.check.ts

@@ -0,0 +1,198 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { MAX_ROWS, layoutList, renderKey, renderLines } from "./bar/bar-line.ts";
+import type { BranchView, RunState } from "./skills/delegate/state.ts";
+
+// The widget sits directly above the input box, so two things can hurt and both are checked
+// here rather than argued in a comment:
+//
+//   1. a composed line one column too wide wraps in the terminal and pushes the box down
+//   2. the `❯` column pushing a row past the width does the same
+//
+// Everything under test is pure, so this needs no terminal, no theme and no pi.
+// Run with: bun run bar.check.ts
+
+// A function declaration, not a const arrow: TypeScript only narrows past a never-returning
+// call when it is declared this way, and every assertion below relies on that narrowing.
+function fail(message: string): never {
+	throw new Error(message);
+}
+
+// SAFETY: only the fields the layouts read are populated; every one of them is here.
+const branch = (over: Partial<BranchView> = {}): BranchView =>
+	({
+		phase: "map",
+		name: "general-purpose",
+		parent: null,
+		index: 1,
+		model: "Opus 5",
+		pid: 4242,
+		status: "running",
+		activity: "Grepping localStorage keys in office-persist.ts",
+		tokens: 56_500,
+		startedAt: 0,
+		updatedAt: 232_000,
+		report: null,
+		error: null,
+		stem: "map-general-purpose",
+		label: "map:general-purpose",
+		depth: 0,
+		elapsedMs: 232_000, // 3m 52s
+		idleMs: 0,
+		exitCode: null,
+		timedOut: false,
+		alive: true,
+		settled: false,
+		...over,
+	}) as BranchView;
+
+const run = (over: Partial<RunState> = {}): RunState =>
+	({
+		dir: ".pi-out/20260905-030000",
+		name: "pi-toolcall-render",
+		description: "Map how pi renders tool calls and whether an extension can override it",
+		startedAt: 0,
+		phases: ["map", "design"],
+		activePhase: 0,
+		branches: [],
+		done: 2,
+		total: 4,
+		tokens: 397_800,
+		live: true,
+		...over,
+	}) as RunState;
+
+const now = 278_000; // 4m 38s
+
+// A phased run draws the same list as a flat one; the panel is where its phases are.
+const phased = run({ branches: [branch()] });
+// A finished run inside its linger window, and the same run once it has faded.
+const settled = run({ live: false, done: 4, branches: [branch({ updatedAt: now, settled: true, alive: false })] });
+
+// ---------- reference 3, the flat list ----------
+
+const flat = run({
+	phases: ["map"], // one phase: no workflow to collapse, so this is the list case
+	done: 0,
+	total: 2,
+	branches: [
+		branch(),
+		branch({
+			name: "Explore",
+			stem: "map-explore",
+			label: "map:Explore",
+			depth: 1,
+			parent: "map-general-purpose",
+			index: 2,
+			activity: "Confirming store.ts is unused",
+			tokens: 86_300,
+			elapsedMs: 172_000, // 2m 52s
+			// Hollow in the reference while its sibling is filled, and a branch that has not
+			// emitted for a quarter of a minute is the one state that can honestly produce that.
+			// The screen cannot tell us which of the two it was; the rule has to mean something,
+			// so it means the thing the panel already tracks.
+			idleMs: 20_000,
+		}),
+	],
+});
+
+for (let width = 8; width <= 200; width++) {
+	for (const state of [flat, undefined, settled]) {
+		const rows = layoutList(width, state, now, MAX_ROWS);
+		if (rows.length === 0) fail(`list width ${width}: zero rows un-mounts the widget`);
+		for (const row of rows) {
+			const used =
+				visibleWidth(row.head) + visibleWidth(row.activity) + row.fill.length + visibleWidth(row.right);
+			if (used !== width - 2) fail(`list width ${width}: row composed ${used}, expected ${width - 2}`);
+		}
+		// The activity column has to start in the same place on every row, or the sentences
+		// stagger and the list stops being readable at a glance.
+		const heads = new Set(rows.map((row) => visibleWidth(row.head)));
+		if (heads.size !== 1) fail(`list width ${width}: ragged head column ${[...heads].join()}`);
+	}
+}
+
+const list = layoutList(100, flat, now, MAX_ROWS);
+if (list.length !== 3) fail(`expected main + two agents, got ${list.length}`);
+// SAFETY: length checked immediately above.
+const [main, first, nested] = list as [(typeof list)[0], (typeof list)[0], (typeof list)[0]];
+if (main.head.trimEnd() !== "○ main") fail(`main row: ${JSON.stringify(main.head)}`);
+if (main.branch !== undefined) fail("the main row is not a branch");
+if (main.activity !== "" || main.right.trim() !== "") fail("the main row carries counters the reference does not show");
+if (first.head.trimEnd() !== "● general-purpose") fail(`agent row: ${JSON.stringify(first.head)}`);
+if (first.dotAt !== 0) fail(`dot column on a top-level row: ${first.dotAt}`);
+if (!first.activity.endsWith("Grepping localStorage keys in office-persist.ts")) fail(`activity: ${first.activity}`);
+if (first.right !== "3m 52s · ↓ 56.5k tokens") fail(`right column: ${JSON.stringify(first.right)}`);
+if (nested.head.trimEnd() !== "└ ○ Explore") fail(`nested row: ${JSON.stringify(nested.head)}`);
+if (nested.dotAt !== 2) fail(`dot column on a nested row: ${nested.dotAt}`);
+if (nested.right !== "2m 52s · ↓ 86.3k tokens") fail(`nested right column: ${JSON.stringify(nested.right)}`);
+
+// An idle session is one bare row.
+const idle = layoutList(100, undefined, now, MAX_ROWS);
+if (idle.length !== 1 || idle[0]?.head.trimEnd() !== "○ main") fail("idle is not exactly one `○ main` row");
+if (layoutList(100, settled, now + 31_000, MAX_ROWS).length !== 1) fail("finished run outstayed LINGER_MS in the list");
+
+// A quiet branch goes hollow, a working one is filled, and the row budget is a ceiling rather
+// than a suggestion.
+const quiet = layoutList(100, run({ phases: ["map"], branches: [branch({ idleMs: 60_000 })] }), now, MAX_ROWS);
+if (!quiet[1]?.head.startsWith("○")) fail(`an idle branch kept its filled dot: ${quiet[1]?.head}`);
+
+const many = run({ phases: ["map"], branches: Array.from({ length: 40 }, (_, i) => branch({ stem: `map-b${i}` })) });
+const capped = layoutList(100, many, now, MAX_ROWS);
+if (capped.length !== MAX_ROWS) fail(`row budget ignored: ${capped.length}`);
+if (!capped[MAX_ROWS - 1]?.head.startsWith("+33 more")) fail(`no overflow row: ${capped[MAX_ROWS - 1]?.head}`);
+if (capped[MAX_ROWS - 1]?.dotAt !== -1) fail("the overflow row was given a status dot");
+// A budget of one is `○ main` and nothing else, not `○ main` plus an apology.
+if (layoutList(100, many, now, 1).length !== 1) fail("a one-row budget grew a second row");
+if (layoutList(100, many, now, 2).length !== 2) fail("a two-row budget is main plus the overflow");
+
+// ---------- the fixed-height rule ----------
+
+const paint = (_color: unknown, text: string) => text; // identity: measure the plain frame
+for (let width = 0; width <= 200; width++) {
+	// Every path through renderLines, at every width, with the cursor on main and on an agent.
+	for (const [label, lines] of [
+		["phased", renderLines(width, phased, now, MAX_ROWS, paint)],
+		["cursor on an agent", renderLines(width, flat, now, MAX_ROWS, paint, false, "map-explore")],
+		["panel open", renderLines(width, phased, now, MAX_ROWS, paint, true)],
+		["idle", renderLines(width, undefined, now, MAX_ROWS, paint)],
+		["list", renderLines(width, flat, now, MAX_ROWS, paint)],
+		["faded", renderLines(width, settled, now + 31_000, MAX_ROWS, paint)],
+	] as [string, string[]][]) {
+		// idle and faded now draw NOTHING, at every width, and that is the assertion - not a
+		// blank line. The slot is belowEditor, where pi passes spacerWhenEmpty and leadingSpacer
+		// both false, so zero lines is zero rows and the footer above never moves. The check
+		// runs width 0..200 because the faded test sits ahead of the narrow-terminal guard;
+		// putting it after would have made a 5-column terminal the one place a bare row survived.
+		if (label === "idle" || label === "faded") {
+			if (lines.length !== 0) fail(`${label} drew ${lines.length} lines at width ${width}, expected none`);
+		} else if (lines.length < 1) {
+			fail(`${label} rendered nothing at width ${width}`);
+		}
+		for (const line of lines) {
+			if (visibleWidth(line) !== Math.max(0, width)) fail(`${label} overflowed at width ${width}: ${line.length}`);
+		}
+	}
+}
+if (renderLines(80, phased, now, MAX_ROWS, paint, true)[0]?.trim() !== "") fail("the open panel did not blank the widget");
+
+// ---------- the cursor ----------
+
+// `❯` sits on `○ main` while the user types, and on exactly one agent once they move down.
+const onMain = renderLines(100, flat, now, MAX_ROWS, paint);
+if (!onMain[0]?.startsWith(" ❯ ○ main")) fail(`no cursor on main: ${onMain[0]}`);
+if (onMain.filter((line) => line.includes("❯")).length !== 1) fail("more than one cursor with none chosen");
+const onAgent = renderLines(100, flat, now, MAX_ROWS, paint, false, "map-explore");
+if (!onAgent[2]?.startsWith(" ❯ └ ○ Explore")) fail(`cursor not on the chosen agent: ${onAgent[2]}`);
+if (onAgent.filter((line) => line.includes("❯")).length !== 1) fail("the cursor stayed on main as well");
+if (!renderLines(100, phased, now, MAX_ROWS, paint)[1]?.includes("● general-purpose")) fail("a phased run did not draw its agents");
+
+// ---------- the no-op frame ----------
+
+if (renderKey(flat, now) !== renderKey(flat, now)) fail("render key is not stable");
+if (renderKey(undefined, now) !== "-") fail("an empty screen is not one key");
+if (renderKey(settled, now + 31_000) !== "-") fail("a faded run is not the empty screen");
+if (renderKey(flat, now) === renderKey(flat, now + 1_000)) fail("the clock moved and the key did not");
+const rewritten = run({ ...flat, branches: [branch({ activity: "Reading hooks.server.ts and app.d.ts" }), ...flat.branches.slice(1)] });
+if (renderKey(flat, now) === renderKey(rewritten, now)) fail("the activity sentence changed and the key did not");
+
+console.log("ok");