@pi-archimedes/core 2.10.4 → 2.11.0

package/src/settings-io.test.ts

@@ -17,7 +17,7 @@ vi.mock("@earendil-works/pi-coding-agent", () => ({
 }));
 
 // Import after mocks are set up
-const { loadConfig, saveConfig, removeConfig, isConfigEnabled, setConfigEnabled, updateConfig } = await import("./settings-io.js");
+const { loadConfig, saveConfig, removeConfig, isConfigEnabled, setConfigEnabled, updateConfig, readEffectiveSettings } = await import("./settings-io.js");
 
 describe("removeConfig", () => {
   beforeEach(() => {
@@ -468,3 +468,176 @@ describe("symlink preservation", () => {
     expect(data["archimedes.test"]).toEqual({ d: 4 });
   });
 });
+
+// ── readEffectiveSettings ───────────────────────────────────────────────────
+//
+// `loadConfig` reads `~/.pi/agent/settings.json` by hand, which cannot see
+// project-scoped settings or overrides. `pi.getSettings()` returns the merged
+// effective object, so it is the right source when the running pi has it — and
+// the file read is the fallback that keeps core's peer floor where ADR 0013 put
+// it (getSettings is an ExtensionAPI method that older pi does not expose).
+// Note the direction of the whole thing: this is a READER. The writer stays on
+// the hand-rolled symlink-preserving path because pi has no public write API.
+
+describe("readEffectiveSettings", () => {
+  const settingsPath = () => join(tempDir, "settings.json");
+
+  beforeEach(() => {
+    const p = settingsPath();
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  });
+
+  afterEach(() => {
+    const p = settingsPath();
+    try { fs.unlinkSync(p); } catch { /* ignore */ }
+    try { fs.unlinkSync(p + ".tmp"); } catch { /* ignore */ }
+  });
+
+  it("returns pi.getSettings() when the host exposes it", () => {
+    const pi = { getSettings: () => ({ "archimedes.web": { braveApiKey: "from-host" } }) };
+    expect(readEffectiveSettings(pi)).toEqual({ "archimedes.web": { braveApiKey: "from-host" } });
+  });
+
+  it("its value wins over settings.json (project scope and overrides are invisible to the file read)", () => {
+    fs.writeFileSync(
+      settingsPath(),
+      JSON.stringify({ "archimedes.web": { braveApiKey: "from-file" } }),
+      "utf-8",
+    );
+    const pi = { getSettings: () => ({ "archimedes.web": { braveApiKey: "from-effective" } }) };
+    const result = readEffectiveSettings(pi) as { "archimedes.web": { braveApiKey: string } };
+    expect(result["archimedes.web"].braveApiKey).toBe("from-effective");
+  });
+
+  it("falls back to the file read when the handle has no getSettings (a pi older than the API)", () => {
+    fs.writeFileSync(
+      settingsPath(),
+      JSON.stringify({ "archimedes.web": { braveApiKey: "from-file" } }),
+      "utf-8",
+    );
+    const result = readEffectiveSettings({}) as { "archimedes.web": { braveApiKey: string } };
+    expect(result["archimedes.web"].braveApiKey).toBe("from-file");
+  });
+
+  it("falls back to the file read when no handle is passed at all", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { a: 1 } }), "utf-8");
+    expect(readEffectiveSettings()).toEqual({ "test.ns": { a: 1 } });
+    expect(readEffectiveSettings(undefined)).toEqual({ "test.ns": { a: 1 } });
+    expect(readEffectiveSettings(null)).toEqual({ "test.ns": { a: 1 } });
+  });
+
+  it("treats a non-function getSettings property as absent", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { a: 1 } }), "utf-8");
+    expect(readEffectiveSettings({ getSettings: "not a function" })).toEqual({ "test.ns": { a: 1 } });
+  });
+
+  it("falls back when getSettings() throws — pi asserts an active extension context and can refuse", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { a: 1 } }), "utf-8");
+    const pi = {
+      getSettings: () => {
+        throw new Error("Extension is not active");
+      },
+    };
+    expect(() => readEffectiveSettings(pi)).not.toThrow();
+    expect(readEffectiveSettings(pi)).toEqual({ "test.ns": { a: 1 } });
+  });
+
+  it("falls back when getSettings() returns something unusable (null / undefined / a scalar)", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { a: 1 } }), "utf-8");
+    expect(readEffectiveSettings({ getSettings: () => undefined })).toEqual({ "test.ns": { a: 1 } });
+    expect(readEffectiveSettings({ getSettings: () => null })).toEqual({ "test.ns": { a: 1 } });
+    expect(readEffectiveSettings({ getSettings: () => 42 })).toEqual({ "test.ns": { a: 1 } });
+  });
+
+  it("returns an empty object for malformed JSON with no handle (existing loadConfig behaviour preserved)", () => {
+    fs.writeFileSync(settingsPath(), "{ invalid json }", "utf-8");
+    expect(readEffectiveSettings()).toEqual({});
+    // …and the malformed file still does not break the namespaced reader.
+    expect(loadConfig("test.ns", { foo: "bar" })).toEqual({ foo: "bar" });
+  });
+
+  it("returns {} when there is no file and no handle", () => {
+    expect(fs.existsSync(settingsPath())).toBe(false);
+    expect(readEffectiveSettings()).toEqual({});
+  });
+
+  it("never writes: it is a reader, so the file and the writer's tmp path are untouched", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { a: 1 } }), "utf-8");
+    const before = fs.readFileSync(settingsPath(), "utf-8");
+    const beforeMtimeMs = fs.statSync(settingsPath()).mtimeMs;
+    readEffectiveSettings({});
+    readEffectiveSettings({ getSettings: () => ({}) });
+    expect(fs.readFileSync(settingsPath(), "utf-8")).toBe(before);
+    expect(fs.statSync(settingsPath()).mtimeMs).toBe(beforeMtimeMs);
+    expect(fs.existsSync(settingsPath() + ".tmp")).toBe(false);
+  });
+
+  it("never creates settings.json when it is absent", () => {
+    readEffectiveSettings({});
+    expect(fs.existsSync(settingsPath())).toBe(false);
+  });
+
+  it("does not disturb the writer: saveConfig still round-trips after an effective read", () => {
+    readEffectiveSettings({ getSettings: () => ({ "test.ns": { from: "host" } }) });
+    saveConfig("test.ns", { from: "file" });
+    expect(loadConfig("test.ns", { from: "" })).toEqual({ from: "file" });
+  });
+});
+
+// ── The catch must not be invisible ────────────────────────────────────────
+//
+// `pi.getSettings()` refuses for the expected reason (the handle's wrapper
+// asserts an active extension context) AND for reasons that are bugs: the
+// runtime stub throws "Extension runtime not initialized" for a call made
+// during extension loading, and the real implementation can throw for anything
+// it chokes on. Falling back to the file is right in every case; falling back
+// without a trace is not, because the symptom of each of those is a silently
+// project-blind settings read.
+
+describe("readEffectiveSettings reports the reason it fell back", () => {
+  const ENV = "PI_ARCHIMEDES_LOG";
+  const settingsPath = () => join(tempDir, "settings.json");
+  const previous = process.env[ENV];
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env[ENV];
+    else process.env[ENV] = previous;
+    const p = settingsPath();
+    try { fs.unlinkSync(p); } catch { /* ignore */ }
+  });
+
+  it("logs the error when getSettings() throws, and still returns the file read", () => {
+    const target = join(tempDir, "effective-fallback.log");
+    process.env[ENV] = target;
+    fs.writeFileSync(
+      settingsPath(),
+      JSON.stringify({ "test.ns": { from: "file" } }),
+      "utf-8",
+    );
+
+    const pi = {
+      getSettings: () => {
+        throw new Error("Extension runtime not initialized");
+      },
+    };
+    expect(readEffectiveSettings(pi)).toEqual({ "test.ns": { from: "file" } });
+
+    const logged = fs.readFileSync(target, "utf-8");
+    expect(logged).toContain("[core]");
+    expect(logged).toContain("Extension runtime not initialized");
+    // With the stack, which is the part that says which call site did it.
+    expect(logged).toMatch(/\n\s+at\s+\S/);
+  });
+
+  it("says nothing on the normal paths (supported host, older pi, no handle)", () => {
+    const target = join(tempDir, "effective-quiet.log");
+    process.env[ENV] = target;
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { a: 1 } }), "utf-8");
+
+    readEffectiveSettings({ getSettings: () => ({ "test.ns": { a: 2 } }) });
+    readEffectiveSettings({});
+    readEffectiveSettings();
+
+    expect(fs.existsSync(target)).toBe(false);
+  });
+});

