@pi-archimedes/core 2.10.4 → 2.11.1

package/src/chrome.ts

@@ -1,4 +1,10 @@
-import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { Theme, ThemeAppearance, ThemeColor } from "@earendil-works/pi-coding-agent";
+// A namespace import, deliberately: `foregroundAnsi` is pi-tui 1.x, and a named
+// import of a name an older host never exported fails when the module *links* —
+// before any of this package runs, taking the palette and everyone who imports it
+// down. ADR 0026's rule is to warn about an old host, never break it.
+import * as piTui from "@earendil-works/pi-tui";
+import type { Color, TerminalColorMode } from "@earendil-works/pi-tui";
 
 // ── ANSI constants ───────────────────────────────────────────────────────────
 
@@ -14,10 +20,17 @@ export const AUTOCOMPLETE_CURSOR = "›";
 export const HINT_MARGIN_RIGHT = 3;
 export const PAD_X = 1;
 
-// ── Fallback ANSI codes (neutral near-black) ─────────────────────────────────
+// ── Fallback ANSI codes (no-theme-object path only) ─────────────────────────
+
+// A palette is only ever built without a theme in tests and headless runs, so
+// these constants stay hardcoded — but they still respect a light appearance
+// when one can be read, because a near-black slab on a light terminal is the
+// bug this file used to ship.
+const PANEL_FALLBACK: Readonly<Record<ThemeAppearance, PanelColor>> = {
+  dark: { panelBg: "\x1b[48;2;16;16;16m", panelEdge: "\x1b[38;2;16;16;16m" },
+  light: { panelBg: "\x1b[48;2;238;238;238m", panelEdge: "\x1b[38;2;238;238;238m" },
+};
 
-const FALLBACK_PANEL_BG = "\x1b[48;2;16;16;16m";
-const FALLBACK_PANEL_EDGE = "\x1b[38;2;16;16;16m";
 const FALLBACK_FG = "\x1b[38;2;74;74;74m"; // #4a4a4a structural gray
 
 // ── Palette ──────────────────────────────────────────────────────────────────
