@pi-archimedes/core 2.7.3 → 2.9.0

package/src/index.test.ts

@@ -1,362 +1,31 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Theme } 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";
 
-// ── Mock surface ────────────────────────────────────────────────────────
-// Only seam that MUST be mocked: loadCoreConfig (drives the spin flag).
-// settings-io is mocked the same way as in config.test.ts (its module scope
-// calls getAgentDir()); the editor and the rest of index.ts' imports are
-// verified side-effect-free at import time, so they stay real — the real
-// HephaestusEditor is what makes the setInterval/onSpinInterval assertions
-// meaningful.
-vi.mock("./settings-io.js", () => ({
-  loadConfig: vi.fn(),
-  saveConfig: vi.fn(),
-}));
-vi.mock("./config.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./config.js")>();
-  return {
-    ...actual,
-    loadCoreConfig: vi.fn(),
-  };
-});
 vi.mock("./bus.js", () => ({
   initBus: vi.fn(),
 }));
-vi.mock("./startup/capture.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./startup/capture.js")>();
-  return {
-    ...actual,
-    patchConsoleLog: vi.fn(),
-  };
-});
-vi.mock("./thinking/patch.js", () => ({
-  patchThinkingRenderer: vi.fn(),
+vi.mock("./bridge/index.js", () => ({
+  registerBridge: vi.fn(),
+}));
+vi.mock("./bridge/self-usage.js", () => ({
+  registerSelfUsage: vi.fn(),
 }));
 
-const { registerCore, getCoreSettingsItems } = await import("./index.js");
-const { loadCoreConfig, DEFAULT_CORE_CONFIG } = await import("./config.js");
-
-// ── Sparse spy handles (real casts strip the spy typing) ───────────────
-
-interface UiSpies {
-  setHeader: ReturnType<typeof vi.fn>;
-  setEditorComponent: ReturnType<typeof vi.fn>;
-  setWorkingVisible: ReturnType<typeof vi.fn>;
-}
-type TimerSpy = {
-  mock: {
-    calls: unknown[][];
-    results: ReadonlyArray<{ value: unknown }>;
-    invocationCallOrder: number[];
-  };
-  mockRestore(): void;
-};
-
-function makeCtx(): { ctx: ExtensionContext; ui: UiSpies } {
-  const ui: UiSpies = {
-    setHeader: vi.fn(),
-    setEditorComponent: vi.fn(),
-    setWorkingVisible: vi.fn(),
-  };
-  const ctx = {
-    ui: { ...ui, theme: {} as Theme },
-    isIdle: vi.fn(() => true),
-    shutdown: vi.fn(),
-  } as unknown as ExtensionContext;
-  return { ctx, ui };
-}
-
-/** Build an editor via the most recently registered factory. */
-function buildEditor(ui: UiSpies): unknown {
-  const factory = ui.setEditorComponent.mock.calls.at(-1)![0] as (
-    tui: unknown,
-    theme: unknown,
-    keybindings: unknown,
-  ) => unknown;
-  // `borderColor` set (like the custom editor mock in editor/index.test.ts) so
-  // the real pi-coding-agent `renderTopBorder` doesn't trip on an unset
-  // base-class field when these tests render through the real editor.
-  const editor = factory(
-    { terminal: { rows: 24 }, requestRender: () => {} },
-    { borderColor: (s: string) => s },
-    {},
-  );
-  constructed.push(editor);
-  return editor;
-}
-
-function registerAndCapture(): {
-  start: (ctx: ExtensionContext) => void;
-  shutdown: (ctx: ExtensionContext) => void;
-} {
-  const onSpy = vi.fn();
-  registerCore({ on: onSpy } as unknown as ExtensionAPI);
-  // Top-level registrations are exactly: session_shutdown + session_start
-  // (message_end is registered inside the session_start handler).
-  const calls = onSpy.mock.calls as Array<
-    [string, (event: unknown, ctx: ExtensionContext) => void]
-  >;
-  const startCall = calls.find((c) => c[0] === "session_start");
-  const shutdownCall = calls.find((c) => c[0] === "session_shutdown");
-  expect(startCall).toBeTruthy();
-  expect(shutdownCall).toBeTruthy();
-  const startFn = startCall! ? startCall[1] : undefined;
-  const shutdownFn = shutdownCall ? shutdownCall[1] : undefined;
-  return {
-    start: (ctx) => startFn!(null, ctx),
-    shutdown: (ctx) => shutdownFn!(null, ctx),
-  };
-}
-
-let start: (ctx: ExtensionContext) => void;
-let shutdown: (ctx: ExtensionContext) => void;
-let ctx: ExtensionContext;
-let ui: UiSpies;
-let si: TimerSpy;
-let cl: TimerSpy;
-let constructed: unknown[];
-
-/** Count of timers registered with delay 32 ms (the spinner cadence at the default config — the default `pendulum` native 12 ms × the normal multiplier, clamped at the 32 ms tick floor). */
-function spinTimerCount(): number {
-  return si.mock.calls.filter((c) => c[1] === 32).length;
-}
-
-beforeEach(() => {
-  const handlers = registerAndCapture();
-  start = handlers.start;
-  shutdown = handlers.shutdown;
-  const made = makeCtx();
-  ctx = made.ctx;
-  ui = made.ui;
-  si = vi.spyOn(globalThis, "setInterval") as unknown as TimerSpy;
-  cl = vi.spyOn(globalThis, "clearInterval") as unknown as TimerSpy;
-  constructed = [];
-});
-
-afterEach(() => {
-  // Reap any live spinner timers so the test process never hangs.
-  for (const e of constructed.splice(0)) {
-    (e as { dispose?: () => void }).dispose?.();
-  }
-  si.mockRestore();
-  cl.mockRestore();
-});
-
-// ── 1. Default (on) ────────────────────────────────────────────────────
-
-describe("editorSpinBorder = true (default)", () => {
-  it("session_start hides the Working line; the editor drives a 32ms timer (the default pendulum) stored onSpinInterval; shutdown restores and reaps", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue(DEFAULT_CORE_CONFIG);
-
-    start(ctx);
-    expect(ui.setWorkingVisible.mock.calls.map((c: unknown[]) => c[0])).toEqual(
-      [false],
-    );
-
-    buildEditor(ui); // real ctor: setInterval(fn, 32) + onSpinInterval(token)
-    expect(spinTimerCount()).toBe(1);
-    const setCall = si.mock.calls.at(-1)!;
-    expect(typeof setCall[0]).toBe("function");
-    expect(setCall[1]).toBe(32);
-
-    // onSpinInterval stored the handle: shutdown() clears it.
-    shutdown(ctx);
-    const visCalls = ui.setWorkingVisible.mock.calls.map((c: unknown[]) => c[0]);
-    expect(visCalls.at(-1)).toBe(true);
-    expect(cl.mock.calls.length).toBeGreaterThan(0);
-    const token = si.mock.results[si.mock.calls.length - 1]!.value;
-    expect(cl.mock.calls.some((c) => c[0] === token)).toBe(true);
-  });
-
-  it("a second shutdown is a no-op (no restore, no clear)", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue(DEFAULT_CORE_CONFIG);
-    start(ctx);
-    buildEditor(ui);
-    shutdown(ctx);
-    const visAfter = ui.setWorkingVisible.mock.calls.length;
-    const clearAfter = cl.mock.calls.length;
-    shutdown(ctx); // spinFlag already reset, handle already cleared
-    expect(ui.setWorkingVisible.mock.calls.length).toBe(visAfter);
-    expect(cl.mock.calls.length).toBe(clearAfter);
-  });
-
-  it("editorSpinSpeed = \"fast\": the editor's interval period is 48 ms (the typing 80 ms native × 0.6)", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinSpeed: "fast",
-      editorSpinStyle: "typing",
-    });
-
-    start(ctx);
-    buildEditor(ui);
-    const setCall = si.mock.calls.at(-1)!;
-    expect(setCall[1]).toBe(48);
-  });
-
-  it("editorSpinSpeed = \"slow\": the editor's interval period is 120 ms (the typing 80 ms native × 1.5)", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinSpeed: "slow",
-      editorSpinStyle: "typing",
-    });
-
-    start(ctx);
-    buildEditor(ui);
-    const setCall = si.mock.calls.at(-1)!;
-    expect(setCall[1]).toBe(120);
-  });
-
-  it("editorSpinStyle = \"rain\" → the factory pass-through: the editor's interval period is 40 × 1 (normal) = 40 (rain's native tempo) and the border shows rain's frames (ported — batch 4)", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinStyle: "rain",
-    });
-    vi.mocked(ctx.isIdle).mockReturnValue(false); // busy
-
-    start(ctx);
-    buildEditor(ui);
-    const setCall = si.mock.calls.at(-1)!;
-    expect(setCall[1]).toBe(40); // 40 × 1 — not 80 (typing), so the style reached the editor
-
-    const editor = buildEditor(ui) as unknown as { tickSpin(): void; render(w: number): string[] };
-    // hold-0 port styles run the full source loop: a never-ticked box is at step 0, so the border shows rain's real step-0 frame (the seeded drops — NOT the typing ⠁; NOT a blank beat)
-    const plain = (l: string) => l.replace(/\x1b\[[0-9;]*m/g, "");
-    expect(plain(editor.render(60)[1]!)).toContain("⠈⠠⠠ Working");
-    expect(plain(editor.render(60)[1]!)).not.toContain("⠁   Working"); // not the typing fallback
-  });
-
-  it("editorSpinLabel = \"Thinking\" → the factory-built editor's busy border carries ` Thinking`, not ` Working`", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinLabel: "Thinking",
-    });
-
-    start(ctx);
-    vi.mocked(ctx.isIdle).mockReturnValue(false); // busy
-    const editor = buildEditor(ui) as { render(w: number): string[] };
-    const plain = (l: string) => l.replace(/\x1b\[[0-9;]*m/g, "");
-    const row = plain(editor.render(60)[1]!);
-    expect(row).toContain(" Thinking");
-    expect(row).not.toContain("Working");
-  });
-
-  it("editorSpinLabel = \"\" → the factory-built editor's busy border shows the window only (no label, dash-compensated)", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinLabel: "",
-    });
-
-    start(ctx);
-    vi.mocked(ctx.isIdle).mockReturnValue(false); // busy
-    const editor = buildEditor(ui) as { render(w: number): string[] };
-    const plain = (l: string) => l.replace(/\x1b\[[0-9;]*m/g, "");
-    const row = plain(editor.render(60)[1]!);
-    // Corner + leading space + the 4-cell window (frame-agnostic here — the default style is now pendulum and its seeded step-0 frame fills the window, not typing's clear beat; window frames are covered in editor/index.test.ts) + the full (51) trailing run.
-    expect(row).toMatch(/\s[^\s─]{4}─{51}/);
-    expect(row).not.toContain("Working");
-  });
-});
-
-// ── 2b. Corrupt (hand-edited) config robustness ────────────────────────────
-
-describe("getCoreSettingsItems with hand-edited (corrupt) values", () => {
-  it("an empty-string editorSpinSpeed (corrupt) projects to \"Normal\" without throwing", () => {
-    const items = getCoreSettingsItems({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinSpeed: "" as never,
-    });
-    const item = items.find((i) => i.id === "editorSpinSpeed");
-    expect(item).toBeTruthy();
-    expect(item!.currentValue).toBe("Normal");
-  });
-
-  it("a trailing-dash editorSpinStyle (empty split word) projects without throwing", () => {
-    const items = getCoreSettingsItems({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinStyle: "wave-" as never,
-    });
-    const item = items.find((i) => i.id === "editorSpinStyle");
-    expect(item).toBeTruthy();
-    expect(item!.currentValue).toBe("Wave");
-  });
-
-  it("a number editorSpinSpeed (corrupt — non-string) projects to \"Normal\" without throwing", () => {
-    const items = getCoreSettingsItems({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinSpeed: 2 as never,
-    });
-    const item = items.find((i) => i.id === "editorSpinSpeed");
-    expect(item).toBeTruthy();
-    expect(item!.currentValue).toBe("Normal");
-  });
-
-  it("a null editorSpinStyle (corrupt — non-string) projects to \"Typing\" without throwing", () => {
-    const items = getCoreSettingsItems({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinStyle: null as never,
-    });
-    const item = items.find((i) => i.id === "editorSpinStyle");
-    expect(item).toBeTruthy();
-    expect(item!.currentValue).toBe("Typing");
+describe("registerCore", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
   });
-});
-
-// ── 2. Off ──────────────────────────────────────────────────────────────
-
-describe("editorSpinBorder = false", () => {
-  it("no timer; setWorkingVisible(true) (default); shutdown is inert; re-start re-applies the flag", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue({
-      ...DEFAULT_CORE_CONFIG,
-      editorSpinBorder: false,
-    });
-
-    start(ctx);
-    expect(ui.setWorkingVisible.mock.calls.at(-1)?.[0]).toBe(true);
-
-    buildEditor(ui);
-    expect(spinTimerCount()).toBe(0);
-
-    const visBeforeShutdown = ui.setWorkingVisible.mock.calls.length;
-    const clearBeforeShutdown = cl.mock.calls.length;
-    shutdown(ctx); // nothing to restore or reap
-    expect(ui.setWorkingVisible.mock.calls.length).toBe(visBeforeShutdown);
-    expect(cl.mock.calls.length).toBe(clearBeforeShutdown);
 
-    // Idempotent restore: the flag is re-stored on the next session_start.
-    start(ctx);
-    expect(ui.setWorkingVisible.mock.calls.at(-1)?.[0]).toBe(true);
+  it("registers bus, bridge, and self-usage", () => {
+    const pi = {} as ExtensionAPI;
+    registerCore(pi);
+    expect(initBus).toHaveBeenCalled();
+    expect(registerBridge).toHaveBeenCalledWith(pi);
+    expect(registerSelfUsage).toHaveBeenCalledWith(pi);
   });
 });
 
-// ── 3. Orphaned-timer reaping (/reload rebind) ─────────────────────────
-
-describe("orphaned timer reaping", () => {
-  it("a re-invoked session_start (the /reload rebind) reaps the previous editor's timer before the new editor constructs", () => {
-    vi.mocked(loadCoreConfig).mockReturnValue(DEFAULT_CORE_CONFIG);
-
-    // (1) First session_start
-    start(ctx);
-    buildEditor(ui); // real ctor starts the timer → onSpinInterval stores it
-    const tokenA = si.mock.results[si.mock.calls.length - 1]!.value;
-    expect(spinTimerCount()).toBe(1);
-
-    // (3) /reload rebind — session_start runs BEFORE factory B is built,
-    // so merely calling factory A again would NOT trigger the reap.
-    const reconnectsBefore = ui.setEditorComponent.mock.calls.length;
-    start(ctx);
-    expect(ui.setEditorComponent.mock.calls.length).toBe(reconnectsBefore + 1);
-    expect(cl.mock.calls.at(-1)?.[0]).toBe(tokenA);
-    const clearOrderA =
-      cl.mock.invocationCallOrder[cl.mock.calls.length - 1]!;
-
-    // (4) Build factory B's editor (new constructor, new timer)
-    buildEditor(ui);
-    expect(spinTimerCount()).toBe(2);
-    const setOrderB =
-      si.mock.invocationCallOrder[si.mock.calls.length - 1]!;
-
-    // (5) The orphan was reaped BEFORE the new editor's setInterval
-    expect(clearOrderA).toBeLessThan(setOrderB);
-  });
-});

package/src/index.ts

@@ -1,277 +1,20 @@
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { type TUI, type EditorTheme, type Component, type SettingItem } from "@earendil-works/pi-tui";
-
-import { HephaestusEditor } from "./editor/index.js";
-
-import { renderHeader, patchStartupListing, type ListingRef } from "./startup/index.js";
-import { patchConsoleLog, unpatchConsoleLog } from "./startup/capture.js";
-import { patchThinkingRenderer } from "./thinking/patch.js";
-import { transformThinkingContent } from "./thinking/transform.js";
-import { loadCoreConfig, saveCoreConfig, DEFAULT_CORE_CONFIG, ANIMATION_STYLES, type CoreConfig } from "./config.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { initBus } from "./bus.js";
-
-// Re-export for session lifecycle management
-export { unpatchConsoleLog } from "./startup/capture.js";
-
-// ── Settings items ────────────────────────────────────────────────────────
-
-export function getCoreSettingsItems(config: CoreConfig): SettingItem[] {
-  return [
-    {
-      id: "mutedTheme",
-      label: "Muted Theme",
-      description: "Use muted colors for thinking blocks",
-      currentValue: config.mutedTheme ? "On" : "Off",
-      values: ["On", "Off"],
-    },
-    {
-      id: "codeUnindent",
-      label: "Code Unindent",
-      description: "Remove 2-space indent from code blocks",
-      currentValue: config.codeUnindent ? "On" : "Off",
-      values: ["On", "Off"],
-    },
-    {
-      id: "labelText",
-      label: "Label Text",
-      description: "Text shown before thinking blocks",
-      currentValue: config.labelText,
-    },
-    {
-      id: "labelColor",
-      label: "Label Color",
-      description: "RGB color for thinking label (e.g. 255,215,0)",
-      currentValue: config.labelColor,
-    },
-    {
-      id: "animationStyle",
-      label: "Logo Animation",
-      description: "Splashscreen logo reveal style",
-      currentValue: config.animationStyle,
-      values: [...ANIMATION_STYLES],
-    },
-    {
-      id: "editorSpinBorder",
-      label: "Editor Spin Border",
-      description: "Type across the editor's top border while the agent is working (hides the “Working” line)",
-      currentValue: config.editorSpinBorder ? "On" : "Off",
-      values: ["On", "Off"],
-    },
-    {
-      id: "editorSpinSpeed",
-      label: "Spin Speed",
-      description: "Border spinner speed (slow / normal / fast — the × 1.5 / × 1 / × 0.6 of the style's native tempo)",
-      currentValue: (() => {
-        // Hand-edited (corrupt) values — non-strings (null/number/boolean) or an
-        // empty string — fall back to `normal` (the `typeof` guard keeps the
-        // settings panel from TypeError-ing on a non-string setting; the
-        // falsy check keeps an empty string from projecting as a `NaN` label).
-        const s =
-          typeof config.editorSpinSpeed === "string" && config.editorSpinSpeed
-            ? config.editorSpinSpeed
-            : "normal";
-        return s[0]!.toUpperCase() + s.slice(1);
-      })(),
-      values: ["Slow", "Normal", "Fast"],
-    },
-    {
-      id: "editorSpinStyle",
-      label: "Spin Style",
-      description: "Which animation the editor border runs while working",
-      currentValue:
-        typeof config.editorSpinStyle === "string"
-          ? config.editorSpinStyle
-              .split("-")
-              .filter(Boolean)
-              .map((w) => w[0]!.toUpperCase() + w.slice(1))
-              .join(" ")
-          : "Typing",
-      values: [
-        "Typing",
-        "Wave Rows",
-        "Columns",
-        "Pulse",
-        "Marquee",
-        "Pendulum",
-        "Rain",
-        "Cascade",
-        "Diagonal Swipe",
-        "Sparkle",
-      ],
-    },
-    {
-      id: "editorSpinLabel",
-      label: "Spinner Label",
-      description: "Label typed after the spin window (empty hides it)",
-      currentValue: config.editorSpinLabel,
-    },
-  ];
-}
+import { registerBridge } from "./bridge/index.js";
+import { registerSelfUsage } from "./bridge/self-usage.js";
 
 // ── Core registration ─────────────────────────────────────────────────────
 
-// Module-level state for session lifecycle (shared between session_start and session_shutdown)
-let coreRef: ListingRef | undefined;
-let coreCtx: ExtensionContext | undefined;
-let coreTui: TUI | undefined;
-
-// Spin-prompt lifecycle state: the editor self-drives its timer and reports it
-// back via onSpinInterval so the session handlers can reap it (no circular import
-// — editor/index.ts must never import this module).
-let spinFlag = false;
-let spinInterval: ReturnType<typeof setInterval> | undefined;
-function clearSpinInterval(): void {
-  if (spinInterval) {
-    clearInterval(spinInterval);
-    spinInterval = undefined;
-  }
-}
-
 export function registerCore(pi: ExtensionAPI): void {
-  // Patch console.log for model scope capture
-  patchConsoleLog();
-
-  // session_shutdown handler (top-level to prevent accumulation on /reload)
-  pi.on("session_shutdown", (_event, _ctx) => {
-    // Restore the Working line if we hid it, and reap the editor's spinner
-    // timer. Runs FIRST: enabled-only restore of the Working line +
-    // unconditional spinner-timer reap (idempotent when spin is off).
-    if (spinFlag) { _ctx.ui.setWorkingVisible(true); }
-    clearSpinInterval();
-    spinFlag = false;
-
-    // Mark listing as settled
-    if (coreRef) { coreRef.settled = true; }
-    const g: Record<string | symbol, unknown> = globalThis as unknown as typeof global & Record<string | symbol, unknown>;
-    const listingRef = g["listingRef"] as ListingRef | undefined;
-    if (listingRef) { listingRef.settled = true; }
-
-    // Restore patched addChild to prevent closure accumulation across reloads
-    const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
-    const ORIG_ADD_CHILD = Symbol.for("splashscreen:origAddChild");
-    if (coreTui) {
-      try {
-        // Direct TUI children (old Pi: chatContainer was a direct child)
-        for (const child of coreTui.children) {
-          const cc = child as any;
-          if (cc[PATCHED_LISTING] && cc[ORIG_ADD_CHILD]) {
-            cc.addChild = cc[ORIG_ADD_CHILD];
-            cc[PATCHED_LISTING] = false;
-            cc[ORIG_ADD_CHILD] = undefined;
-          }
-        }
-        // Nested children (Pi 0.84+: loadedResourcesContainer is inside documentContainer)
-        for (const topChild of coreTui.children) {
-          const tc = topChild as any;
-          if (!tc.children) continue;
-          for (const child of tc.children) {
-            const cc = child as any;
-            if (cc[PATCHED_LISTING] && cc[ORIG_ADD_CHILD]) {
-              cc.addChild = cc[ORIG_ADD_CHILD];
-              cc[PATCHED_LISTING] = false;
-              cc[ORIG_ADD_CHILD] = undefined;
-            }
-          }
-        }
-
-      // Clear animation interval and debounce timer for prompt cleanup
-      const ANIM_INTERVAL = Symbol.for("splashscreen:animInterval");
-      const DEBOUNCE_TIMER = Symbol.for("splashscreen:debounceTimer");
-      for (const child of coreTui.children) {
-        const cc = child as any;
-        if (cc[ANIM_INTERVAL]) clearInterval(cc[ANIM_INTERVAL]);
-        if (cc[DEBOUNCE_TIMER]) clearTimeout(cc[DEBOUNCE_TIMER]);
-      }
-      // Nested children (Pi 0.84+: loadedResourcesContainer is inside documentContainer)
-      for (const topChild of coreTui.children) {
-        const tc = topChild as any;
-        if (!tc.children) continue;
-        for (const child of tc.children) {
-          const cc = child as any;
-          if (cc[ANIM_INTERVAL]) clearInterval(cc[ANIM_INTERVAL]);
-          if (cc[DEBOUNCE_TIMER]) clearTimeout(cc[DEBOUNCE_TIMER]);
-        }
-      }
-    } catch {
-      /* TUI structure may have changed — ignore */
-    }
-  }
-
-    // Clear editor component override
-    if (coreCtx) { coreCtx.ui.setEditorComponent(undefined); }
-  });
-
-  // session_start handler
-  pi.on("session_start", (_event, ctx: ExtensionContext) => {
-    // Initialize bus (flushes queued events)
-    initBus();
-
-    // Save context for shutdown cleanup
-    coreCtx = ctx;
-
-    // Spin-prompt flag (drives the editor self-timer + Working-line visibility)
-    const config = loadCoreConfig();
-    spinFlag = config.editorSpinBorder;
-
-    // Set animated header
-    coreRef = {
-      sections: [],
-      frame: 0,
-      revealed: false,
-      revealedAt: 0,
-      scaffoldAt: 0,
-      settled: false,
-    };
-    const ref = coreRef;
-    const headerFactory = (tui: TUI, theme: Theme): Component & { dispose?(): void } => {
-      coreTui = tui; // Capture for shutdown cleanup
-      const comp: Component & { dispose?(): void } = {
-        invalidate(): void { /* no-op */ },
-        render(width: number): string[] {
-          return renderHeader(theme, ref, width, tui.terminal.rows - 3);
-        },
-      };
-      patchStartupListing(tui, theme, ref);
-      return comp;
-    };
-    ctx.ui.setHeader(headerFactory);
-
-    // Set editor component (reap any orphaned timer from a previous editor /
-    // /reload rebind first — pi does not dispose the old editor's timer)
-    clearSpinInterval();
-    // Unconditional: OFF idempotently recovers a carried-over hidden state
-    // (pi's resetExtensionUI() resets workingVisible = true before session_start
-    // re-applies it, so this is always safe)
-    ctx.ui.setWorkingVisible(!spinFlag);
-    ctx.ui.setEditorComponent((tui: TUI, editorTheme: EditorTheme, keybindings: KeybindingsManager) => {
-      const theme = ctx.ui.theme;
-      return new HephaestusEditor(tui, editorTheme, keybindings, {
-        getTheme: () => theme,
-        isIdle: () => ctx.isIdle(),
-        shutdown: () => ctx.shutdown(),
-        spin: spinFlag,
-        spinSpeed: config.editorSpinSpeed,
-        spinStyle: config.editorSpinStyle,
-        spinLabel: config.editorSpinLabel,
-        onSpinInterval: (i) => { spinInterval = i; },
-      });
-    });
-
-    // Patch thinking renderer (config was hoisted above the editor factory)
-    patchThinkingRenderer(() => ctx.ui.theme, {
-      labelText: config.labelText,
-      labelColor: config.labelColor,
-    });
-
-    // Register events
-    pi.on("message_end", (event, _ctx) => {
-      // Transform thinking content (unindent code blocks if enabled)
-      if (config.codeUnindent) {
-        transformThinkingContent(event.message as any);
-      }
-    });
-  });
+  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).
+  registerSelfUsage(pi);
 }
 
 // ── Default export (for standalone pi.extensions loading) ─────────────────

package/src/tool-render.ts

@@ -1,7 +1,7 @@
 /**
  * Shared tool-row rendering helpers.
  *
- * Archimedes tools (mcp, todo, …) render a consistent two-part row:
+ * Archimedes tools (todo, …) render a consistent two-part row:
  *
  *   line 1 (header):  <toolName> (blue bold) + <action> (orange accent)
  *   result line:      <glyph> <label>  — glyph reflects run status: