@linxiraos/pi-tui 1.2.0 → 1.3.0

package/src/overlays/advisor-config.ts

@@ -34,7 +34,16 @@ import { sanitizeDisplayWarnings } from "../render/render-utils";
 import { formatKeyHint } from "../app-keybindings";
 import { editorKey, editorKeys } from "../chrome/keybinding-hints";
 import { HookEditorComponent } from "./hook-editor";
-import { buildBrowserItems, ModelBrowser, type ModelBrowserSource, sortModelItems } from "./model-browser";
+import {
+	buildBrowserItems,
+	MODEL_PICKER_COLUMNS,
+	ModelBrowser,
+	type ModelBrowserItem,
+	type ModelBrowserSource,
+	type ModelPickerCatalogue,
+	type ModelPickerOrder,
+	sortModelItems,
+} from "./model-browser";
 import { bottomBorder, divider, dividerSplit, PanelRows, row, topBorder, topBorderSplit } from "../chrome/overlay-box";
 import { isLayoutMouseRoutable } from "../components/layout/geometry";
 import { SplitPane } from "../components/layout/split-pane";
@@ -42,7 +51,16 @@ import { Stack } from "../components/layout/stack";
 import type { TspPrefsProps, TspPrefsRow, TspSpan } from "@linxiraos/pi-wire";
 import { col, node, span, text } from "../native/describe";
 import type { DescribeContext, NativeChild, NativeNode, NativeUiEvent } from "../native/node";
-import { actionHint, hintsRow, type NativeHint, overlayCard } from "../native/overlay";
+import { actionBar, actionButton, actionHint, hintsRow, type NativeHint, overlayCard } from "../native/overlay";
+import {
+	CLOSE_ACTION,
+	pickerAction,
+	pickerEvent,
+	routeSelectListPicker,
+	type SelectPickerOptions,
+	selectListPicker,
+} from "../native/picker";
+import { getThinkingLevelMetadata, parseThinkingLevel } from "../thinking";
 
 export const ADVISOR_REVIEW_MODES = ["turn", "agent-end"] as const;
 export const ADVISOR_SYNC_BACKLOG_MODES = ["off", "1", "3", "5", "strict"] as const;