@@ -36,12 +49,18 @@ export interface PanePalette {
 
 function tryGetBgAnsi(theme: Theme, key: ThemeBg): string | undefined {
   try {
-    return (theme as any).getBgAnsi(key);
+    return theme.getBgAnsi(key);
   } catch {
+    // Unknown token (`tokenAnsi` throws in 1.x), or no theme object at all.
     return undefined;
   }
 }
 
+/** `Theme.appearance` exists from pi 0.99.0; older hosts report nothing. */
+function themeAppearance(theme: Theme | undefined): ThemeAppearance | undefined {
+  return (theme as { appearance?: ThemeAppearance } | undefined)?.appearance;
+}
+
 function tryFg(theme: Theme, key: ThemeColor, text: string): string | undefined {
   try {
     return theme.fg(key, text);
@@ -58,12 +77,119 @@ function safeThemeColor(theme: Theme, keys: ThemeColor[], text: string): string
   return fgWrap(FALLBACK_FG, text);
 }
 
-/** Convert a 48;2 or 48;5 bg ANSI code to its fg equivalent (38;…). */
-function bgToFgAnsi(bg: string): string {
-  if (bg.startsWith("\x1b[48;2;") || bg.startsWith("\x1b[48;5;")) {
-    return bg.replace("\x1b[48;", "\x1b[38;");
+// ── Terminal-default tokens: "no color", not "some color" ──────────────────
+
+/**
+ * The escape sequences that mean *paint nothing, use the terminal's own
+ * color*. Since pi 0.99.0 a theme token is allowed to be `""` (terminal
+ * default), and `Theme.getBgAnsi()` / `getFgAnsi()` render that as `\x1b[49m` /
+ * `\x1b[39m` — **truthy** strings, so a `getBgAnsi(…) ?? FALLBACK` chain never
+ * reaches the fallback and a `… || HARD_COLOR` chain never fires. Measured on
+ * pi 1.2.0: a theme with `userMessageBg: ""` answers `"\x1b[49m"`, and one with
+ * `borderMuted: ""` answers `"\x1b[39m"`.
+ *
+ * Membership here is a *comparison*, never a decode: nothing in this file reads
+ * the color an escape happens to encode. Suite rule — decide color from the
+ * theme, never by parsing an escape sequence.
+ */
+const TERMINAL_DEFAULT_SEQUENCES: ReadonlySet<string> = new Set([
+  "", // the answer itself, pre-0.99.0
+  RESET, // "\x1b[0m": a full reset leaves no colour set
+  "\x1b[m", // …and its parameter-less form
+  "\x1b[39m", // a foreground token set to ""
+  "\x1b[49m", // a background token set to ""
+]);
+
+/** Does this theme answer mean "the terminal's own color", i.e. no color? */
+export function isTerminalDefault(ansi: string | undefined): boolean {
+  return ansi === undefined || TERMINAL_DEFAULT_SEQUENCES.has(ansi);
+}
+
+// ── Panel tint and edge ─────────────────────────────────────────────────────
+
+interface PanelColor {
+  /** Opening background escape for the panel body, or "" for no tint. */
+  panelBg: string;
+  /** Opening foreground escape for the edge slabs, or "" for no edge. */
+  panelEdge: string;
+}
+
+/** No color at all: panel and edges render in the terminal's own. */
+const NO_PANEL_COLOR: PanelColor = { panelBg: "", panelEdge: "" };
+
+/** Queried in order; the first answer wins — a terminal default included. */
+const PANEL_BG_TOKENS: readonly ThemeBg[] = ["userMessageBg", "customMessageBg"];
+
+/** The token the panel is tinted with, and the escape it answers with. */
+interface PanelTint {
+  token: ThemeBg;
+  ansi: string;
+}
+
+function panelTint(theme: Theme): PanelTint | undefined {
+  for (const token of PANEL_BG_TOKENS) {
+    const ansi = tryGetBgAnsi(theme, token);
+    if (ansi !== undefined) return { token, ansi };
+  }
+  return undefined;
+}
+
+/** pi-tui's own "colour → foreground escape" emitter, if this host has one. */
+type ForegroundAnsi = (color: Color, mode: TerminalColorMode) => string;
+const emitForeground = (
+  piTui as Partial<Record<string, unknown>>
+).foregroundAnsi as ForegroundAnsi | undefined;
+
+/**
+ * The edge slabs are the **panel's own colour, asked for as a foreground**.
+ *
+ * A slab sits hard against the panel body, so it is a cushion rather than a
+ * border: in the panel's own tint it is invisible by construction, and in any
+ * other token — a border, for instance — it is a visible rule hugging the text
+ * area. pi accepts a token only in its own slot (asking the foreground for
+ * `userMessageBg` throws; measured on 1.2.0) and documents `theme.colors[token]`
+ * as the way to use a token's color in the other slot, so that is what we ask:
+ * the theme hands back its own `Color`, and the host's own emitter renders it as
+ * a foreground escape. The value is still *asked for*, never read out of a
+ * string, so the suite's colour rule stands — and reaching for a different
+ * token because it looks similar is the same mistake in a different costume.
+ *
+ * A theme that cannot answer — no `colors`, nothing for the winning token, an
+ * old host without the emitter — means **no colour**, and the editor blanks the
+ * rows. Never a substitute token.
+ */
+function panelEdgeAnsi(theme: Theme, token: ThemeBg): string {
+  try {
+    const colors = (theme as { colors?: Partial<Record<ThemeBg, Color | undefined>> })
+      .colors;
+    const color = colors?.[token];
+    if (!color || !emitForeground) return "";
+    return emitForeground(color, theme.getColorMode());
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Panel tint and edge, decided by theme tokens alone: the panel is painted with
+ * whatever the theme's own panel background token says (passed through, not
+ * re-emitted), and the edge slabs with that *same* token asked for as a
+ * foreground, so the cushion matches the surface it extends.
+ *
+ * Nothing is derived *from* an escape sequence. The old
+ * background-to-foreground helper matched `48;2;`/`48;5;` inside the background
+ * string and answered everything else — notably the `\x1b[49m` a
+ * terminal-default token produces — with near-black `#101010`, which is how an
+ * untinted panel ended up with black borders on a light terminal.
+ */
+function resolvePanelColor(theme: Theme): PanelColor {
+  const tint = panelTint(theme);
+  if (tint === undefined) {
+    // Nothing to ask: no theme object, or one with no panel token at all.
+    return PANEL_FALLBACK[themeAppearance(theme) ?? "dark"];
   }
-  return FALLBACK_PANEL_EDGE;
+  if (isTerminalDefault(tint.ansi)) return NO_PANEL_COLOR;
+  return { panelBg: tint.ansi, panelEdge: panelEdgeAnsi(theme, tint.token) };
 }
 
 function fgWrap(ansi: string, text: string): string {
@@ -71,14 +197,11 @@ function fgWrap(ansi: string, text: string): string {
 }
 
 export function resolvePalette(theme: Theme): PanePalette {
-  const panelBg =
-    tryGetBgAnsi(theme, "userMessageBg") ??
-    tryGetBgAnsi(theme, "customMessageBg") ??
-    FALLBACK_PANEL_BG;
+  const { panelBg, panelEdge } = resolvePanelColor(theme);
 
   return {
     panelBg,
-    panelEdge: bgToFgAnsi(panelBg),
+    panelEdge,
     frame: (t) => safeThemeColor(theme, ["borderMuted", "border"], t),
     prefix: (t) => safeThemeColor(theme, ["borderMuted", "border"], t),
     spin: (t) => safeThemeColor(theme, ["accent", "borderMuted"], t),
@@ -86,8 +209,3 @@ export function resolvePalette(theme: Theme): PanePalette {
     hint: (t) => safeThemeColor(theme, ["dim", "muted"], t),
   };
 }
-
-/** Set a bg color on the theme's internal bgColors map. */
-export function setThemeBg(theme: Theme, key: ThemeBg, ansi: string): void {
-  (theme as any)?.bgColors?.set(key, ansi);
-}

package/src/events-host-bus.test.ts

@@ -0,0 +1,113 @@
+/**
+ * The emit helper against pi's REAL event bus (`createEventBus()`), not the
+ * suite's synchronous stand-in.
+ *
+ * Every other test in this migration drives a hand-written bus whose `emit`
+ * calls listeners inline and lets their throws escape. pi's bus is not built
+ * that way: `createEventBus()` (`dist/core/event-bus.js`) wraps each handler in
+ * an `async` function with its own `try/catch`, so a subscriber's throw is
+ * contained by the host and printed with `console.error`. The two transports
+ * are NOT interchangeable on that point, and the difference has two
+ * consequences worth having in writing:
+ *
+ * - Nothing in the suite can rely on a subscriber's throw reaching the emitter.
+ *   The retired bus caught and logged it too, so no caller is broken, but a
+ *   future "let the emitter see it" plan would be silently dead on arrival.
+ * - Where a listener failure is *reported* changed: the old bus wrote to
+ *   `diag()` (our log file); the host writes to `console.error`, which is the
+ *   one surface `log-discipline.test.ts` forbids precisely because it smears a
+ *   fullscreen frame. Our listeners therefore have to report their own failures.
+ */
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { createEventBus } from "@earendil-works/pi-coding-agent";
+import { Events, emitOn } from "./events.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("pi's real event bus, as our emitters and listeners meet it", () => {
+  it("delivers a payload to a subscriber on the same handle", () => {
+    const bus = createEventBus();
+    const seen: unknown[] = [];
+    const unsub = bus.on(Events.TODOS_UPDATE, (p) => seen.push(p));
+    emitOn(bus, Events.TODOS_UPDATE, { source: "main", todos: [] });
+    expect(seen).toEqual([{ source: "main", todos: [] }]);
+    unsub();
+    bus.clear();
+  });
+
+  /**
+   * RED-FIRST EVIDENCE, kept as a pin. The migration note in
+   * `docs/decisions/0029` claimed a throwing subscriber is "still rethrown into
+   * the emitter, which is what the old bus did". It is not: written as
+   * `expect(() => emitOn(bus, …)).toThrow()` this test failed ("expected
+   * [Function] to throw an error") against pi 1.2.0, and the same is true of a
+   * bare `bus.emit`. The host swallows it.
+   */
+  it("does NOT rethrow a subscriber's throw into the emitter", async () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const bus = createEventBus();
+    const unsub = bus.on(Events.COST_UPDATE, () => {
+      throw new Error("listener exploded");
+    });
+
+    expect(() => bus.emit(Events.COST_UPDATE, { source: "main" })).not.toThrow();
+    expect(() => emitOn(bus, Events.COST_UPDATE, { source: "main" })).not.toThrow();
+    await new Promise((resolve) => setImmediate(resolve));
+    // The host does report it — on the console, which is not our log file.
+    expect(errSpy.mock.calls.some((call) => String(call[0]).includes("Event handler error"))).toBe(true);
+    unsub();
+    bus.clear();
+  });
+
+  it("a throwing subscriber does not cost the other subscribers the payload", async () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const bus = createEventBus();
+    const seen: unknown[] = [];
+    const a = bus.on(Events.TODOS_UPDATE, () => {
+      throw new Error("first listener exploded");
+    });
+    const b = bus.on(Events.TODOS_UPDATE, (p) => seen.push(p));
+
+    emitOn(bus, Events.TODOS_UPDATE, { source: "subagent:x", todos: [] });
+    expect(seen).toEqual([{ source: "subagent:x", todos: [] }]);
+    a();
+    b();
+    bus.clear();
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(errSpy).toHaveBeenCalled();
+  });
+
+  it("still swallows handle-death, which is what emitOn exists for", () => {
+    const stale = {
+      emit: () => {
+        throw new Error("This extension ctx is stale after session replacement or reload.");
+      },
+      on: () => () => {},
+    };
+    // Unlike a subscriber throw, a dead handle DOES throw at the caller — and
+    // that is the only throw `emitOn` is written to absorb.
+    expect(() => emitOn(stale, Events.COST_UPDATE, { source: "main" })).not.toThrow();
+  });
+
+  it("an unsubscribe returned by the host really removes the subscriber", () => {
+    const bus = createEventBus();
+    const seen: unknown[] = [];
+    const unsub = bus.on(Events.TODOS_CLEAR, (p) => seen.push(p));
+    unsub();
+    emitOn(bus, Events.TODOS_CLEAR, { source: "subagent:x" });
+    expect(seen).toEqual([]);
+    bus.clear();
+  });
+
+  it("an emit with no subscriber is dropped, not queued for the next one", () => {
+    const bus = createEventBus();
+    emitOn(bus, Events.TODOS_UPDATE, { source: "subagent:x", todos: [] });
+    const seen: unknown[] = [];
+    const unsub = bus.on(Events.TODOS_UPDATE, (p) => seen.push(p));
+    expect(seen).toEqual([]);
+    unsub();
+    bus.clear();
+  });
+});

package/src/events.test.ts

@@ -0,0 +1,85 @@
+/**
+ * The channel vocabulary (`Events`) + payload types, and the emit helper.
+ *
+ * This module has NO transport of its own — it holds no listeners and touches
+ * no `globalThis` (that was the retired `core/bus` singleton, ADR 0004, now
+ * replaced by the host's `pi.events`; see ADR 0029). The tests here are the
+ * regression pins for that: the six channel strings must stay byte-identical
+ * (they are the wire names the Archimedes Client sees, and the contract
+ * between packages that no longer share a bus object), and importing this file
+ * must not install a process-wide singleton.
+ */
+import { describe, it, expect } from "vitest";
+import { Events, emitOn } from "./events.js";
+
+describe("Events — channel names", () => {
+  it("are byte-identical to the retired bus constants (wire contract with the Client)", () => {
+    // Byte-identical on purpose: `core/bridge/events.ts` maps several of these
+    // verbatim onto push frames (`cost_update`, `todos_update`, `todos_clear`).
+    expect({ ...Events }).toEqual({
+      COST_UPDATE: "archimedes:cost_update",
+      TODOS_UPDATE: "archimedes:todos_update",
+      TODOS_CLEAR: "archimedes:todos_clear",
+      ASK_REQUEST: "archimedes:ask_request",
+      ASK_RESPONSE: "archimedes:ask_response",
+      ASK_CANCEL: "archimedes:ask_cancel",
+    });
+  });
+});
+
+describe("emitOn — the host handle is not ours to trust", () => {
+  it("delivers to a listener on the same handle", () => {
+    const seen: unknown[] = [];
+    const bus = fakeBus();
+    bus.on(Events.TODOS_UPDATE, (p) => seen.push(p));
+    emitOn(bus, Events.TODOS_UPDATE, { source: "main", todos: [] });
+    expect(seen).toEqual([{ source: "main", todos: [] }]);
+  });
+
+  /**
+   * A real one: `pi.events.emit` THROWS once the extension runtime has been
+   * invalidated — verified against a live pi 1.2.0 session, where a deferred
+   * `setTimeout` emit after the run ended crashed the process with "This
+   * extension ctx is stale after session replacement or reload." Our emitters
+   * hang off sockets, child streams and timers, so they CAN outlive the session
+   * that handed them the handle. The old `globalThis` bus never threw; this
+   * helper keeps that contract.
+   */
+  it("does not rethrow a handle that throws (stale runtime after session replacement)", () => {
+    const stale = {
+      emit: () => {
+        throw new Error("This extension ctx is stale after session replacement or reload.");
+      },
+      on: () => () => {},
+    };
+    expect(() => emitOn(stale, Events.COST_UPDATE, { source: "main" })).not.toThrow();
+  });
+
+  it("is a no-op without a handle (a call site constructed before registration)", () => {
+    expect(() => emitOn(undefined, Events.ASK_REQUEST, {})).not.toThrow();
+  });
+});
+
+/** A minimal stand-in for pi's `createEventBus()` (same emit/on contract). */
+export function fakeBus() {
+  const listeners = new Map<string, Array<(data: unknown) => void>>();
+  return {
+    emit(channel: string, data: unknown): void {
+      for (const handler of [...(listeners.get(channel) ?? [])]) handler(data);
+    },
+    on(channel: string, handler: (data: unknown) => void): () => void {
+      const subs = listeners.get(channel) ?? [];
+      subs.push(handler);
+      listeners.set(channel, subs);
+      return () => {
+        const current = listeners.get(channel) ?? [];
+        const idx = current.indexOf(handler);
+        if (idx !== -1) current.splice(idx, 1);
+      };
+    },
+    /** Test-only: how many handlers are live on a channel. */
+    listenerCount(channel: string): number {
+      return (listeners.get(channel) ?? []).length;
+    },
+  };
+}

package/src/events.ts

@@ -0,0 +1,107 @@
+// ── Channel vocabulary ──────────────────────────────────────────────────────
+//
+// The names packages use to talk to each other, and the payload shapes that
+// ride on them. **This module carries no transport.** It keeps no listeners,
+// opens no socket, and — unlike the `Bus` singleton it replaces (ADR 0004,
+// retired in favour of the host's `pi.events`, ADR 0029) — touches no
+// `globalThis`. Call sites share the constants; the host owns the bus.
+//
+// The six channel strings are byte-identical to the retired `Events`
+// constants. They are not free to change: `bridge/events.ts` maps several of
+// them straight onto Archimedes Client push frames (`cost_update`,
+// `todos_update`, `todos_clear`), so a rename is a wire-protocol change.
+//
+// Delivery is the host's promise, and it has two edges worth knowing before
+// adding a channel:
+//
+// 1. **No queue.** An emit with no subscriber is dropped. Every emitter here
+//    fires from a tool call, a child socket, or a turn — all of which happen
+//    after `session_start`, so every subscription (made at registration or at
+//    `session_start`) is already live. If you add an emitter that fires during
+//    extension load, it needs its own ordering guard at the emitter; do not
+//    reintroduce a general-purpose queue.
+// 2. **A handle dies with its session.** `pi.events.emit` throws once the
+//    extension runtime has been invalidated ("This extension ctx is stale
+//    after session replacement or reload."), which a deferred emit — a socket
+//    callback, a child stream, a timer — can easily outlive. `emitOn` below is
+//    the contract the old bus gave for free: emitting never throws at you.
+// 3. **A subscriber's throw is the host's problem, not the emitter's.**
+//    `createEventBus()` wraps every handler in its own `try/catch` and prints
+//    `Event handler error (<channel>)` with `console.error`, so a listener
+//    failure never propagates back to whoever emitted — and never reaches our
+//    log file either. A listener with something worth keeping must report it
+//    through `diag()` itself. Pinned in `events-host-bus.test.ts`.
+
+import type { EventBus } from "@earendil-works/pi-coding-agent";
+import { diag, describeError } from "./log.js";
+
+export const Events = {
+  COST_UPDATE: "archimedes:cost_update",
+  TODOS_UPDATE: "archimedes:todos_update",
+  TODOS_CLEAR: "archimedes:todos_clear",
+  ASK_REQUEST: "archimedes:ask_request",
+  ASK_RESPONSE: "archimedes:ask_response",
+  ASK_CANCEL: "archimedes:ask_cancel",
+} as const;
+
+interface CostUpdatePayload {
+  source: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  cost?: number;
+}
+
+interface TodoUpdatePayload {
+  source: string;       // "main" or "subagent:<agent-name>"
+  todos: Array<{ content: string; description?: string; status: "pending" | "in_progress" | "completed" }>;
+}
+
+interface TodoClearPayload {
+  source: string;
+}
+
+interface AskRequestPayload {
+  source: string;        // "subagent:<agent-name>"
+  requestId: string;     // unique id to match request → response
+  toolCallId?: string;   // the tool-call id of the process that invoked the tool (carried for Client correlation)
+  questions: Array<{ id: string; question: string; description?: string; options: Array<{ label: string }>; multi?: boolean; recommended?: number }>;
+}
+
+interface AskResponsePayload {
+  requestId: string;
+  cancelled: boolean;
+  results: Array<{ id: string; selectedOptions: string[]; customInput?: string }>;
+}
+
+interface AskCancelPayload {
+  requestId: string;
+  source: string;
+}
+
+export type { CostUpdatePayload, TodoUpdatePayload, TodoClearPayload, AskRequestPayload, AskResponsePayload, AskCancelPayload };
+
+/**
+ * Emit on a host handle without letting the handle's failure become ours.
+ *
+ * `pi.events.emit` throws when the runtime behind the handle has been
+ * invalidated — verified against a live pi 1.2.0 session, where an emit
+ * deferred past the end of the run crashed the process. Every emitter in this
+ * suite hangs off something asynchronous (a child's socket, a child's stdout,
+ * a tool call that outlived its session), so the throw is reachable, and a
+ * dropped notification is a better outcome than a dead pi. The retired bus
+ * swallowed the same class of failure; `diag` keeps it visible when someone is
+ * looking.
+ *
+ * @param events the host handle, or `undefined` for a call site that was
+ *               constructed before there was one to hold
+ */
+export function emitOn(events: EventBus | undefined, channel: string, payload: unknown): void {
+  if (!events) return;
+  try {
+    events.emit(channel, payload);
+  } catch (err) {
+    diag("core", `[archimedes:events] emit "${channel}" failed: ${describeError(err)}`);
+  }
+}

package/src/index.test.ts

@@ -1,13 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerCore } from "./index.js";
-import { initBus } from "./bus.js";
 import { registerBridge } from "./bridge/index.js";
 import { registerSelfUsage } from "./bridge/self-usage.js";
 
-vi.mock("./bus.js", () => ({
-  initBus: vi.fn(),
-}));
 vi.mock("./bridge/index.js", () => ({
   registerBridge: vi.fn(),
 }));
@@ -20,12 +16,10 @@ describe("registerCore", () => {
     vi.clearAllMocks();
   });
 
-  it("registers bus, bridge, and self-usage", () => {
-    const pi = {} as ExtensionAPI;
+  it("registers bridge and self-usage", () => {
+    const pi = { events: { emit: vi.fn(), on: vi.fn() } } as unknown as ExtensionAPI;
     registerCore(pi);
-    expect(initBus).toHaveBeenCalled();
     expect(registerBridge).toHaveBeenCalledWith(pi);
     expect(registerSelfUsage).toHaveBeenCalledWith(pi);
   });
 });
-

package/src/index.ts

@@ -1,19 +1,19 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { initBus } from "./bus.js";
 import { registerBridge } from "./bridge/index.js";
 import { registerSelfUsage } from "./bridge/self-usage.js";
 
 // ── Core registration ─────────────────────────────────────────────────────
 
 export function registerCore(pi: ExtensionAPI): void {
-  initBus();
   registerBridge(pi);
 
   // Self-usage (per-turn COST_UPDATE, source "main") — top-level like the
   // bridge (never inside a session handler, so it doesn't accumulate on
-  // /reload). Unconditional: NOT gated on bridge mode (design decision 3 —
-  // the TUI footer's CostAccumulator sums it; in bridge mode the existing
-  // events.ts forwarder carries it to the desktop).
+  // /reload). Unconditional: NOT gated on bridge mode (design decision 3).
+  // Its live consumer is the events.ts forwarder, which carries it to the
+  // desktop as `cost_update`; the footer stopped subscribing in Task 9 (it
+  // reads usage from the session entries, which already include the main
+  // agent's — see bridge/self-usage.ts).
   registerSelfUsage(pi);
 }