@ferris1225/pi-subagents 4.3.11 → 4.3.12

package/CHANGELOG.md

@@ -1,8 +1,22 @@
 # Changelog
 
-Published versions of `@ferris1225/pi-subagents`. Unpublished numbers
-(`4.2.3`, `4.2.6`, `4.2.9`–`4.2.11`) never shipped on npm; their changes
-landed in the next published release.
+Release notes for `@ferris1225/pi-subagents`. Only the most recent releases
+are kept here; every published version is preserved as a GitHub Release.
+
+## 4.3.12
+
+- Replace pi's built-in consumption line with a per-model cost footer for the
+  main window: each `provider/model` keeps its own token flow, cost, context
+  share, thinking level, and live `tok/s` throughput, directly under the
+  current-project line. Settled models rank by spend, cap at three rows, and
+  drop token flow before truncating under width pressure. The tally reseeds
+  from the session file on reload.
+- Stop attaching awaited children's usage to the `subagent` tool result: pi
+  folds tool-result usage into one session total, which merged every model's
+  spend into the main window's consumption. Children keep reporting usage per
+  run with their model ref when they settle.
+- Group parallel completion totals per model instead of summing different
+  models' costs into one number.
 
 ## 4.3.11
 
@@ -80,186 +94,3 @@ landed in the next published release.
   reviews.
 - Drop the 4.3.5 retirement filter: configs written by 4.3.5–4.3.7 adopt `sentinel` once
   through the built-in adoption rule, and a deliberate disable in setup remains disabled.