package/src/settings-io.ts

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, existsSync, renameSync, unlinkSync, lstatSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { diag, describeError } from "./log.js";
 
 const SETTINGS_PATH = join(getAgentDir(), "settings.json");
 
@@ -33,6 +34,59 @@ function readSettings(): Record<string, unknown> {
   return parseSettings(readRawSettings());
 }
 
+/**
+ * Read the settings the running pi actually applies: `pi.getSettings()` when
+ * the host exposes it, otherwise the file read.
+ *
+ * `getSettings()` returns the *effective* object — global settings merged with
+ * project settings (`<cwd>/.pi/settings.json`) and any in-process overrides —
+ * which a hand-rolled read of `~/.pi/agent/settings.json` cannot see. It lives
+ * on **`ExtensionAPI`**, not on `ExtensionContext` (`extensions/types.d.ts:1286`
+ * in pi 1.2.0), so a call site must pass the `pi` handle, never `ctx`.
+ *
+ * The fallback is not decoration: it is what keeps `core`'s peer floor at
+ * `>=0.85.0` (ADR 0013 / ADR 0026), because `getSettings` is younger than that
+ * floor. It also covers pi refusing the call — the handle's wrapper asserts an
+ * active extension context and throws otherwise — and a host that hands back
+ * something that is not an object. Anything unusable falls through to the file,
+ * and a *thrown* refusal is recorded in the log on the way: the same catch hides
+ * a call made before the runtime bound itself, whose only symptom would be a
+ * settings read that quietly cannot see project scope.
+ *
+ * Reads only. There is no matching write path: pi exposes no public settings
+ * writer, so `saveConfig` keeps its symlink-preserving tmp+rename behaviour
+ * (docs/features/symlink-preserving-settings-writes.md).
+ *
+ * @param pi the `ExtensionAPI` handle, or nothing at all (headless call sites,
+ *           tests, and every pi without the API).
+ */
+export function readEffectiveSettings(pi?: unknown): Record<string, unknown> {
+  const getSettings = (pi as { getSettings?: unknown } | null | undefined)?.getSettings;
+  if (typeof getSettings === "function") {
+    try {
+      const effective = (getSettings as () => unknown).call(pi);
+      // An object is the only usable answer; `undefined`/`null`/a scalar mean
+      // the host had nothing to say, which is the file read's job.
+      if (typeof effective === "object" && effective !== null && !Array.isArray(effective)) {
+        return effective as Record<string, unknown>;
+      }
+    } catch (err) {
+      // pi asserts the extension is active before answering, so the call can
+      // refuse. A settings read is never allowed to be the reason something
+      // failed, so fall through to the file — but never fall through silently:
+      // the same catch also swallows the handle's "runtime not initialized"
+      // stub (a call made too early, i.e. a bug) and anything the real
+      // implementation chokes on, and every one of those looks like nothing
+      // more than a settings read that cannot see project scope.
+      diag(
+        "core",
+        `[archimedes:settings-io] getSettings() refused; falling back to settings.json: ${describeError(err)}`,
+      );
+    }
+  }
+  return readSettings();
+}
+
 /**
  * Load a config section from settings.json, merged with defaults.
  */