@@ -205,6 +223,40 @@ function formatAdvisorTools(tools: readonly string[] | undefined, emptyLabel: st
 /** Choice value for "no per-advisor override"; matches no {@link ADVISOR_SYNC_BACKLOG_MODES} entry. */
 const SYNC_BACKLOG_INHERIT = "inherit";
 
+/** The tools list's terminal-only "Done" row; the picker applies with its own action instead. */
+const TOOLS_DONE = "__done";
+
+/**
+ * A picker editor as a component of its own: a component's root picker stays
+ * where it is described, the prefs page's editor slot, where a picker
+ * described inside the page would be hoisted into `layer` under the sheet.
+ */
+class EditorSheet implements Component {
+	node: NativeNode | undefined;
+	readonly #route: (event: NativeUiEvent) => void;
+
+	constructor(route: (event: NativeUiEvent) => void) {
+		this.#route = route;
+	}
+
+	render(): readonly string[] {
+		return [];
+	}
+
+	describe(): NativeNode | null {
+		return this.node ?? null;
+	}
+
+	handleNativeEvent(event: NativeUiEvent): void {
+		this.#route(event);
+	}
+}
+
+/** Whether two memo dependency lists hold the same values by identity. */
+function sameDeps(a: readonly unknown[], b: readonly unknown[]): boolean {
+	return a.length === b.length && a.every((value, i) => value === b[i]);
+}
+
 /** One-line cadence label: mode plus interval. */
 function formatReviewCadence(advisor: AdvisorConfig): string {
 	const reviewInterval = advisor.reviewInterval ?? 1;
@@ -297,7 +349,15 @@ export class AdvisorConfigOverlayComponent implements Component {
 
 	/** The advisor the detail screen (and its editors) edits; -1 on the roster or the shared instructions. */
 	#detailIndex = -1;
-	#nativePrefs: { signature: string; editor: Component | undefined; node: NativeNode } | undefined;
+	#nativePrefs: { signature: string; editor: NativeNode | undefined; node: NativeNode } | undefined;
+	/** The editor over the prefs page, rebuilt only when one of `deps` changes identity. */
+	#nativeEditor: { deps: readonly unknown[]; node: NativeNode } | undefined;
+	/** The model screen's catalogue and the advisor's current model among it (picker `current`). */
+	#modelItems: ModelBrowserItem[] = [];
+	#modelCurrent: string | undefined;
+	/** Picker sheet options of the current list screen (thinking, review mode, sync backlog, tools). */
+	#sheetOptions: SelectPickerOptions | undefined;
+	readonly #editorSheet = new EditorSheet(event => this.#routeEditorPicker(event));
 	#screen: Screen = "list";
 	/** The interactive element for the current screen. */
 	#active: Component = new SelectList([], 1, getSelectListTheme());
@@ -587,7 +647,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 			this.#screen === "sync-backlog" ||
 			this.#screen === "tools" ||
 			this.#screen === "instructions";
-		const editor = overlay ? this.#active : undefined;
+		const editor = overlay ? this.#prefsEditor() : undefined;
 		const focus =
 			this.#screen === "detail" && this.#active instanceof SelectList
 				? (this.#active.getSelectedItem()?.value ?? null)
@@ -606,12 +666,137 @@ export class AdvisorConfigOverlayComponent implements Component {
 		const signature = JSON.stringify(props);
 		const prev = this.#nativePrefs;
 		if (prev && prev.signature === signature && prev.editor === editor) return prev.node;
-		const children: NativeChild[] = editor ? [col([editor], { role: "zeta.prefs.editor" })] : [];
+		let children: NativeChild[] = [];
+		if (editor?.k === "picker") {
+			this.#editorSheet.node = editor;
+			children = [this.#editorSheet];
+		} else if (editor) {
+			children = [editor];
+		}
 		const root = node("prefs", props, children);
 		this.#nativePrefs = { signature, editor, node: root };
 		return root;
 	}
 
+	/**
+	 * The editor over the prefs page. Choices are picker sheets on `/model`'s
+	 * anatomy (search, rows, the highlighted model's facts, one primary
+	 * action); the instructions and review-interval editors sit in the page's
+	 * editor card.
+	 */
+	#prefsEditor(): NativeNode {
+		const active = this.#active;
+		const memo = this.#nativeEditor;
+		if (active instanceof ModelBrowser) {
+			const order = active.pickerOrder({ providers: false, rest: active.query.trim() ? "Matches" : "All" });
+			const catalogue = active.pickerItems(this.#modelItems);
+			const preview = active.pickerPreview("compact", this.#modelCurrent);
+			const deps = [active, order, catalogue, preview, active.query, active.cursor, active.pickerSelected];
+			if (memo && sameDeps(memo.deps, deps)) return memo.node;
+			const sheet = this.#modelSheet(active, order, catalogue, preview);
+			this.#nativeEditor = { deps, node: sheet };
+			return sheet;
+		}
+		const options = this.#sheetOptions;
+		if (active instanceof SelectList && options) {
+			const view = active.pickerView();
+			const deps = [active, view.items, view.selected, view.pending, view.query, view.cursor];
+			if (memo && sameDeps(memo.deps, deps)) return memo.node;
+			const props = selectListPicker(active, options);
+			const sheet = node(
+				"picker",
+				this.#screen === "tools"
+					? {
+							...props,
+							items: props.items?.filter(item => item.id !== TOOLS_DONE),
+							actions: [
+								pickerAction("confirm", "Toggle", "enter"),
+								pickerAction("apply", "Apply", "escape", { primary: true, end: true }),
+							],
+						}
+					: props,
+			);
+			this.#nativeEditor = { deps, node: sheet };
+			return sheet;
+		}
+		if (memo && sameDeps(memo.deps, [active])) return memo.node;
+		const content = this.#screen === "review-interval" ? this.#intervalCard(active) : active;
+		const card = col([content], { role: "zeta.prefs.editor" });
+		this.#nativeEditor = { deps: [active], node: card };
+		return card;
+	}
+
+	#modelSheet(
+		browser: ModelBrowser,
+		order: ModelPickerOrder,
+		catalogue: ModelPickerCatalogue,
+		preview: readonly NativeChild[],
+	): NativeNode {
+		const name = this.#doc.advisors[this.#detailIndex]?.name || "This advisor";
+		const fallback = this.#defaultModelLabel ?? "the advisor role default";
+		return node(
+			"picker",
+			{
+				title: "Advisor model",
+				subtitle: `${name} reviews with this model. Unset, it uses ${fallback}.`,
+				icon: "model",
+				noun: "models",
+				size: "md",
+				layout: "rows",
+				preview: "below",
+				query: browser.query,
+				cursor: browser.cursor,
+				placeholder: "Search models…",
+				columns: MODEL_PICKER_COLUMNS,
+				...catalogue,
+				order: order.order,
+				...(order.hits ? { hits: order.hits } : {}),
+				selected: browser.pickerSelected,
+				...(this.#modelCurrent ? { current: [this.#modelCurrent] } : {}),
+				total: browser.baseCount,
+				empty: "No models available",
+				actions: [
+					pickerAction("use", "Use for advisor", "enter", { primary: true }),
+					browser.query.length > 0 ? { ...CLOSE_ACTION, label: "Clear search" } : CLOSE_ACTION,
+				],
+			},
+			preview,
+		);
+	}
+
+	/** The review-interval field as a titled card: what the number means, the field, Cancel and Save. */
+	#intervalCard(input: Component): NativeNode {
+		const name = this.#doc.advisors[this.#detailIndex]?.name || "this advisor";
+		return overlayCard("zeta.overlay.advisor.interval", `Review interval · ${name}`, [
+			text([span("Review every Nth eligible update; skipped updates join the next review.", "muted")], {
+				wrap: "word",
+			}),
+			input,
+			actionBar([
+				null,
+				actionButton("Cancel", "field-cancel", { keys: "escape" }),
+				actionButton("Save", "field-save", { keys: "enter", tone: "accent" }),
+			]),
+		]);
+	}
+
+	/** A pointer event on the editor's picker sheet, on the path of the key it stands for. */
+	#routeEditorPicker(event: NativeUiEvent): void {
+		const picked = pickerEvent(event);
+		if (!picked) return;
+		const active = this.#active;
+		if (active instanceof ModelBrowser) {
+			if (picked.kind !== "action") active.routePickerItem(picked.item, picked.kind === "activate");
+			else if (picked.act === "close") active.handleCancel();
+			else if (picked.act === "use" && active.pickerSelected) active.routePickerItem(active.pickerSelected, true);
+		} else if (active instanceof SelectList) {
+			// The tools list applies on cancel, like its Esc.
+			if (picked.kind === "action" && picked.act === "apply") active.onCancel?.();
+			else routeSelectListPicker(active, event);
+		}
+		this.#cb.requestRender();
+	}
+
 	/**
 	 * Native page events, each through the roster/detail selections the keys
 	 * make: a page opens that advisor (or the shared instructions), a field
@@ -619,6 +804,14 @@ export class AdvisorConfigOverlayComponent implements Component {
 	 * or the page cancels like Esc.
 	 */
 	handleNativeEvent(event: NativeUiEvent): void {
+		// The review-interval card's buttons, on its Enter and Esc paths.
+		if (event.type === "action" && (event.act === "field-save" || event.act === "field-cancel")) {
+			const input = this.#active;
+			if (!(input instanceof Input)) return;
+			if (event.act === "field-save") input.onSubmit?.(input.getValue());
+			else input.onEscape?.();
+			return;
+		}
 		if (event.key !== "") return;
 		const index = this.#pageIndex();
 		switch (event.type) {
@@ -979,9 +1172,11 @@ export class AdvisorConfigOverlayComponent implements Component {
 
 	// ───────────────────────────── screens ───────────────────────────
 
-	#setScreen(screen: Screen, active: Component, footerHint: string): void {
+	/** `sheet`: how a list screen describes as a picker over the prefs page. */
+	#setScreen(screen: Screen, active: Component, footerHint: string, sheet?: SelectPickerOptions): void {
 		this.#screen = screen;
 		this.#active = active;
+		this.#sheetOptions = sheet;
 		this.#footerHint = footerHint;
 		this.#previewScroll = 0;
 		this.#cb.requestRender();
@@ -1155,6 +1350,8 @@ export class AdvisorConfigOverlayComponent implements Component {
 	}
 
 	#onDetailSelect(index: number, field: string): void {
+		// Editors opened straight from the prefs page edit this advisor too.
+		this.#detailIndex = index;
 		switch (field) {
 			case "toggleEnabled": {
 				const a = this.#doc.advisors[index];
@@ -1232,11 +1429,19 @@ export class AdvisorConfigOverlayComponent implements Component {
 		}
 		const items = buildBrowserItems(models);
 		sortModelItems(items, { mruOrder });
+		// The configured model, whatever thinking suffix it carries, is the picker's current row.
+		const model = this.#doc.advisors[index]?.model?.trim();
+		const current = model
+			? items.find(item => model === item.selector || model.startsWith(`${item.selector}:`))?.selector
+			: undefined;
+		this.#modelItems = items;
+		this.#modelCurrent = current;
 
 		const picker = new ModelBrowser(this.#deps.browserSource, {});
 		picker.setMruOrder(mruOrder);
 		picker.setPerfStats(this.#deps.browserSource.modelPerf);
 		picker.setItems(items);
+		if (current) picker.selectSelector(current);
 		picker.onActivate = item => {
 			const efforts = getSupportedEfforts(item.model);
 			if (efforts.length === 0) {
@@ -1259,6 +1464,11 @@ export class AdvisorConfigOverlayComponent implements Component {
 		const items: SelectItem[] = [{ value: "", label: "(model default thinking)" }];
 		for (const effort of efforts) items.push({ value: effort, label: effort });
 		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		// The level the advisor already runs this model at, when it is this model.
+		const model = this.#doc.advisors[index]?.model?.trim();
+		const current =
+			model === selector ? "" : model?.startsWith(`${selector}:`) ? model.slice(selector.length + 1) : undefined;
+		if (current !== undefined) list.setSelectedValue(current);
 		list.onSelect = item => {
 			// Values are supported efforts or the empty model-default choice.
 			this.#doc.advisors[index].model = item.value ? `${selector}:${item.value}` : selector;
@@ -1270,6 +1480,23 @@ export class AdvisorConfigOverlayComponent implements Component {
 			"thinking",
 			list,
 			`Thinking effort for ${selector} · ${editorKey("tui.select.confirm")} / click pick · ${editorKey("tui.select.cancel")} back`,
+			{
+				title: "Thinking level",
+				subtitle: `How hard ${this.#doc.advisors[index]?.name || "the advisor"} reasons on ${selector}.`,
+				icon: "thinking",
+				noun: "levels",
+				current: current === undefined ? [] : [current],
+				confirm: "Use level",
+				decorate: item => {
+					if (!item.value) return { label: "Model default", detail: "No level; the provider decides." };
+					const level = parseThinkingLevel(item.value);
+					const dot = `thinking${item.value.charAt(0).toUpperCase()}${item.value.slice(1)}`;
+					return {
+						detail: level ? getThinkingLevelMetadata(level).description : undefined,
+						chips: [{ text: "", dot }],
+					};
+				},
+			},
 		);
 	}
 	#showReviewModePicker(index: number): void {
@@ -1299,6 +1526,14 @@ export class AdvisorConfigOverlayComponent implements Component {
 			"review-mode",
 			list,
 			`${editorKey("tui.select.confirm")} / click choose review mode · ${editorKey("tui.select.cancel")} back`,
+			{
+				title: "Review mode",
+				subtitle: `When ${advisor.name || "the advisor"} reviews the session.`,
+				icon: "review",
+				noun: "modes",
+				current: [current],
+				decorate: item => ({ label: item.value }),
+			},
 		);
 	}
 
@@ -1361,6 +1596,14 @@ export class AdvisorConfigOverlayComponent implements Component {
 			"sync-backlog",
 			list,
 			`${editorKey("tui.select.confirm")} / click choose catch-up policy · ${editorKey("tui.select.cancel")} back`,
+			{
+				title: "Sync backlog",
+				subtitle: `How long the session waits for ${advisor.name || "the advisor"}'s pending reviews.`,
+				icon: "time",
+				noun: "policies",
+				current: [current ?? SYNC_BACKLOG_INHERIT],
+				decorate: item => ({ label: item.value }),
+			},
 		);
 	}
 
@@ -1370,7 +1613,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 			value: name,
 			label: `${selected.has(name) ? "[x]" : "[ ]"} ${name}`,
 		}));
-		items.push({ value: "__done", label: "Done" });
+		items.push({ value: TOOLS_DONE, label: "Done" });
 		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
 		list.setSelectedIndex(cursor);
 		let cursorIndex = cursor;
@@ -1378,7 +1621,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 			cursorIndex = items.findIndex(i => i.value === item.value);
 		};
 		list.onSelect = item => {
-			if (item.value === "__done") {
+			if (item.value === TOOLS_DONE) {
 				this.#doc.advisors[index].tools = commitTools(selected, all, this.#deps.defaultToolNames);
 				this.#dirty = true;
 				this.#showDetail(index);
@@ -1397,6 +1640,14 @@ export class AdvisorConfigOverlayComponent implements Component {
 			"tools",
 			list,
 			`${editorKey("tui.select.confirm")} / click toggle · select Done or ${editorKey("tui.select.cancel")} to apply (empty = no tools; read/grep/glob = default)`,
+			{
+				title: "Tools",
+				subtitle: `What ${this.#doc.advisors[index]?.name || "the advisor"} may call. None grants no tools; read, grep and glob are the default.`,
+				icon: "tools",
+				noun: "tools",
+				current: [...selected],
+				decorate: item => ({ label: item.value }),
+			},
 		);
 	}
 

package/src/overlays/agent-hub-projection.d.ts

@@ -1,6 +1,9 @@
 import type { AgentMetricsSummary, AgentRecordLike, AgentStatus } from "./agent-hub-types";
 import type { ObservableSession } from "./session-observer-registry";
 export type AgentMetrics = AgentMetricsSummary;
+export interface AgentCostSnapshot {
+    cost: number | undefined;
+}
 export interface AggregateMetrics extends AgentMetrics {
     reportedAgents: number;
     /** Rows whose duration is an observer-measured active runtime. */
@@ -17,14 +20,16 @@ export declare const STATUS_ORDER: Record<AgentStatus, number>;
 export declare function progressMetrics(observed: ObservableSession | undefined): AgentMetrics | undefined;
 /** Live session used to cache a row's direct assistant usage, including with observer progress. */
 export declare function hubFallbackStatsSession<TRecord extends AgentRecordLike>(ref: TRecord, observed: ObservableSession | undefined): NonNullable<TRecord["session"]> | undefined;
-/**
- * Preserve progress/history for non-cost metrics, overlaying cumulative direct-session cost.
- * Persisted `history.metrics.cost` is a leaf-scoped snapshot, so it never overrides live
- * progress; only the cumulative direct-cost sources do.
- */
+/** Full Agent Hub row metrics; see {@link projectRowMetrics} for source precedence. */
 export declare function hubRowMetrics<TRecord extends AgentRecordLike>(ref: TRecord, observed: ObservableSession | undefined, sessionMetrics: WeakMap<object, {
     metrics: AgentMetrics | undefined;
 }>): AgentMetrics | undefined;
+/** Cost-only projection for frequent status updates; full roster metrics keep their own cache. */
+export declare function aggregateCost<TRecord extends AgentRecordLike>(args: {
+    rows: readonly TRecord[];
+    observedById: ReadonlyMap<string, ObservableSession>;
+    sessionCosts: WeakMap<object, AgentCostSnapshot>;
+}): number;
 export declare function aggregateMetrics<TRecord extends AgentRecordLike>(args: {
     rows: readonly TRecord[];
     observedById: ReadonlyMap<string, ObservableSession>;

package/src/overlays/agent-hub-projection.ts

@@ -4,6 +4,10 @@ import type { ObservableSession } from "./session-observer-registry";
 
 export type AgentMetrics = AgentMetricsSummary;
 
+export interface AgentCostSnapshot {
+	cost: number | undefined;
+}
+
 export interface AggregateMetrics extends AgentMetrics {
 	reportedAgents: number;
 	/** Rows whose duration is an observer-measured active runtime. */
@@ -203,15 +207,28 @@ export function hubFallbackStatsSession<TRecord extends AgentRecordLike>(
 	return session && typeof session.getSessionStats === "function" ? session : undefined;
 }
 
-function withDirectCost(metrics: AgentMetrics | undefined, cost: number | undefined): AgentMetrics | undefined {
+/**
+ * Shared row policy for the Agent Hub and the status-line cost total.
+ * Non-cost metrics come from live progress, then persisted history, then the retained
+ * snapshot (parked rows only), then the live session. Cost always overlays the cumulative
+ * direct-session bill: live, then `history.directCost` (written at park), then retained.
+ * Persisted `history.metrics.cost` is a leaf-scoped snapshot, so it never wins.
+ */
+function projectRowMetrics<TMetrics extends AgentCostSnapshot>(
+	ref: AgentRecordLike,
+	observed: ObservableSession | undefined,
+	live: TMetrics | undefined,
+	retained: TMetrics | undefined,
+	hasLiveSession: boolean,
+): TMetrics | AgentMetrics | undefined {
+	const cost = live?.cost ?? ref.history?.directCost ?? retained?.cost;
+	const metrics = observed?.progress
+		? progressMetrics(observed)
+		: (ref.history?.metrics ?? (!hasLiveSession ? retained : undefined) ?? live);
 	return metrics && cost !== undefined ? { ...metrics, cost } : metrics;
 }
 
-/**
- * Preserve progress/history for non-cost metrics, overlaying cumulative direct-session cost.
- * Persisted `history.metrics.cost` is a leaf-scoped snapshot, so it never overrides live
- * progress; only the cumulative direct-cost sources do.
- */
+/** Full Agent Hub row metrics; see {@link projectRowMetrics} for source precedence. */
 export function hubRowMetrics<TRecord extends AgentRecordLike>(
 	ref: TRecord,
 	observed: ObservableSession | undefined,
@@ -220,12 +237,46 @@ export function hubRowMetrics<TRecord extends AgentRecordLike>(
 	const session = hubFallbackStatsSession(ref, observed);
 	const liveEntry = session ? sessionMetrics.get(session) : undefined;
 	const retainedEntry = sessionMetrics.get(ref);
-	const historyMetrics = ref.history?.metrics;
-	const cost = liveEntry?.metrics?.cost ?? ref.history?.directCost ?? retainedEntry?.metrics?.cost;
-	if (observed?.progress) return withDirectCost(progressMetrics(observed), cost);
-	if (historyMetrics) return withDirectCost(historyMetrics, cost);
-	if (!session && retainedEntry?.metrics) return withDirectCost(retainedEntry.metrics, cost);
-	return withDirectCost(liveEntry?.metrics, cost);
+	return projectRowMetrics(ref, observed, liveEntry?.metrics, retainedEntry?.metrics, session !== undefined);
+}
+
+/** Cost-only projection for frequent status updates; full roster metrics keep their own cache. */
+export function aggregateCost<TRecord extends AgentRecordLike>(args: {
+	rows: readonly TRecord[];
+	observedById: ReadonlyMap<string, ObservableSession>;
+	sessionCosts: WeakMap<object, AgentCostSnapshot>;
+}): number {
+	let total = 0;
+	const countedSessions = new Set<NonNullable<AgentRecordLike["session"]>>();
+	for (const ref of args.rows) {
+		const observed = args.observedById.get(ref.id);
+		const session = hubFallbackStatsSession(ref, observed);
+		let cached = session ? args.sessionCosts.get(session) : undefined;
+		if (session) {
+			const directCost = readSessionDirectCost(session);
+			if (directCost !== undefined) {
+				cached = { cost: directCost };
+				args.sessionCosts.set(session, cached);
+			} else if (!cached || !fallbackReadCurrent(cached, session)) {
+				const stamp = fallbackReadStamp(session);
+				cached = { cost: readSessionMetrics(session, undefined)?.cost };
+				if (stamp) fallbackReadStamps.set(cached, stamp);
+				args.sessionCosts.set(session, cached);
+			}
+			if (cached?.cost !== undefined) args.sessionCosts.set(ref, cached);
+		}
+		const cost = projectRowMetrics(
+			ref,
+			observed,
+			cached?.cost !== undefined ? cached : undefined,
+			args.sessionCosts.get(ref),
+			session !== undefined,
+		)?.cost;
+		if (cost === undefined || (session && countedSessions.has(session))) continue;
+		if (session) countedSessions.add(session);
+		total += finiteMetric(cost);
+	}
+	return total;
 }
 
 export function aggregateMetrics<TRecord extends AgentRecordLike>(args: {

package/src/overlays/agent-hub.ts

@@ -1211,7 +1211,7 @@ export class AgentHubOverlayComponent<TRecord extends AgentRecordLike = AgentRec
 						[span("Finished, parked, and killed subagents remain with the session that created them.", "dim")],
 						{ wrap: "word" },
 					),
-					text([span("Resume that session with omp-dev --continue, or spawn a task here.", "dim")], {
+					text([span("Resume that session with zetacode --continue, or spawn a task here.", "dim")], {
 						wrap: "word",
 					}),
 				],
@@ -1857,7 +1857,7 @@ export class AgentHubOverlayComponent<TRecord extends AgentRecordLike = AgentRec
 				const emptyState = [
 					`${theme.fg("muted", theme.status.shadowed)} ${theme.bold("No agents in this session")}`,
 					theme.fg("dim", "Finished, parked, and killed subagents remain with the session that created them."),
-					theme.fg("dim", "Resume that session with omp-dev --continue, or spawn a task here."),
+					theme.fg("dim", "Resume that session with zetacode --continue, or spawn a task here."),
 				];
 				for (const line of emptyState.slice(0, budget)) {
 					lines.push(line);