-
-## 4.3.7
-
-- Make `subagent_control steer` continue rather than reject a thread that is no longer
-  live: a child that reached `completed` or `failed` before guidance lands (including
-  settlement between the state check and RPC acceptance) and a `parked` thread both
-  resume the same stable id with the guidance as their appended objective and retained
-  context when available.
-- Add `subagent_control park`: pause a running thread at a stable checkpoint, keep its
-  session and active worktree, write its durable record immediately, and return the
-  usage so far with the resume handle. Only an active running attempt with a retained
-  session can be parked; the generation body leaves publication to the park owner.
-- Reject an exact re-run of a finished brief while the thread that did the work still
-  holds its retained session, pointing at `resume` with an appended objective or at a
-  brief that states what changed. Active duplicates are still named first.
-- Rewrite the injected delegation directive around the brief contract a memoryless child
-  needs (objective and done condition, exact paths, established facts with citations,
-  boundaries, expected output), effort scaling, the steer/resume/park/stop routing for
-  follow-up work, and reading a truncated result's artifact only when the excerpt is
-  insufficient. The `subagent` task parameter states the same contract.
-- Deepen the built-in roles: scout, artisan, and steward start from the brief's cited
-  facts and stop at its done condition, resolve ambiguity by naming the reading taken
-  instead of asking, scout never drafts fixes or patches and marks unverified
-  conclusions `(inferred)`, artisan stops and reports a wrong premise instead of
-  substituting a change, steward runs only the checks that cover its own edits, and
-  every role reports each check as `command → result`.
-- Tell a resumed child that the workspace may have changed while the thread was inactive
-  so it re-reads a file before editing it, and frame an appended-objective resume as a
-  continuation of the same thread rather than sending the bare objective.
-- Clear a stopped generation's recorded child pids once its process tree has closed, so a
-  long-lived parked record can never direct a later restore at a reassigned pid. Remove
-  an unreachable objective-replacement prompt branch and the never-populated
-  `SessionSeed.prompt`.
-
-## 4.3.6
-
-- Add `subagent_control steer` for nonblank, parent-mediated guidance to the current active
-  RPC attempt without replacing its logical objective. Stable control serialization orders
-  steering against stop and AbortSignal shutdown; bounded ACKs keep stop responsive.
-- Refine the lean delegation directive: main owns architecture; for one high-stakes
-  uncertainty at most two read-only scouts may examine distinct hypotheses, without
-  capping unrelated disjoint scout scopes; main reconciles cited evidence, writers
-  and briefs never overlap, and new evidence steers the existing phase instead of
-  duplicating or restarting it.
-- Steer background completions and stop results into the next parent model boundary
-  instead of queuing them until the whole parent run settles, preventing stale notifications
-  from arriving after the main agent has already finished.
-- Validate durable session, worktree, repository, and recovery paths against their canonical
-  project-scoped layout before restore or cleanup. Forged and junction-escaping records are
-  dropped without deleting external targets.
-- Keep worktree and patch artifacts referenced by recovery records through durable sweeps and
-  stale project-root retention until their recovery notice can be delivered.
-- Clarify that worktree isolation protects Git changes rather than sandboxing child privileges
-  or third-party Pi packages.
-
-## 4.3.5
-
-- Restore `/subagents-setup`'s nested menu flow, fuzzy model picker, and disabled
-  custom-role discovery.
-- Retire the built-in `sentinel` role and mandatory pre-commit review workflow.
-  Config normalization, loading, and saving now remove its enabled/known entries
-  and model/thinking overrides while preserving every other custom role.
-- Keep role prompts self-contained: direct diagnosis, test, and cleanup rules remain,
-  while external loading directives are removed.
-- Delegate substantial independent phases more proactively while capping the child-process
-  pool at six and retaining phase leases, duplicate-dispatch rejection, and single-route delivery.
-- Move the extension assembly to package-root `index.ts`, group `src/` by responsibility,
-  and split thread restoration, shared lifecycle coordination, RPC control, and Git command
-  execution out of the largest modules. Pi now shows the package name without a `:src` suffix.
-
-## 4.3.4
-
-- Keep artisan, steward, and sentinel fully usable when Ferris skills are absent.
-  Installed matching skills add deeper guidance but are optional and never block a role.
-
-## 4.3.3
-
-- Add `sentinel`, a concise read-only adversarial reviewer that runs after cleanup,
-  follows artisan's configured model by default, requests maximum supported thinking,
-  and stays on the shared checkout.
-- Replace `/subagents-setup`'s sequential menus with one transactional overlay for
-  enabled roles, models, and thinking. Cancellation writes nothing; disabled custom
-  roles remain visible, and newly shipped built-ins are adopted exactly once.
-- Show each active run's effective `think:<level>` in the widget.
-- Expand scout into primary-source external research, make artisan the complete
-  primary-change owner, and keep detailed Ferris rules in skills while embedding the
-  minimum diagnosis, testing, cleanup, and evidence gates in role prompts.
-
-## 4.3.2
-
-- Let scout use active, known-safe retrieval plugins: `anchor_grep`, web content
-  tools, and Context7 documentation tools. Shells, mutation tools, and unknown
-  custom tools remain blocked.
-
-## 4.3.1
-
-- Make phase ownership explicit and reject an exact active duplicate by normalized
-  task plus resolved working directory, regardless of agent name.
-- Route each result exactly once: `wait: true` owns in-turn delivery, background
-  completions use follow-up wakeups, and immediate failures flush earlier successes.
-- Move worktree preparation under the bounded queue, release child-process slots
-  before Git finalization, and report repository-lane versus process-slot waits
-  accurately.
-- Keep missing restored worktrees failed, retained, and non-resumable; compute RPC
-  usage from generation-safe session-stat deltas.
-- Store the worktree recovery manifest under `ferris-pi-subagents/`, relocating
-  an existing agent-root manifest without losing retained artifact pointers.
-- Enforce a strict read-only scout tool set and strict declared-tool intersection.
-  Unknown custom tools remain conservatively write-capable for isolation.
-- Honor `enabledAgents`, including `[]`, without auto-enabling roles. Remove the
-  completed role/config migration bridge and shorten role prompts, tool metadata,
-  launch receipts, and handoffs.
-
-## 4.3.0
-
-- Built-in team is `scout`, `artisan`, and `steward`. All three stay enabled.
-- `explorer` / `executor` configs rename in place (models and thinking
-  overrides follow). `steward` is adopted. That migration is deleted in the
-  next major.
-- Artisan owns implement / fix / refactor / test. Steward owns cleanup, docs
-  sync, and merge — dispatched only when that work exists.
-- Thinking is a role default (scout low, artisan high, steward medium) that
-  `/subagents-setup` can override. Per-call `thinking` and agent-file
-  `thinking` are gone. There is no Auto row.
-- First session and first-run setup explain each role and ask for a model.
-- Unit tests cover catalog migration, role prompts, dispatch routing, and
-  honest footer / truncation notes.
-
-## 4.2.13
-
-- README: table of contents, a What's new lead-in, and a pointer at this
-  changelog. Release notes describe the live `main` → npm path.
-
-## 4.2.12
-
-- Executor confirms each named defect on current code before editing.
-- Footer settled counts stay on the line only while a sibling is live, and
-  widget truncation no longer lies about what was cut.
-- Merging to `main` publishes an unpublished `package.json` version to npm
-  and opens a matching GitHub Release.
-
-## 4.2.8
-
-- Always-visible footer roll-up: `subagents 2 running · 1 repo lane · 3 done`.
-- `wait: true` streams progress onto the tool card and reports child token
-  spend as the call's own usage.
-- Completions are held while context compaction rewrites history, then
-  released on success, failure, or abort.
-- A delivered result no longer enters the parent context a second time.
-- Isolated worktrees link `node_modules`.
-- Widget worktree badge is spelled out (`worktree:a91f3c`).
-
-## 4.2.7
-
-- Executor routing is a single self-contained deliverable; `thinking` can
-  be set per dispatch.
-- Child prompt temp directories are removed recursively.
-
-## 4.2.5
-
-- The threads manifest lives per project, beside that project's artifacts.
-
-## 4.2.4
-
-- Explorer findings are one-line retrieval leads.
-- Worktree recovery retries cleanup when the patch was already applied.
-
-## 4.2.2
-
-- A single artifact the main agent must fully absorb stays an inline read;
-  re-reads are bounded.
-
-## 4.2.1
-
-- Upgraded configs prune retired built-in roles so the setup wizard never
-  mixes old and new names.
-
-## 4.2.0
-
-- Built-in team is `explorer` and `executor`. The old
-  `worker` / `cleaner` / `documenter` / `synthesizer` / `reviewer` set is
-  gone.
-- Live widget splits each run into an identity line and a dim activity line.

package/README.md

@@ -12,10 +12,11 @@ once and your main agent delegates on its own.
 
 ## What's new
 
-**4.3.11** — simplifies delegation and role prompts using GPT-6 Astra guidance:
-clear outcomes, task-sized research and verification, and optional cleanup/review
-instead of fixed routines. Existing permission boundaries, required project checks,
-one-shot ownership, and runtime safety mechanisms remain unchanged.
+**4.3.12** — per-model accounting: the main window's consumption line becomes a
+per-model cost footer (token flow, cost, context share, and live `tok/s` per
+`provider/model`), awaited children's usage is no longer folded into the parent
+session total, and parallel completion totals are grouped per model instead of
+summed across them.
 
 See [CHANGELOG.md](./CHANGELOG.md).
 