package/src/text.test.ts

@@ -61,6 +61,64 @@ describe("stripAnsi", () => {
   });
 });
 
+// ── stripAnsi regression fence ───────────────────────────────────────────────
+//
+// stripAnsi is a wrapper, not a delegation: the startup section parser and the
+// footer both consume its output, and they depend on the *whole* pattern set
+// (pi-tui's stripTerminalSequences leaves DCS / SOS / PM and the charset
+// designators in place, and it never trims). These assertions are the fence
+// that keeps the wrapper honest — they must read the same before and after the
+// pi-tui migration, and the DCS/SOS/APC/PM/charset/trim cases below are the
+// ones a pure delegation would break.
+
+describe("stripAnsi (wrapper fence)", () => {
+  it("strips a DCS string terminated by ST as well as by BEL", () => {
+    expect(stripAnsi("before\x1bPq;status\x1b\\after")).toBe("beforeafter");
+  });
+
+  it("strips an APC string terminated by ST", () => {
+    expect(stripAnsi("before\x1b_privacy\x1b\\after")).toBe("beforeafter");
+  });
+
+  it("strips a SOS string terminated by ST", () => {
+    expect(stripAnsi("before\x1b^message\x1b\\after")).toBe("beforeafter");
+  });
+
+  it("strips both charset designators and keeps the designator byte it names", () => {
+    // Same shape as the case above: the pattern drops `ESC (` / `ESC )` and
+    // leaves the designator character, which is what the section parser saw
+    // before the wrapper existed.
+    expect(stripAnsi("\x1b(B\x1b)0plain")).toBe("B0plain");
+  });
+
+  it("strips pi's own control sequences, so callers see only what is drawn", () => {
+    // A captured frame line: SGR + the cursor marker (APC) + an OSC 8 link.
+    const line = `\x1b[38;2;9;9;9m  ${"日本語"}\x1b[0m\x1b_pi:c\x07`;
+    expect(stripAnsi(line)).toBe("日本語");
+  });
+
+  it("trims the padding a surface left behind the styling", () => {
+    expect(stripAnsi("\x1b[90m│\x1b[0m   \n")).toBe("│");
+  });
+});
+
+// ── stripAnsi: what the pi-tui pass adds ────────────────────────────────────
+//
+// The only *new* coverage the wrapper buys: a CSI sequence whose parameters use
+// the `:` sub-parameter form, which our `[0-9;?]*` run stops at. Before the
+// wrapper such an escape survived into the section parser's input; it is not
+// part of the fence above.
+
+describe("stripAnsi (pi-tui pass)", () => {
+  it("strips an SGR sequence whose parameters use the colon form", () => {
+    expect(stripAnsi("\x1b[38:2:255:0:0mred\x1b[0m")).toBe("red");
+  });
+
+  it("strips a private-mode CSI our pattern does not describe", () => {
+    expect(stripAnsi("\x1b[>4;2mhello\x1b[0m")).toBe("hello");
+  });
+});
+
 // ── isParentBorder ──────────────────────────────────────────────────────────
 
 describe("isParentBorder", () => {

package/src/text.ts

@@ -1,36 +1,37 @@
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
 
 // Inline stripSgr — narrow SGR-only strip (no trim) for char-level checks
 const stripSgr = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
 
 /**
- * Strip ALL ANSI escape sequences. Covers:
+ * Strip ALL ANSI escape sequences and trim. Covers:
  * - CSI: ESC [ ... letter (SGR, cursor movement, etc.)
- * - OSC: ESC ] ... ST (operating system commands)
+ * - OSC: ESC ] ... ST (operating system commands, OSC 8 hyperlinks)
  * - DCS: ESC P ... ST (device control strings)
- * - APC: ESC _ ... ST (application program commands)
+ * - APC: ESC _ ... ST (application program commands — pi's CURSOR_MARKER)
  * - SOS: ESC ^ ... ST (start of string)
  * - PM:  ESC \x5c ... ST (privacy message)
  * - Character set: ESC ( or ESC ) (DECSET/DECRST)
+ *
+ * This is a wrapper, not a delegation, and the **local pattern set is the
+ * load-bearing half**. pi-tui's `stripTerminalSequences` leaves DCS, SOS, PM and
+ * the charset designators in place and never trims, so delegating to it alone
+ * would feed control bytes — and stray padding — to the startup section parser
+ * (`ui/src/startup/sections.ts`) and the footer, both of which parse this
+ * output. The `stripTerminalSequences` pass that follows is the backstop for the
+ * sequences our patterns do *not* describe, chiefly the colon sub-parameter
+ * form of SGR (`\x1b[38:2:R:G:Bm`) and other private CSI shapes, which would
+ * otherwise survive into the parsed text.
+ *
  * Trims whitespace. Use for text extraction.
  */
 export function stripAnsi(s: string): string {
-  return s
-    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "")   // CSI
-    .replace(/\x1b\].*?(?:\x07|\x1b\\)/g, "")  // OSC
-    .replace(/\x1b[P^_\x5c].*?(?:\x07|\x1b\\)/g, "") // DCS, SOS, APC, PM
-    .replace(/\x1b[()]/g, "")                   // character set
-    .trim();
-}
-
-/** Clamp a line to maxW visible characters, preserving ANSI escapes. */
-export function clampLine(line: string, maxW: number): string {
-  return truncateToWidth(line, maxW);
-}
-
-/** Clamp an array of lines to maxW visible characters each. */
-function clampLines(lines: string[], maxW: number): string[] {
-  return lines.map((l) => clampLine(l, maxW));
+  const ours = s
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "")            // CSI
+    .replace(/\x1b\].*?(?:\x07|\x1b\\)/g, "")           // OSC
+    .replace(/\x1b[P^_\x5c].*?(?:\x07|\x1b\\)/g, "")    // DCS, SOS, APC, PM
+    .replace(/\x1b[()]/g, "");                          // character set
+  return stripTerminalSequences(ours).trim();
 }
 
 // isParentBorder uses the narrow SGR-only strip (no trim) for char-level checks

