@pi-archimedes/footer 2.10.3 → 2.11.0

package/README.md

@@ -32,7 +32,7 @@ After installing Pi, choose one installation command above, then `cd` into your
 - **Token ledger** — input (↑) and output (↓) tokens, cache read/write, and the live accumulated dollar cost of the session.
 - **Context bar** — colour-coded (green → yellow → red). It shows **consumption**: how much of the context window is used, not how much headroom is left.
 - **Adaptive layout** — one compact line on wide viewports; it wraps to the lines it needs as the terminal narrows instead of truncating essential data.
-- **Subagent aggregation** — in the suite, subagent token and cost events flow over core's bus into the same accumulator, so worker spend and main-session spend read as one total.
+- **Subagent aggregation** — in the suite, a subagent reports its tokens and cost on its own tool result, which this footer's session scan already totals, so worker spend and main-session spend read as one number. (It used to arrive a second way, over core's bus, which meant the same money was counted twice.)
 
 Two honest caveats: the ledger reflects usage and pricing **as reported to the session** — it's a live read of what Pi has accounted, not a guaranteed provider invoice, and not a tally of every background model call. And the context bar tracks consumption, not remaining headroom.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/footer",
-  "version": "2.10.3",
+  "version": "2.11.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -19,15 +19,15 @@
     "./config": "./src/config.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "2.10.3"