@@ -367,6 +368,29 @@ RPC hosts as well as the TUI. Settled counts stay on the line only while a
 sibling is still live (`2 running · 3 done`); the line disappears once nothing
 is active.
 
+### Per-model cost footer
+
+In TUI sessions the extension replaces pi's built-in consumption line with a
+per-model tally of the main window's own spend, directly under the
+current-project line. Models are never merged: each `provider/model` keeps its
+own token flow, cost, and — for the current model — context share, effective
+thinking level, and live throughput (`~` marks the streaming estimate; the
+exact rate of the last completed message replaces it):
+
+```text
+~/projs/app (main)
+↑48.1k ↓112.7k R1.9M W302.4k $3.0812 · 41.2%/200.0k · ~58.3 tok/s     zhipu/glm-4.7 • high
+anthropic/claude-sonnet-4 ↑12.0k ↓31.2k R410.0k $0.9104
+```
+
+Settled models rank by spend and cap at three rows (`… +N more models`);
+under width pressure a settled row drops its token flow before truncating, so
+`model $cost` always survives. Sub-agent spend is deliberately not folded in:
+children report their own usage per run when they settle, and pi would
+otherwise attribute it to one session total — exactly the cross-model merge
+this footer exists to avoid. The ledger reseeds from the session file on
+reload, so the tally survives restarts.
+
 Completions resume the main agent on their own, with a compact block of at most 40
 lines by default; longer output lands unchanged in a Markdown artifact whose path
 comes with the message, stated as how much was actually cut (`40 of 137 lines
@@ -381,11 +405,19 @@ Delivery is held while a context compaction is in flight and released once it
 settles — on failure and abort too — so a result a child spent minutes producing
 is never swallowed by the summary that replaces the history.
 
-A `wait: true` dispatch streams its progress onto the tool card while it waits,
-and reports the awaited children's token spend as the tool call's own usage, so
-sub-agent cost lands in the footer, `/session`, and RPC session totals. A
-background dispatch returns before its children finish, so it reports no usage
-rather than a fabricated number.
+A `wait: true` dispatch streams its progress onto the tool card while it waits.
+Usage is no longer attached to the tool result: pi folds tool-result usage into
+one session total, which merged every model's spend into the main window's
+consumption line. Instead, each child reports its usage per run — with its full
+`provider/model` ref — when it settles, and a parallel group's footer totals
+are grouped per model, never summed across them:
+
+```text
+Totals: 3 runs · zhipu/glm-4.7: ↓300 $0.0500 · anthropic/claude-sonnet-4: ↓4.0k $1.5000
+```
+
+A background dispatch returns before its children finish; their usage arrives
+with the completion message instead.
 
 ## Models, thinking, and tools
 
@@ -543,7 +575,9 @@ It is not bundled into the extension, and no replacement RPC server is introduce
 
 ## Changelog
 
-See [CHANGELOG.md](./CHANGELOG.md) for published release notes.
+See [CHANGELOG.md](./CHANGELOG.md) for the latest release notes. Every
+published version is preserved as a GitHub Release; older entries are trimmed
+from the file.
 
 ## Release
 

package/index.ts

@@ -31,6 +31,8 @@ import { createRuntime } from "./src/lifecycle/runtime.ts";
 import { bootstrapDurableState } from "./src/lifecycle/thread-restore.ts";
 import { registerLookupTools } from "./src/lifecycle/tools.ts";
 import { registerAnnouncements } from "./src/presentation/announcements.ts";
+import { registerMainCostTracking } from "./src/presentation/cost-ledger.ts";
+import { clearCostFooter } from "./src/presentation/cost-footer.ts";
 import { matchRunIds } from "./src/presentation/format.ts";
 import { clearActiveRunsStatus } from "./src/presentation/status.ts";
 import { clearActiveRunsWidget } from "./src/presentation/widget.ts";
@@ -66,12 +68,14 @@ export default function (pi: ExtensionAPI): void {
 	pi.on("session_shutdown", async (_event, ctx) => {
 		clearActiveRunsStatus(ctx);
 		clearActiveRunsWidget(ctx);
+		clearCostFooter(ctx);
 		await runtime.shutdown();
 	});
 
 	registerSubagentTool(pi, runtime);
 	registerSubagentRiskTool(pi);
 	registerLookupTools(pi, runtime);
+	registerMainCostTracking(pi);
 
 	pi.registerCommand("subagents-setup", {
 		description: "Configure pi-subagents: agents, models, and per-role thinking",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "4.3.11",
+  "version": "4.3.12",
   "description": "A managed sub-agent team for pi: scout, artisan, steward, and sentinel roles, one-shot runs, read-only status, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/delegation/dispatch.ts

@@ -6,7 +6,7 @@
  * completion ownership live in thread-lifecycle.ts.
  */
 
-import { StringEnum, type Usage } from "@earendil-works/pi-ai";
+import { StringEnum } from "@earendil-works/pi-ai";
 import { resolve } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
@@ -20,7 +20,6 @@ import {
 	monitor,
 	statusIcon,
 	statusLabel,
-	sumUsage,
 	type RunWaitReason,
 } from "../presentation/monitor.ts";
 import { findDuplicateDispatch, formatParallelScopeAdmissionNote, formatPhaseLeaseReceipt } from "./prompt.ts";
@@ -227,30 +226,10 @@ function parallelAdmissionConflict(
 	return undefined;
 }
 
-/** Map the child's own usage tally onto pi's tool-result `Usage`, so sub-agent
- * token spend lands in the parent's footer, /session, and RPC session totals
- * instead of being invisible. Only the total cost is known here: a child
- * reports one cost number, not a per-bucket split. */
-function toToolUsage(stats: UsageStats): Usage {
-	return {
-		input: stats.input,
-		output: stats.output,
-		cacheRead: stats.cacheRead,
-		cacheWrite: stats.cacheWrite,
-		totalTokens: stats.input + stats.output + stats.cacheRead + stats.cacheWrite,
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: stats.cost },
-	};
-}
-
-/** Usage of the runs awaited in-turn. Omitted entirely in the background path:
- * those children have not finished when the tool returns, so any number there
- * would be a fabrication. */
-function toolUsage(runtime: SubagentRuntime, runIds: number[]): { usage?: Usage } {
-	const parts = runIds
-		.map((id) => runtime.settledRuns.get(id)?.usage)
-		.filter((usage): usage is UsageStats => usage !== undefined);
-	return parts.length > 0 ? { usage: toToolUsage(sumUsage(parts)) } : {};
-}
+/** Awaited children report their usage per run and per model in the result
+ * blocks below; nothing is attached to the tool result itself, because pi
+ * folds tool-result usage into one session total — that merged every
+ * model's spend into the main window's consumption line. */
 
 /** In-turn wait for a fresh dispatch. Registration resolves it without a model-chosen
  * timer; parent abort or removal ends the wait without losing background delivery. */
@@ -631,7 +610,6 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 					return {
 						content: [{ type: "text", text }],
 						details: makeDetails("parallel", true)(results),
-						...toolUsage(runtime, startedIds),
 					};
 				}
 				const text = [
@@ -686,7 +664,6 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 				return {
 					content: [{ type: "text", text: blocks }],
 					details: makeDetails("single", true)([result]),
-					...toolUsage(runtime, [result.runId]),
 				};
 			}
 			return {

package/src/lifecycle/completion.ts

@@ -7,9 +7,8 @@
  * failure directly so it is never delayed.
  */
 
-import { formatUsageCompact, sumUsage, type RunWaitReason } from "../presentation/monitor.ts";
+import { formatUsageTokens, sumUsage, type RunWaitReason } from "../presentation/monitor.ts";
 import type { UsageStats } from "../execution/rpc-control.ts";
-
 export interface CompletionBatchTimings {
 	debounceMs: number;
 	maxWaitMs: number;
@@ -100,20 +99,42 @@ export interface CompletionMessageItem {
 	block: string;
 	/** Final usage of the underlying run (or chain); aggregated into the group totals. */
 	usage?: UsageStats;
+	/** Model ref that produced this run's usage; group totals stay per model
+	 * instead of summing different models' spend into one number. */
+	model?: string;
 }
 
-/** Keep the established single-result shape; add a group header and an aggregate
+/** Keep the established single-result shape; add a group header and a per-model
  * token/cost footer only for real groups. */
 export function formatCompletionMessage(items: readonly CompletionMessageItem[]): string {
 	if (items.length === 0) return "";
 	if (items.length === 1) return items[0].block;
 	const agents = items.map((item) => item.agent).join(", ");
-	const withUsage = items.filter((item) => item.usage !== undefined);
-	const totals = withUsage.length > 0 ? formatUsageCompact(sumUsage(withUsage.map((item) => item.usage!))) : "";
+	const totals = perModelTotals(items);
 	const footer = totals ? `\n\nTotals: ${items.length} runs · ${totals}` : "";
 	return `### Subagents completed (${items.length}): ${agents}\n\n${items.map((item) => item.block).join("\n\n")}${footer}`;
 }
 