package/src/tool-render.test.ts

@@ -4,6 +4,7 @@ import {
   renderStatusLabel,
   renderToolCallLine,
   STATUS_GLYPH,
+  toolRowDuration,
   type ToolRenderTheme,
 } from "./tool-render.js";
 
@@ -77,3 +78,50 @@ describe("renderToolCallLine", () => {
     );
   });
 });
+
+describe("toolRowDuration", () => {
+  it("takes a settled row's duration from the result, so it survives a session reload", () => {
+    // A row re-rendered from a stored session has no renderer state at all —
+    // only the duration the result recorded.
+    expect(toolRowDuration({ durationMs: 4200 }, { isPartial: false })).toEqual({
+      label: "Took",
+      ms: 4200,
+    });
+  });
+
+  it("prefers the recorded duration over the row's own clock, so wall-clock steps are excluded", () => {
+    // The row started 90s of real time ago; the tool itself reported 1.5s.
+    const startedAt = Date.now() - 90_000;
+    expect(toolRowDuration({ durationMs: 1500, startedAt }, { isPartial: false })).toEqual({
+      label: "Took",
+      ms: 1500,
+    });
+  });
+
+  it("counts from the row's own clock while the result is still partial", () => {
+    const startedAt = Date.now() - 2500;
+    const out = toolRowDuration({ startedAt }, { isPartial: true });
+    expect(out?.label).toBe("Elapsed");
+    expect(out?.ms).toBeGreaterThanOrEqual(2400);
+    expect(out?.ms).toBeLessThan(5000);
+  });
+
+  it("falls back to the row's clock for a settled result that recorded no duration", () => {
+    expect(
+      toolRowDuration({ startedAt: Date.now() - 1000, endedAt: Date.now() }, { isPartial: false }),
+    ).toMatchObject({ label: "Took" });
+  });
+
+  it("says nothing about a row that never started and recorded nothing", () => {
+    expect(toolRowDuration({}, { isPartial: false })).toBeUndefined();
+    expect(toolRowDuration({}, { isPartial: true })).toBeUndefined();
+  });
+
+  it("finalises an errored row from its clock even while the result is partial", () => {
+    const out = toolRowDuration(
+      { startedAt: Date.now() - 800, endedAt: Date.now() },
+      { isPartial: true, isError: true },
+    );
+    expect(out?.label).toBe("Took");
+  });
+});