+    "@pi-archimedes/core": "2.11.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.1.0",
-    "@earendil-works/pi-tui": ">=0.1.0"
+    "@earendil-works/pi-coding-agent": ">=0.84.4",
+    "@earendil-works/pi-tui": ">=0.84.4"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.87.0",
-    "@earendil-works/pi-tui": "^0.87.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/cost-source.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Where the footer's cost total comes from.
+ *
+ * The subagent used to smuggle a child's usage to the footer over the suite bus
+ * (`subagent/src/cost.ts` → `COST_UPDATE` → `CostAccumulator`), which the footer
+ * then added to its own read of the session entries. Once the tool result carries
+ * native `usage`, pi persists that usage onto the toolResult message and the
+ * footer's own entry scan (`utils/stats.ts`, `extractEntryUsage`) already counts
+ * it — so the accumulator stops being an addition and becomes a second copy of
+ * the same money. These tests are the proof of both halves.
+ */
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Events } from "@pi-archimedes/core/events";
+import { formatTokenCount } from "./utils/format.js";
+
+// Load the footer's module graph at COLLECT time, before any test starts: the
+// first dynamic import used to happen inside the first test, charging it ~0.8s
+// alone / 2.1s in a full run / 5.1s on a loaded machine for transforming and
+// instantiating `index.ts` and its dependencies — a budget spent loading code,
+// not testing, which shows up as "Test timed out in 5000ms" under CPU
+// contention. Same reasoning as `src/index.test.ts`; collection has no test
+// timeout, and `vi.resetModules()` still hands each test a fresh instance.
+import "./index.js";
+
+interface FooterInstance {
+  render(width: number): string[];
+  dispose(): void;
+  invalidate(): void;
+}
+
+type FooterFactory = (
+  tui: { requestRender: () => void },
+  theme: unknown,
+  footerData: unknown,
+) => FooterInstance;
+
+const THEME = { fg: (_token: string, s: string) => s };
+
+/** One subagent's worth of usage, big enough to survive two decimal places. */
+const CHILD_USAGE = {
+  input: 4000,
+  output: 1500,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 5500,
+  cost: { input: 0.1, output: 0.1, cacheRead: 0, cacheWrite: 0, total: 0.2 },
+};
+
+/** The entry pi persists for a tool result that returned `usage`. */
+function toolResultEntry(id: string, usage: unknown) {
+  return { id, type: "message", message: { role: "toolResult", toolCallId: "t1", toolName: "subagent", usage } };
+}
+
+function assistantEntry(id: string) {
+  return {
+    id,
+    type: "message",
+    message: {
+      role: "assistant",
+      content: [],
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+    },
+  };
+}
+
+/**
+ * Footers built by the fixture while a test runs, handed back after it.
+ *
+ * Each test calls `shutdown()` itself, which releases the module-level
+ * subscription — but only if the test gets that far: a failed assertion skips
+ * it, and `session_shutdown` never touched the host's branch-change
+ * subscription anyway, which is the footer's `dispose()` alone. So the release
+ * belongs in a hook rather than in each test's happy path, mirroring
+ * `src/index.test.ts`.
+ */
+let builtFooters: FooterInstance[] = [];
+
+afterEach(() => {
+  for (const footer of builtFooters) footer.dispose();
+  builtFooters = [];
+});
+
+async function installFooter(
+  entries: unknown[],
+): Promise<{ rendered: (width?: number) => string[]; shutdown: () => void; bus: ReturnType<typeof fakeBus> }> {
+  vi.resetModules();
+  vi.doMock("./utils/git.js", () => ({
+    getGitStatus: () => ({ staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 }),
+    isInsideLinkedWorktree: () => false,
+  }));
+  vi.doMock("./utils/jj.js", () => ({ getJjBookmark: () => null, getJjChangedFiles: () => 0 }));
+  // Pin the footer's settings to the shipped defaults: `loadFooterConfig()` reads
+  // the developer's `settings.json`, and `expectRendered` below asserts on the
+  // branch the footer paints, so a saved `archimedes.footer.branchMaxLength` of
+  // 1–3 fails these tests for a footer that is working correctly. Same fixture
+  // decision as `src/index.test.ts`.
+  vi.doMock("./config.js", async (importOriginal) => {
+    const real = await importOriginal<typeof import("./config.js")>();
+    return { ...real, loadFooterConfig: () => real.DEFAULT_FOOTER_CONFIG };
+  });
+
+  const { registerFooter } = await import("./index.js");
+
+  const handlers: Record<string, (event: unknown, ctx: ExtensionContext) => void> = {};
+  // The handle the footer is handed. It no longer matters what is put on it —
+  // the footer subscribes to nothing — which is exactly what the cost tests below
+  // assert. A handle is passed anyway, because a real `ExtensionAPI` always has
+  // one and a test that omits it would not be shaped like production.
+  const bus = fakeBus();
+  const pi = {
+    on: (event: string, handler: (event: unknown, ctx: ExtensionContext) => void) => {
+      handlers[event] = handler;
+      return () => {};
+    },
+    getThinkingLevel: () => "off",
+    events: bus,
+  } as unknown as ExtensionAPI;
+
+  let factory: FooterFactory | undefined;
+  const ctx = {
+    hasUI: true,
+    model: undefined,
+    ui: {
+      setFooter: (f: FooterFactory) => {
+        factory = f;
+      },
+      notify: vi.fn(),
+    },
+    sessionManager: {
+      getEntries: () => entries as never,
+      getSessionId: () => "s",
+      getLeafId: () => null,
+    },
+    getContextUsage: () => undefined,
+  } as unknown as ExtensionContext;
+
+  registerFooter(pi);
+  handlers["session_start"]!({}, ctx);
+  if (!factory) throw new Error("footer factory was never installed");
+  const footer = factory({ requestRender: vi.fn() }, THEME, {
+    onBranchChange: () => vi.fn(),
+    getGitBranch: () => "main",
+    getExtensionStatuses: () => new Map<string, string>(),
+  });
+  builtFooters.push(footer);
+  return {
+    rendered: (width = 200) => footer.render(width),
+    shutdown: () => handlers["session_shutdown"]!({}, ctx),
+    bus,
+  };
+}
+
+/** The host event bus, stood in for (`pi.events`). */
+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);
+      };
+    },
+  };
+}
+
+/** The `$` figure the footer painted, or undefined when it painted none. */
+function paintedCost(lines: string[]): string | undefined {
+  const match = lines.join(" ").match(/\$\d+\.\d{2}/);
+  return match?.[0];
+}
+
+/**
+ * Assert the footer actually painted a status bar.
+ *
+ * `render()` swallows a render failure and returns `[]`, so "there is no cost
+ * figure" is satisfied by a footer that vanished. Any test whose point is the
+ * ABSENCE of a figure has to prove presence of something else first, or it
+ * passes for a blank screen.
+ */
+function expectRendered(lines: string[]): void {
+  const joined = lines.join(" ");
+  // `ctx.model` is undefined in these fixtures, so the model section reads
+  // "no-model"; the branch comes from the fake footerData.
+  expect(joined).toContain("no-model");
+  expect(joined).toContain("main");
+}
+
+describe("the footer counts a subagent's cost once", () => {
+  it("a toolResult entry carrying usage is already in the footer's total", async () => {
+    const { rendered, shutdown } = await installFooter([
+      assistantEntry("e1"),
+      toolResultEntry("e2", CHILD_USAGE),
+    ]);
+    const lines = rendered();
+    expect(paintedCost(lines)).toBe("$0.20");
+    expect(lines.join(" ")).toContain("↑" + formatTokenCount(CHILD_USAGE.input));
+    shutdown();
+  });
+
+  it("renders sensibly for a toolResult entry whose usage is null", async () => {
+    // Not hypothetical: pi 0.x persisted `usage: null` on every tool result, and
+    // those entries are still in old sessions on disk (one measured here:
+    // `{"role":"toolResult","toolName":"subagent","usage":null}`). A dereference
+    // of that field is a `NaN` in the cost line.
+    const { rendered, shutdown } = await installFooter([
+      assistantEntry("e1"),
+      toolResultEntry("e2", null),
+    ]);
+    const lines = rendered();
+    expectRendered(lines);
+    const cost = paintedCost(lines);
+    expect(cost === undefined || cost === "$0.00").toBe(true);
+    expect(lines.join(" ")).not.toContain("NaN");
+    shutdown();
+  });
+
+  it("paints no cost figure for a run that never reported one", async () => {
+    // The child that died before its first event, and every pre-spawn refusal,
+    // report zeros. `if (totalCost)` means the `$` section is simply absent — a
+    // child that cost nothing must not render as though it cost something, and
+    // must not push a bare `$0.00` into an otherwise clean line.
+    const zero = {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+    const { rendered, shutdown } = await installFooter([
+      assistantEntry("e1"),
+      toolResultEntry("e2", zero),
+    ]);
+    const lines = rendered();
+    expectRendered(lines);
+    expect(paintedCost(lines)).toBeUndefined();
+    shutdown();
+  });
+
+  it("ignores COST_UPDATE traffic on the handle: there is no accumulator left to double-count", async () => {
+    // The route this replaced (`subagent/src/cost.ts` → `COST_UPDATE` →
+    // `CostAccumulator`) added the same usage a second time on top of the entry
+    // scan above — measured at `$0.40` / `↑7.8k` for one child before the
+    // removal. Anything still publishing on that channel (the bridge's own
+    // self-usage emitter does) must not reach the status bar twice.
+    const { rendered, shutdown, bus } = await installFooter([
+      assistantEntry("e1"),
+      toolResultEntry("e2", CHILD_USAGE),
+    ]);
+    bus.emit(Events.COST_UPDATE, {
+      source: "subagent:reviewer",
+      inputTokens: CHILD_USAGE.input,
+      outputTokens: CHILD_USAGE.output,
+      cost: CHILD_USAGE.cost.total,
+    });
+    const lines = rendered();
+    expect(paintedCost(lines)).toBe("$0.20");
+    expect(lines.join(" ")).toContain("↑" + formatTokenCount(CHILD_USAGE.input));
+    expect(lines.join(" ")).not.toContain("↑" + formatTokenCount(CHILD_USAGE.input * 2));
+    shutdown();
+  });
+
+  it("starts a fresh session with nothing carried over from the handle", async () => {
+    // No accumulator and nothing queued behind it: a footer installed after an
+    // earlier session published COST_UPDATE still reports only what the session
+    // entries say. (The retired bus made this a real risk — an unmatched emit
+    // sat in a process-wide queue and replayed into the next subscriber.)
+    const first = await installFooter([assistantEntry("e1")]);
+    first.bus.emit(Events.COST_UPDATE, { source: "main", inputTokens: 9999, cost: 9.99 });
+    first.shutdown();
+
+    const { rendered, shutdown } = await installFooter([assistantEntry("e1")]);
+    const lines = rendered();
+    expectRendered(lines);
+    expect(paintedCost(lines)).toBeUndefined();
+    expect(lines.join(" ")).not.toContain("$9.99");
+    shutdown();
+  });
+});