+/** One `model ↑x ↓y $z` segment per model, first-seen order — models are never
+ * merged, because each model's spend comes out of its own budget. The cost is
+ * always present (even `$0.0000`) so every model line reads as a tally. */
+export function perModelTotals(items: readonly CompletionMessageItem[]): string {
+	const byModel = new Map<string, UsageStats[]>();
+	for (const item of items) {
+		if (item.usage === undefined) continue;
+		const key = item.model?.trim() || "unknown model";
+		byModel.set(key, [...(byModel.get(key) ?? []), item.usage]);
+	}
+	if (byModel.size === 0) return "";
+	return [...byModel.entries()]
+		.map(([model, parts]) => {
+			const total = sumUsage(parts);
+			const tokens = formatUsageTokens(total);
+			return `${model}: ${tokens ? `${tokens} ` : ""}$${total.cost.toFixed(4)}`;
+		})
+		.join(" · ");
+}
+
 /** Minimal shape of an active run, for the "others still running" footer. Kept
  * decoupled from the monitor's RunView so this stays a pure, easily tested
  * formatter; the caller maps its live runs into this shape. */

package/src/lifecycle/thread-lifecycle.ts

@@ -343,6 +343,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 						? `${formatCompletionBlock(result, runConfig.maxResultLines, { resultRoot: projectResultsRoot(runtime.configPath, result.projectCwd ?? originalCwd) })}\n\n${modelLevelTakeoverNote(result)}`
 						: formatCompletionBlock(result, runConfig.maxResultLines, { resultRoot: projectResultsRoot(runtime.configPath, result.projectCwd ?? originalCwd) }),
 					usage: result.usage,