package/src/tool-render.ts

@@ -99,3 +99,47 @@ export function renderToolCallLine(
     theme.fg(token, STATUS_GLYPH[status] + " ") + theme.fg(token, name);
   return suffix ? head + theme.fg("dim", suffix) : head;
 }
+
+/** What a row knows about how long its tool took. */
+export interface ToolRowTiming {
+  /** Milliseconds the tool recorded on its final result, if it recorded any. */
+  durationMs?: number | undefined;
+  /** When this row first saw the call running, from the row's own clock. */
+  startedAt?: number | undefined;
+  /** When the row saw the call settle, from the row's own clock. */
+  endedAt?: number | undefined;
+}
+
+/** The timing line of a tool row: which word to use, and how long to show. */
+export interface ToolRowDuration {
+  label: "Elapsed" | "Took";
+  ms: number;
+}
+
+/**
+ * The duration line a tool row shows, following pi's own rows:
+ *
+ * - A settled result carries `durationMs`, measured by the tool. That number
+ *   wins, because it is monotonic, it excludes whatever the row was doing
+ *   between the call and the paint, and it is still there when the session is
+ *   reloaded and the row's own clock is gone.
+ * - While the result is still partial the row counts from its own clock
+ *   (`Elapsed`).
+ * - A settled result that recorded no duration falls back to the row's clock.
+ * - A row that never saw the call start and recorded nothing says nothing.
+ *
+ * `isError` finalises the row: a failed call is not still running, whatever the
+ * partial flag says.
+ */
+export function toolRowDuration(
+  timing: ToolRowTiming,
+  options: { isPartial: boolean; isError?: boolean },
+): ToolRowDuration | undefined {
+  const settled = !options.isPartial || options.isError === true;
+  if (settled && typeof timing.durationMs === "number") {
+    return { label: "Took", ms: Math.max(0, timing.durationMs) };
+  }
+  if (timing.startedAt === undefined) return undefined;
+  const end = timing.endedAt ?? Date.now();
+  return { label: settled ? "Took" : "Elapsed", ms: Math.max(0, end - timing.startedAt) };
+}