+					model: result.model,
 				};
 				if (modelLevel) {
 					const detail = result.errorMessage?.trim() || "model unavailable or broken";

package/src/presentation/announcements.ts

@@ -6,6 +6,8 @@ import { FIRST_RUN_SETUP_HINT, loadConfig, saveConfig } from "../configuration/c
 import { availableModelsInScope, filterUnavailableModelOverrides } from "../configuration/models.ts";
 import { announceRecoveryRecords, relocateRecoveryManifest } from "../isolation/recovery.ts";
 import type { SubagentRuntime } from "../lifecycle/runtime.ts";
+import { seedCostLedgerFromSession } from "./cost-ledger.ts";
+import { installCostFooter } from "./cost-footer.ts";
 import { installActiveRunsStatus } from "./status.ts";
 import { installActiveRunsWidget } from "./widget.ts";
 
@@ -50,10 +52,14 @@ export function registerAnnouncements(pi: ExtensionAPI, runtime: SubagentRuntime
 				"info",
 			);
 		}
-		// The footer status works in every UI host (TUI and RPC); the widget is TUI-only.
+		// The footer status works in every UI host (TUI and RPC); the widget and
+		// the per-model cost footer are TUI-only. Seeding first means the first
+		// footer render already carries the reloaded session's per-model spend.
 		installActiveRunsStatus(ctx);
 		if (ctx.mode !== "tui") return;
+		seedCostLedgerFromSession(ctx);
 		installActiveRunsWidget(ctx);
+		installCostFooter(ctx);
 	});
 
 	// Compaction failures are otherwise silent in long orchestration sessions

package/src/presentation/cost-footer.ts

@@ -0,0 +1,201 @@
+/**
+ * Persistent cost footer: replaces pi's built-in consumption line with a
+ * per-model tally of the main window's own spend, so models are never summed
+ * into one number — each `provider/model` keeps its own token flow, cost,
+ * context share, and live throughput. The current-project line stays first,
+ * exactly where pi put it; extension statuses stay last.
+ *
+ * Sub-agent spend is intentionally absent: children report per-run usage with
+ * their model ref when they settle, and injecting it here (or into the parent
+ * session totals) is what mixed unrelated models' costs before.
+ */
+
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import { costLedger, latestTrackedContext, type ModelSpendRow } from "./cost-ledger.ts";
+import { formatTokens, formatUsageTokens } from "./monitor.ts";
+import type { UsageStats } from "../execution/rpc-control.ts";
+
+/** Footer data as injected by pi's `setFooter` factory; only the read-only
+ * surface exists in types, so keep the structural shape local. */
+interface FooterData {
+	getGitBranch(): string | null;
+	getExtensionStatuses(): ReadonlyMap<string, string>;
+	onBranchChange(callback: () => void): () => void;
+}
+
+/** Context pieces the footer renders against; falls back to the latest event
+ * context so a fresh install still sees live session state. */
+type RenderContext = Partial<Pick<ExtensionContext, "sessionManager" | "getContextUsage" | "model" | "thinkingLevel">>;
+
+/** Minimum gap between the stats left side and the right-aligned model. */
+const MIN_PADDING = 2;
+/** Settled-model rows shown after the current one; anything older collapses
+ * into one overflow marker so the footer's height stays bounded no matter how
+ * many models a session switched through. */
+const MAX_SETTLED_MODEL_ROWS = 3;
+
+/** Home-relative project path, matching the built-in footer's `~` form. */
+function formatProjectPath(cwd: string, home: string | undefined): string {
+	if (!home) return cwd;
+	const resolvedCwd = resolve(cwd);
+	const resolvedHome = resolve(home);
+	const relativeToHome = relative(resolvedHome, resolvedCwd);
+	const isInsideHome = relativeToHome === "" ||
+		(relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
+	if (!isInsideHome) return cwd;
+	return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}
+
+/** The `12%/200k` context share of the current model; colored by pressure
+ * like the built-in footer did. */
+function contextPart(theme: Theme, usage: { percent?: number | null; contextWindow?: number } | undefined): string {
+	if (!usage || !usage.contextWindow || usage.contextWindow <= 0) return "";
+	const percent = usage.percent === null || usage.percent === undefined
+		? "?"
+		: usage.percent.toFixed(1);
+	const display = `${percent}%/${formatTokens(usage.contextWindow)}`;
+	if (typeof usage.percent === "number" && usage.percent > 90) return theme.fg("error", display);
+	if (typeof usage.percent === "number" && usage.percent > 70) return theme.fg("warning", display);
+	return display;
+}
+
+function speedPart(speed: { tokensPerSecond: number; streaming: boolean } | undefined): string {
+	if (!speed || speed.tokensPerSecond <= 0) return "";
+	return `${speed.streaming ? "~" : ""}${speed.tokensPerSecond.toFixed(1)} tok/s`;
+}
+
+function spendUsage(spend: ModelSpendRow["spend"]): UsageStats {
+	return { ...spend, contextTokens: 0, turns: 0 };
+}
+
+/** One `↑in ↓out R r W w $cost` flow for a model row; zero components drop
+ * out, but a model with no spend at all still shows its bare `$0.0000` so the
+ * row reads as a tally rather than an empty label. */
+function spendPart(spend: ModelSpendRow["spend"]): string {
+	return [formatUsageTokens(spendUsage(spend)), `$${spend.cost.toFixed(4)}`].filter(Boolean).join(" ");
+}
+
+/** Current-model row: stats left, model identity right-aligned — the built-in
+ * footer's geometry, applied to the ledger row. */
+function currentModelLine(
+	row: ModelSpendRow,
+	theme: Theme,
+	width: number,
+	ctx: RenderContext,
+): string {
+	const parts = [spendPart(row.spend)];
+	const context = contextPart(theme, ctx.getContextUsage?.());
+	if (context) parts.push(context);
+	const speed = costLedger.speed();
+	if (speed && speed.model === row.model) {
+		const part = speedPart(speed);
+		if (part) parts.push(part);
+	}
+	let left = parts.join(" ");
+	if (visibleWidth(left) > width) left = truncateToWidth(left, width, "…");
+
+	let right = row.model;
+	if (ctx.model?.reasoning && ctx.thinkingLevel) {
+		right = ctx.thinkingLevel === "off" ? `${right} • thinking off` : `${right} • ${ctx.thinkingLevel}`;
+	}
+	// The provider prefix duplicates the ref's own `provider/` half, so keep it
+	// only for the bare-id shape a providerless ref produces.
+	const leftWidth = visibleWidth(left);
+	if (leftWidth + MIN_PADDING + visibleWidth(right) > width) {
+		const available = width - leftWidth - MIN_PADDING;
+		if (available <= 0) return theme.fg("dim", left);
+		right = truncateToWidth(right, available, "");
+	}
+	const padding = " ".repeat(Math.max(MIN_PADDING, width - leftWidth - visibleWidth(right)));
+	return theme.fg("dim", `${left}${padding}${right}`);
+}
+
+/** Settled-model row: the model ref leads because that is the line's whole
+ * point — which model, what it cost. Under width pressure the token flow drops
+ * first (the cost is the headline), then the line truncates. */
+function settledModelLine(row: ModelSpendRow, theme: Theme, width: number): string {
+	const full = `${row.model} ${spendPart(row.spend)}`;
+	if (visibleWidth(full) <= width) return theme.fg("dim", full);
+	const bare = `${row.model} $${row.spend.cost.toFixed(4)}`;
+	if (visibleWidth(bare) <= width) return theme.fg("dim", bare);
+	return truncateToWidth(theme.fg("dim", full), width, "…");
+}
+
+/** Render the replacement footer: project line first, one line per model the
+ * main window spent on (current model with context + throughput), extension
+ * statuses last — the same slots the built-in footer used. Settled models are
+ * ranked by spend and capped, so a session that switched through many models
+ * never grows the footer without bound. */
+export function renderCostFooter(
+	width: number,
+	theme: Theme,
+	footerData: FooterData | undefined,
+	ctx: RenderContext,
+): string[] {
+	const live = latestTrackedContext() ?? ctx;
+	const sessionManager = live.sessionManager ?? ctx.sessionManager;
+	const lines: string[] = [];
+
+	let project = formatProjectPath(sessionManager?.getCwd() ?? "", process.env.HOME || process.env.USERPROFILE);
+	const branch = footerData?.getGitBranch();
+	if (branch) project = `${project} (${branch})`;
+	const sessionName = sessionManager?.getSessionName();
+	if (sessionName) project = `${project} • ${sessionName}`;
+	lines.push(truncateToWidth(theme.fg("dim", project), width, theme.fg("dim", "…")));
+
+	const rows = costLedger.snapshot();
+	if (rows.length > 0) {
+		const current = rows.find((row) => row.current);
+		if (current) lines.push(currentModelLine(current, theme, width, live));
+		const settled = rows
+			.filter((row) => !row.current)
+			.sort((left, right) => right.spend.cost - left.spend.cost);
+		for (const row of settled.slice(0, MAX_SETTLED_MODEL_ROWS)) {
+			lines.push(settledModelLine(row, theme, width));
+		}
+		const hidden = settled.length - MAX_SETTLED_MODEL_ROWS;
+		if (hidden > 0) {
+			lines.push(theme.fg("dim", `… +${hidden} more model${hidden === 1 ? "" : "s"}`));
+		}
+	}
+
+	const statuses = footerData?.getExtensionStatuses();
+	if (statuses && statuses.size > 0) {
+		const statusLine = [...statuses.entries()]
+			.sort(([left], [right]) => left.localeCompare(right))
+			.map(([, text]) => stripVTControlCharacters(text).replace(/[\r\n\t]+/g, " ").replace(/ +/g, " ").trim())
+			.join(" ");
+		lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "…")));
+	}
+	return lines;
+}
+
+/**
+ * Replace pi's built-in footer with the per-model cost footer. The factory
+ * re-renders on ledger updates and git branch changes; context, model, and
+ * thinking state come from the freshest event context available.
+ */
+export function installCostFooter(ctx: Pick<ExtensionContext, "mode" | "ui"> & RenderContext): void {
+	if (ctx.mode !== "tui") return;
+	ctx.ui.setFooter((tui, theme, footerData) => {
+		const unsubscribe = [
+			costLedger.subscribe(() => tui.requestRender()),
+			footerData.onBranchChange(() => tui.requestRender()),
+		];
+		return {
+			render: (width: number) => renderCostFooter(width, theme, footerData, ctx),
+			invalidate() {},
+			dispose() {
+				for (const stop of unsubscribe) stop();
+			},
+		};
+	});
+}
+
+/** Restore pi's built-in footer. */
+export function clearCostFooter(ctx: Pick<ExtensionContext, "mode" | "ui">): void {
+	if (ctx.mode === "tui") ctx.ui.setFooter(undefined);
+}