package/src/bus.test.ts

@@ -1,154 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { getBus, initBus, Events } from "./bus.js";
-
-// ── globalThis cleanup ──────────────────────────────────────────────────────
-
-const BUS_KEY = Symbol.for("archimedes:bus");
-const QUEUE_KEY = Symbol.for("archimedes:busQueue");
-
-afterEach(() => {
-  // Reset globalThis bus and queue to avoid test pollution
-  delete (globalThis as Record<symbol, unknown>)[BUS_KEY];
-  delete (globalThis as Record<symbol, unknown>)[QUEUE_KEY];
-});
-
-// ── emit → on delivery ─────────────────────────────────────────────────────
-
-describe("emit → on delivery", () => {
-  it("subscriber receives payload", () => {
-    const bus = getBus();
-    const received: unknown[] = [];
-    bus.on("test:event", (payload) => received.push(payload));
-    bus.emit("test:event", { hello: "world" });
-    expect(received).toEqual([{ hello: "world" }]);
-  });
-});
-
-// ── multiple subscribers ────────────────────────────────────────────────────
-
-describe("multiple subscribers", () => {
-  it("all receive the event", () => {
-    const bus = getBus();
-    const a: unknown[] = [];
-    const b: unknown[] = [];
-    bus.on("multi", (p) => a.push(p));
-    bus.on("multi", (p) => b.push(p));
-    bus.emit("multi", "shared");
-    expect(a).toEqual(["shared"]);
-    expect(b).toEqual(["shared"]);
-  });
-});
-
-// ── unsubscribe ─────────────────────────────────────────────────────────────
-
-describe("unsubscribe", () => {
-  it("removed subscriber does not receive subsequent events", () => {
-    const bus = getBus();
-    const received: unknown[] = [];
-    const unsub = bus.on("unsub:test", (p) => received.push(p));
-    bus.emit("unsub:test", "first");
-    unsub();
-    bus.emit("unsub:test", "second");
-    expect(received).toEqual(["first"]);
-  });
-});
-
-// ── error isolation ─────────────────────────────────────────────────────────
-
-describe("error isolation", () => {
-  it("one listener throwing does not prevent others from receiving", () => {
-    const bus = getBus();
-    const received: unknown[] = [];
-    bus.on("err:test", () => {
-      throw new Error("boom");
-    });
-    bus.on("err:test", (p) => received.push(p));
-    bus.emit("err:test", "payload");
-    expect(received).toEqual(["payload"]);
-  });
-});
-
-// ── late subscriber queue ───────────────────────────────────────────────────
-
-describe("late subscriber queue", () => {
-  it("events emitted before on() are delivered when subscriber registers", () => {
-    // Create a fresh bus
-    const bus = getBus();
-
-    // Emit before anyone subscribes — this queues the event
-    bus.emit("queued:event", "queued-payload");
-
-    // Now subscribe — queued events should be delivered
-    const received: unknown[] = [];
-    bus.on("queued:event", (p) => received.push(p));
-
-    expect(received).toEqual(["queued-payload"]);
-  });
-});
-
-// ── initBus ─────────────────────────────────────────────────────────────────
-
-describe("initBus", () => {
-  it("flushes queued events to subscribers that registered before init", () => {
-    // Emit before any subscriber exists — queues the event
-    const bus = getBus();
-    bus.emit("init:test", "queued-value");
-
-    // Subscribe — on() drains queue and delivers
-    const received: unknown[] = [];
-    bus.on("init:test", (p) => received.push(p));
-    expect(received).toEqual(["queued-value"]);
-  });
-
-  it("initBus re-emits queued events through the bus", () => {
-    // Emit with no subscriber — queues
-    const bus = getBus();
-    bus.emit("init:test2", "queued");
-
-    // initBus re-emits through the bus
-    initBus();
-
-    // Since no subscriber for test2, re-emit goes back to queue.
-    // Now subscribe — on() drains the re-queued event
-    const received: unknown[] = [];
-    bus.on("init:test2", (p) => received.push(p));
-    expect(received).toEqual(["queued"]);
-  });
-
-  it("initBus snapshots and clears queue before iterating", () => {
-    // Emit with no subscriber — queues
-    const bus = getBus();
-    bus.emit("snapshot:test", "a");
-    bus.emit("snapshot:test", "b");
-
-    // Subscribe — on() drains queue and delivers (but queue array persists)
-    const received: unknown[] = [];
-    bus.on("snapshot:test", (p) => received.push(p));
-    expect(received).toEqual(["a", "b"]);
-
-    // Queue array still has items (on() delivers but doesn't remove)
-    const queueBefore = (globalThis as Record<symbol, unknown>)[QUEUE_KEY] as Array<unknown>;
-    expect(queueBefore.length).toBe(2);
-
-    // initBus snapshots, clears queue, and re-emits
-    initBus();
-    // Re-emits go to existing subscriber (not re-queued)
-    expect(received).toEqual(["a", "b", "a", "b"]);
-
-    // Queue is now empty (initBus cleared it)
-    const queueAfter = (globalThis as Record<symbol, unknown>)[QUEUE_KEY] as Array<unknown>;
-    expect(queueAfter.length).toBe(0);
-  });
-});
-
-// ── Events constant ─────────────────────────────────────────────────────────
-
-describe("Events constant", () => {
-  it("all event names are defined", () => {
-    expect(Events.COST_UPDATE).toBe("archimedes:cost_update");
-    expect(Events.TODOS_UPDATE).toBe("archimedes:todos_update");
-    expect(Events.TODOS_CLEAR).toBe("archimedes:todos_clear");
-    expect(Events.ASK_REQUEST).toBe("archimedes:ask_request");
-    expect(Events.ASK_RESPONSE).toBe("archimedes:ask_response");
-  });
-});