package/src/presentation/cost-ledger.ts

@@ -0,0 +1,286 @@
+/**
+ * Per-model spend ledger for the main window's own generation.
+ *
+ * Sub-agent runs are deliberately not tracked here: every child reports its
+ * usage with its model ref when it settles (completion block, widget row,
+ * per-model completion totals), so mixing its live spend into the parent's
+ * footer would just re-create the cross-model sum this ledger exists to
+ * avoid. The ledger covers the main window only — across `/model` switches,
+ * each model keeps its own tally — plus its live token throughput.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { modelRef } from "../configuration/models.ts";
+
+export interface ModelSpend {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+}
+
+export interface ModelSpendRow {
+	/** Full `provider/model` ref. */
+	model: string;
+	/** True while this is the window's current model. */
+	current: boolean;
+	spend: ModelSpend;
+}
+
+export interface MainStreamSpeed {
+	model: string;
+	tokensPerSecond: number;
+	/** True while the assistant is still streaming (value is an estimate). */
+	streaming: boolean;
+}
+
+interface StreamState {
+	model: string;
+	startedAt: number;
+	estimatedChars: number;
+}
+
+/** Rough chars-per-token for the live estimate; the exact rate replaces it at
+ * `message_end`, where real output tokens are known. */
+const ESTIMATED_CHARS_PER_TOKEN = 4;
+
+/** pi Usage shape: numeric token buckets plus a cost that is either already a
+ * number (child tallies) or the provider object with a `total`. */
+interface UsageLike {
+	input?: unknown;
+	output?: unknown;
+	cacheRead?: unknown;
+	cacheWrite?: unknown;
+	cost?: unknown;
+}
+
+function emptySpend(): ModelSpend {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+}
+
+/** `provider/model` for a message; falls back to the bare model id when a
+ * providerless message sneaks through. */
+export function messageModelRef(message: { provider?: string; model?: string }): string | undefined {
+	const model = message.model?.trim();
+	if (!model) return undefined;
+	return message.provider?.trim() ? `${message.provider.trim()}/${model}` : model;
+}
+
+function finiteUsage(usage: UsageLike | undefined): ModelSpend {
+	const num = (value: unknown): number => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+	const cost = usage?.cost;
+	return {
+		input: num(usage?.input),
+		output: num(usage?.output),
+		cacheRead: num(usage?.cacheRead),
+		cacheWrite: num(usage?.cacheWrite),
+		cost: num(typeof cost === "object" && cost !== null ? (cost as { total?: unknown }).total : cost),
+	};
+}
+
+export class CostLedger {
+	private rows = new Map<string, ModelSpend>();
+	/** First-seen order, so row order is stable between notifications. */
+	private order: string[] = [];
+	private currentModel: string | undefined;
+	private stream: StreamState | undefined;
+	private lastSpeed: MainStreamSpeed | undefined;
+	private subscribers = new Set<() => void>();
+
+	record(model: string, spend: UsageLike | undefined): void {
+		const ref = model.trim();
+		if (!ref) return;
+		const row = this.rows.get(ref) ?? emptySpend();
+		const add = finiteUsage(spend);
+		row.input += add.input;
+		row.output += add.output;
+		row.cacheRead += add.cacheRead;
+		row.cacheWrite += add.cacheWrite;
+		row.cost += add.cost;
+		if (!this.rows.has(ref)) this.order.push(ref);
+		this.rows.set(ref, row);
+		this.notify();
+	}
+
+	markCurrentModel(model: string | undefined): void {
+		const ref = model?.trim() || undefined;
+		if (ref === this.currentModel) return;
+		this.currentModel = ref;
+		this.notify();
+	}
+
+	getCurrentModel(): string | undefined {
+		return this.currentModel;
+	}
+
+	/** Current model first, everything else in first-seen order. A current
+	 * model with no spend yet still gets a zero row so the footer keeps its
+	 * shape from the first render. */
+	snapshot(): ModelSpendRow[] {
+		const rows: ModelSpendRow[] = [];
+		if (this.currentModel) {
+			rows.push({ model: this.currentModel, current: true, spend: this.rows.get(this.currentModel) ?? emptySpend() });
+		}
+		for (const model of this.order) {
+			if (model === this.currentModel) continue;
+			rows.push({ model, current: false, spend: this.rows.get(model) ?? emptySpend() });
+		}
+		return rows;
+	}
+
+	reset(): void {
+		this.rows.clear();
+		this.order = [];
+		this.currentModel = undefined;
+		this.stream = undefined;
+		this.lastSpeed = undefined;
+		this.notify();
+	}
+
+	subscribe(cb: () => void): () => void {
+		this.subscribers.add(cb);
+		return () => {
+			this.subscribers.delete(cb);
+		};
+	}
+
+	noteStreamStart(model: string): void {
+		this.stream = { model, startedAt: Date.now(), estimatedChars: 0 };
+		this.lastSpeed = undefined;
+		this.notify();
+	}
+
+	noteStreamDelta(chars: number): void {
+		if (!this.stream || chars <= 0) return;
+		this.stream.estimatedChars += chars;
+		this.notify();
+	}
+
+	isStreaming(): boolean {
+		return this.stream !== undefined;
+	}
+
+	noteStreamEnd(model: string, outputTokens: number): void {
+		const stream = this.stream;
+		this.stream = undefined;
+		if (stream && outputTokens > 0) {
+			const seconds = Math.max(0.001, (Date.now() - stream.startedAt) / 1_000);
+			this.lastSpeed = { model, tokensPerSecond: outputTokens / seconds, streaming: false };
+		}
+		this.notify();
+	}
+
+	/** Live estimate while streaming, exact rate of the last completed
+	 * assistant message afterwards; undefined before any generation. */
+	speed(): MainStreamSpeed | undefined {
+		if (this.stream) {
+			const seconds = Math.max(0.001, (Date.now() - this.stream.startedAt) / 1_000);
+			return {
+				model: this.stream.model,
+				tokensPerSecond: this.stream.estimatedChars / ESTIMATED_CHARS_PER_TOKEN / seconds,
+				streaming: true,
+			};
+		}
+		return this.lastSpeed;
+	}
+
+	private notify(): void {
+		for (const cb of this.subscribers) {
+			try {
+				cb();
+			} catch {
+				/* subscriber errors must not break accounting */
+			}
+		}
+	}
+}
+
+export const costLedger = new CostLedger();
+
+/** Latest event context, so the footer renders against live session state
+ * (context usage, cwd, session name) without holding a stale install-time ctx. */
+let latestContext: ExtensionContext | undefined;
+
+/** Wire the main window's own generation into the ledger: assistant messages
+ * carry the serving model and exact usage, model switches re-key the current
+ * row, and compaction calls land on the model that made them. */
+export function registerMainCostTracking(pi: ExtensionAPI): void {
+	const remember = (ctx: ExtensionContext): void => {
+		latestContext = ctx;
+	};
+
+	pi.on("message_start", async (event, ctx) => {
+		remember(ctx);
+		const message = (event as { message?: { role?: string } }).message;
+		if (message?.role !== "assistant") return;
+		const ref = messageModelRef(message as { provider?: string; model?: string });
+		if (ref) costLedger.noteStreamStart(ref);
+	});
+
+	pi.on("message_update", async (event, ctx) => {
+		remember(ctx);
+		const delta = (event as { assistantMessageEvent?: { type?: string; delta?: string } }).assistantMessageEvent;
+		if (delta?.type !== "text_delta" && delta?.type !== "thinking_delta") return;
+		// `message_start` does not always carry the model yet; the first delta
+		// of the stream is just as good a clock start.
+		if (!costLedger.isStreaming()) {
+			const partial = (event as { message?: { role?: string } }).message;
+			if (partial?.role === "assistant") {
+				const ref = messageModelRef(partial as { provider?: string; model?: string });
+				if (ref) costLedger.noteStreamStart(ref);
+			}
+		}
+		costLedger.noteStreamDelta(delta.delta?.length ?? 0);
+	});
+
+	pi.on("message_end", async (event, ctx) => {
+		remember(ctx);
+		const message = (event as { message?: { role?: string; provider?: string; model?: string; usage?: UsageLike } }).message;
+		if (message?.role !== "assistant") return;
+		const ref = messageModelRef(message) ?? costLedger.getCurrentModel();
+		if (!ref) return;
+		const usage = finiteUsage(message.usage);
+		costLedger.noteStreamEnd(ref, usage.output);
+		costLedger.record(ref, usage);
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		remember(ctx);
+		costLedger.markCurrentModel(modelRef(event.model));
+	});
+
+	pi.on("session_compact", async (event, ctx) => {
+		remember(ctx);
+		const usage = (event as { compactionEntry?: { usage?: UsageLike } }).compactionEntry?.usage;
+		const ref = costLedger.getCurrentModel() ?? (latestContext?.model ? modelRef(latestContext.model) : undefined);
+		if (usage && ref) costLedger.record(ref, finiteUsage(usage));
+	});
+}
+
+/** Rebuild the ledger from the persisted session after a reload or session
+ * switch, then key the current row to the window's model. Compaction and
+ * branch-summary LLM calls carry no model of their own, so they land on the
+ * current model — the one that made them. */
+export function seedCostLedgerFromSession(ctx: {
+	sessionManager: { getEntries(): Array<{ type: string; message?: unknown; usage?: UsageLike }> };
+	model?: { provider: string; id: string } | undefined;
+}): void {
+	costLedger.reset();
+	costLedger.markCurrentModel(ctx.model ? modelRef(ctx.model) : undefined);
+	const current = costLedger.getCurrentModel();
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type === "message") {
+			const message = entry.message as { role?: string; provider?: string; model?: string; usage?: UsageLike } | undefined;
+			if (message?.role !== "assistant") continue;
+			const ref = messageModelRef(message);
+			if (ref) costLedger.record(ref, finiteUsage(message.usage));
+		} else if ((entry.type === "compaction" || entry.type === "branch_summary") && entry.usage && current) {
+			costLedger.record(current, finiteUsage(entry.usage));
+		}
+	}
+}
+
+export function latestTrackedContext(): ExtensionContext | undefined {
+	return latestContext;
+}

package/src/presentation/monitor.ts

@@ -264,7 +264,7 @@ export function shrinkRunLabel(text: string, maxWidth: number): string {
 	return `${TASK_SUMMARY_ELLIPSIS}${tailGraphemes(chars, maxWidth - 1)}`;
 }
 
-function formatTokens(count: number): string {
+export function formatTokens(count: number): string {
 	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
 	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
 	return String(count);