@nijaru/pi-peak-hours 0.0.6 → 0.0.8

package/README.md

@@ -1,14 +1,16 @@
 # pi-peak-hours
 
-Correct pi's recorded cost for providers that bill by time of day, and show the rate in force in the footer.
+Estimate time-of-day pricing from pi's recorded cost, and show the current estimated rate in the footer.
 
 DeepSeek is the current example. Its peak windows are `01:00–04:00` and `06:00–10:00` UTC, Monday to Friday, and off-peak is half the peak rate. pi has no notion of time-of-day pricing: `usage.cost` is computed once from the model's flat rates when usage is finalized, so a session is over- or understated by up to 2x depending on which side of the schedule the recorded rate sits.
 
 The default covers DeepSeek direct only: pi records it at the published **peak** rate, so correction is ×1 inside the windows and ×0.5 outside. Reseller routes bill flat — OpenRouter prices each model per key and publishes no time-of-day overrides — so a default multiplier would corrupt their cost instead of correcting it. Give a route an explicit schedule only when its provider really bills by time of day. Custom `models.json` rates also need matching multipliers.
 
-This extension rewrites `usage.cost` on the finalized assistant message, so the footer total, the per-model breakdown, and the HTML export all reflect the billed rate. The status line quotes the rate in force for the selected model — `· ▲ peak $0.30/$1.20/M` during a peak window, `· $0.15/$0.60/M` off it — with `▲ peak` or `▼ off-peak` added when the hour costs more or less than the rate pi recorded. With stock peak-base prices, the peak indicator is absent and off-peak is marked as a discount. `/peak-hours status` names the schedule behind it.
+With a compatible [pi-provider-compaction](https://github.com/nijaru/pi-provider-compaction) companion loaded, this extension scales existing `usage.cost` before request completion reaches stream consumers or cache observers. It covers observed foreground requests, compaction, branch summaries, and cache warming for scheduled providers. Without the companion, it still corrects finalized foreground assistant messages through `message_end`; auxiliary usage stays unchanged. Both paths preserve token counts and existing cost corrections such as `/fast`.
 
-The quoted rate is pi's recorded rate scaled by the schedule, so it always agrees with the cost written to the session. It describes the hour in force rather than a particular request, though: a request that started before a boundary is billed by its start time while the footer has already moved to the new hour. Where pi's rate table is stale or wrong for your route, the quoted rate is stale in the same way — the extension corrects the shape of the bill, not the base rate.
+The status line quotes the selected model's scheduled catalog estimate — `· $0.30/$1.20/M` during a peak window, `· ▼ off-peak $0.15/$0.60/M` off it. `▲ peak` or `▼ off-peak` marks a rate above or below pi's recorded rate. With stock peak-base prices, peak has no indicator and off-peak is marked as a discount. `/peak-hours status` names the schedule.
+
+The footer describes the current hour, not a particular request: a request invoked before a boundary uses its invocation timestamp even after the footer moves to the new hour. Request-specific corrections can also differ from the quoted catalog rate. Stale base prices remain stale; this extension applies a multiplier, not a price lookup. All costs are estimates, not invoices: server arrival times and Chinese public holidays are not modeled.
 
 ## Install
 
@@ -16,7 +18,9 @@ The quoted rate is pi's recorded rate scaled by the schedule, so it always agree
 pi install npm:@nijaru/pi-peak-hours
 ```
 
-Or copy `extensions/index.ts` to `~/.pi/agent/extensions/` for a single-machine install.
+For a manual install, copy both files from `extensions/` into `~/.pi/agent/extensions/peak-hours/`, keeping `index.ts` and `request-pricing.ts` together.
+
+Request-wide pricing requires a companion version that supports the `pi-provider-compaction:observe-usage` event. Older or absent companions leave foreground correction usable; no second provider wrapper is installed.
 
 ## Usage
 
@@ -25,6 +29,8 @@ Or copy `extensions/index.ts` to `~/.pi/agent/extensions/` for a single-machine
 /peak-hours on|off    # toggle correction; persists to pi-peak-hours.json
 ```
 
+`/peak-hours status` also reloads the configuration. With the companion, configuration and on/off changes apply to new requests; requests already dispatched keep their sampled decision.
+
 The footer status is a separate line under the stats bar. It shows the model's current rate while a schedule covers it, and clears when correction is off, no schedule applies, or pi records no cost for the model. It re-evaluates on model switch, on every turn, and when a message is finalized — and it arms a timer for the next instant the rate it quotes actually changes, so a session sitting idle across 04:00 UTC flips to the new rate on time instead of at its next turn.
 
 ## Configuration
@@ -96,20 +102,21 @@ Note that a coding plan is billed in credits against a subscription, so pi's cos
 
 OpenRouter publishes the same windows machine-readably for models it hosts (`pricing.overrides` with `utc_days` / `utc_start` / `utc_end` on `https://openrouter.ai/api/v1/models`), but this extension reads its schedule from config rather than the network: the correction is a rate difference, not a price lookup, and a fetch would add a failure mode to a handler that must never throw.
 
-A malformed field falls back to its default rather than disabling the extension; a malformed file warns and resolves to defaults.
+A malformed field falls back to its default rather than disabling the extension; a malformed file warns and resolves to defaults. `/peak-hours on|off` refuses to rewrite a malformed, unreadable, or non-object config and reports that the save failed, leaving the existing file untouched.
 
 ## Design notes
 
-- **Only the selected model drives the indicator.** Schedules are provider- and model-scoped, so the footer never shows a rate for a service that does not bill by time of day. A rate above the recorded one reads `peak`, below it `off-peak`, and a discount is never labelled a peak. The quoted rate and the written cost come from the same multiplication, so they cannot disagree.
+- **Only the selected model drives the indicator.** Schedules are provider- and model-scoped, so the footer shows no rate for uncovered models. A rate above the recorded one reads `peak`, below it `off-peak`.
 - **The footer follows the window it quotes.** pi has no render tick and fires no event while a session is idle, and a rate that changes at 04:00 would otherwise stay on screen until the next turn. The extension arms a single timer for the next instant the quoted rate changes and re-arms it after each fire, from the same clock reading as the status it is keeping fresh. It arms nothing when there is no status on screen, and the timer is unreferenced and cleared on session shutdown, so it neither holds pi open nor outlives its session.
-- **Rate by provider invocation.** Pi providers timestamp each assistant message before preparing and sending its HTTP request. That timestamp selects the multiplier, not response completion or the shared payload hook (which also fires for background cache warming). Server arrival can differ across a boundary, so this remains an estimate.
-- **Scaled once.** Retries and overflow recovery can re-deliver the same message object, so adjustments are guarded by identity; the replacement returned to pi is registered too, so a replayed replacement cannot be scaled twice.
+- **Rate by provider invocation.** Pi providers timestamp each assistant message before preparing and sending its HTTP request. That timestamp selects the multiplier, not completion time or the shared payload hook. With the companion, active state and schedules are captured at request dispatch; without it, foreground fallback uses the configuration at `message_end`.
+- **Scaled once.** Global weak identity guards protect usage and foreground message objects across loaded copies, retries, and returned replacements. Usage observed at dispatch remains handled even when its decision is unchanged (×1 or inactive), so fallback cannot overwrite it after a config change.
+- **Shared ownership.** The client requests usage-only leases for covered available models and the current model, deduplicated by provider. The companion scopes callbacks to the owning session. Retired leases are reacquired on reconciliation; shutdown and SDK disposal remove only this client's leases. Neither catalogs nor unrelated provider slots are replaced.
 - **Only cost moves.** The four cost fields are scaled and `total` is recomputed from them, matching pi's own invariant. Token counts are untouched, so rate-from-cost derivations stay self-consistent — including pi's cache-miss accounting, which derives its paid and read rates from the same message and scales with it.
-- **Coverage.** The default weekday schedule does not encode Chinese public holidays, which DeepSeek treats as off-peak. Holiday costs can therefore be overstated; totals are not an invoice. Assistant messages carry the bulk of a session's spend. Compaction and branch-summary usage, prompt-cache-warming refreshes, and token usage reported by tools also consume budget but cannot be adjusted after the fact, so totals stay an estimate rather than an invoice.
+- **Coverage.** Only requests observed by the companion's safe dispatcher receive request-wide correction. Unavailable models, unsupported provider registrations, and usage reported independently by tools can remain uncorrected. Without the companion, coverage is foreground assistant messages only. The default weekday schedule does not encode Chinese public holidays, which DeepSeek treats as off-peak; holiday costs can therefore be overstated.
 
 ## Stack
 
-TypeScript, Bun. Pi extension API (`@earendil-works/pi-coding-agent`). `@earendil-works/pi-ai` is a dev dependency only — the handlers use pi's own `Model` and usage shapes structurally, so nothing from it ships. No build step — pi loads the extension directly.
+TypeScript, Bun. `@earendil-works/pi-coding-agent` and `@earendil-works/pi-ai` are host-provided peers; the latter supplies session-resource cleanup for SDK disposal. No build step — pi loads `extensions/index.ts` directly.
 
 ## Testing
 

package/extensions/index.ts

@@ -1,5 +1,5 @@
 /**
- * pi-peak-hours — correct recorded cost for providers that bill by time of day.
+ * pi-peak-hours — estimate time-of-day cost from pi's existing recorded cost.
  *
  * DeepSeek is the clearest example: a 2x multiplier applies during peak windows
  * (01:00-04:00 and 06:00-10:00 UTC, Monday-Friday, as of September 2026) and the
@@ -8,18 +8,17 @@
  * finalized — so a session is over- or understated by up to 2x, in whichever
  * direction the recorded rate sits from the billed one.
  *
- * This extension rewrites `usage.cost` on the finalized assistant message in
- * `message_end`, the documented hook for replacing a message. The footer
- * recomputes session totals from persisted entries on every render, so the
- * corrected number appears in the footer, the per-model breakdown, and the
- * HTML export without further plumbing.
+ * With pi-provider-compaction, usage-only leases correct request usage before
+ * stream consumers and cache observers see it. Without the companion, the
+ * documented `message_end` replacement hook still corrects foreground messages.
+ * Neither path changes catalogs, tokens, or other cost corrections.
  *
  * The footer indicator is scoped to the selected model and quotes the rate that
  * applies to it right now, in dollars per million tokens: with the default
- * schedule, `· $0.30/$1.20/M` at peak and `· ▼ off-peak $0.15/$0.60/M` off it.
- * The rate is the one pi recorded scaled by the schedule, so it always agrees
- * with the cost this extension writes. A session on a provider or model no
- * schedule covers never shows a rate, and switching models re-evaluates it.
+ * schedule, `· $0.30/$1.20/M` at peak and
+ * `· ▼ off-peak $0.15/$0.60/M` off it. This is a scheduled catalog estimate;
+ * request-specific corrections such as /fast can change the actual usage cost.
+ * Uncovered models show no rate; switching models re-evaluates it.
  *
  * The indicator is a snapshot of the current hour, and pi fires no event while a
  * session sits idle — so a timer armed at the next window boundary keeps it from
@@ -36,8 +35,8 @@
  *
  * - The rate is chosen from the request's START time, not its end. DeepSeek
  *   bills by when a request arrives, so a request spanning a window boundary
- *   would otherwise be billed on the wrong side of it. `message_start` gives
- *   the start; `message_end` gives the end.
+ *   would otherwise be billed on the wrong side of it. The provider's message
+ *   timestamp records invocation; completion wall-clock time is not used.
  * - A schedule declares the multiplier INSIDE its windows and `outside` for
  *   every other hour. Which side pi's recorded rate sits on is not assumed:
  *   encode it in the config, and only the difference is applied. Only DeepSeek
@@ -52,18 +51,19 @@
  *   modified, so any rate derived from cost/tokens stays self-consistent
  *   (cache-miss accounting derives paid and read rates from the same message
  *   and scales with it).
- * - Unknown or malformed configuration leaves the extension inert after a
- *   single warning; it never throws inside a message handler.
+ * - Unknown or malformed configuration falls back to the defaults with a
+ *   warning; no path throws from a message handler.
  *
- * Coverage limit: assistant messages carry the bulk of a session's spend.
- * Compaction and branch-summary usage and token usage reported by tools also
- * feed footer totals, but pi exposes no hook that can adjust them afterwards,
- * so those stay at list rates and the footer stays an estimate, not an invoice.
+ * All costs remain estimates, not invoices: server arrival, Chinese public
+ * holidays, and usage outside observed provider requests are not modeled.
  */
 
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { applyMultiplier, handledUsage, requestPricing } from "./request-pricing.ts";
+
+export { applyMultiplier } from "./request-pricing.ts";
 
 export const STATUS_KEY = "peak-hours";
 /**
@@ -271,11 +271,6 @@ export function multiplierAt(startedAt: Date, schedule: Schedule): number {
 	return schedule.outside;
 }
 
-/** Whether the rate in force costs more than the one pi recorded. */
-export function isPeakAt(startedAt: Date, schedule: Schedule): boolean {
-	return multiplierAt(startedAt, schedule) > 1;
-}
-
 const MS_PER_MINUTE = 60_000;
 
 /**
@@ -428,29 +423,12 @@ export function statusIndicator(
 	}
 }
 
-export interface CostBreakdown extends RateCard {
-	total: number;
-}
-
-/** Scale every rate field and recompute `total` from them, as pi itself does. */
-export function applyMultiplier(cost: CostBreakdown, multiplier: number): CostBreakdown {
-	const scaled: CostBreakdown = {
-		input: cost.input * multiplier,
-		output: cost.output * multiplier,
-		cacheRead: cost.cacheRead * multiplier,
-		cacheWrite: cost.cacheWrite * multiplier,
-		total: 0,
-	};
-	scaled.total = scaled.input + scaled.output + scaled.cacheRead + scaled.cacheWrite;
-	return scaled;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 /** Missing or malformed config uses defaults; parsing failures are reported. */
-export function readConfig(path: string): ConfigFile | undefined {
+export function readConfig(path: string): ConfigFile {
 	if (!existsSync(path)) return {};
 	try {
 		const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
@@ -466,16 +444,16 @@ export function readConfig(path: string): ConfigFile | undefined {
 	}
 }
 
-/** Persist `active` while preserving keys this version does not model. */
-export function writeActive(path: string, active: boolean): void {
+/** Refuse to replace unreadable/malformed config; preserve unknown valid keys. */
+export function writeActive(path: string, active: boolean): boolean {
 	try {
-		const existing = readConfig(path) ?? {};
-		const merged = isRecord(existing) ? { ...existing, active } : { active };
+		const config: unknown = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+		if (!isRecord(config)) return false;
 		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(path, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		console.warn(`[${STATUS_KEY}] Failed to write ${path}: ${message}`);
+		writeFileSync(path, `${JSON.stringify({ ...config, active }, null, 2)}\n`, "utf8");
+		return true;
+	} catch {
+		return false;
 	}
 }
 
@@ -527,14 +505,23 @@ function adjustedMessages(): WeakSet<object> {
 
 export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions = {}): void {
 	const configPath = options.configPath ?? CONFIG_PATH;
-	let config = readConfig(configPath) ?? {};
+	let config = readConfig(configPath);
 	let schedules = resolveSchedules(config);
 	let active = parseActive(config.active);
 	const adjusted = adjustedMessages();
 	let timer: ReturnType<typeof setTimeout> | undefined;
+	const pricing = requestPricing(pi, {
+		covers: (model) => scheduleFor(schedules, model.provider, model.id) !== undefined,
+		snapshot(model) {
+			// Refresh replaces schedules rather than mutating them. Capturing this
+			// resolved schedule and toggle freezes the decision for this request.
+			const schedule = active ? scheduleFor(schedules, model.provider, model.id) : undefined;
+			return (timestamp) => schedule ? multiplierAt(new Date(timestamp), schedule) : 1;
+		},
+	}, disarm);
 
 	function refresh(): void {
-		config = readConfig(configPath) ?? {};
+		config = readConfig(configPath);
 		schedules = resolveSchedules(config);
 		active = parseActive(config.active);
 	}
@@ -562,7 +549,7 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 
 		const next = nextTransitionAt(now, schedule);
 		if (!next) return;
-		// Floored, so a boundary crossed between reading the clock and arming the
+		// Clamped, so a boundary crossed between reading the clock and arming the
 		// timer cannot spin it; unreferenced, so a pending window never keeps pi
 		// alive after its work is done.
 		timer = setTimeout(() => {
@@ -595,30 +582,34 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 			ctx.ui.notify(`Peak hours: not applied to ${model.provider}/${model.id}. ${describeAll(schedules)}`, "info");
 			return;
 		}
-		const multiplier = multiplierAt(new Date(), schedule);
+		const now = new Date();
+		const multiplier = multiplierAt(now, schedule);
 		const rate = describeRate(model.cost, multiplier);
-		const state =
-			multiplier > 1
-				? `peak ×${multiplier} right now`
-				: multiplier < 1
-					? `off-peak ×${multiplier} right now`
-					: "no correction right now";
+		const rateState = rateStateAt(now, schedule);
+		const state = rateState === "none" ? "no correction right now" : `${rateState} ×${multiplier} right now`;
 		const detail = rate ? `${state} (${rate})` : state;
-		ctx.ui.notify(`Peak hours: ${detail}. ${describeSchedule(schedule)}`, "info");
+		ctx.ui.notify(`Peak hours estimate: ${detail}. ${describeSchedule(schedule)}. Costs are not an invoice.`, "info");
 	}
 
 	pi.on("session_start", async (_event, ctx) => {
 		refresh();
-		updateStatus(ctx);
+		await pricing.start(ctx);
+		if (pricing.isCurrent(ctx)) updateStatus(ctx);
+	});
+
+	pi.on("before_agent_start", async (_event, ctx) => {
+		await pricing.reconcile(ctx);
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
-		disarm();
+		pricing.stop();
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 
 	pi.on("model_select", async (event, ctx) => {
-		updateStatus(ctx, event.model);
+		refresh();
+		await pricing.reconcile(ctx, event.model);
+		if (pricing.isCurrent(ctx)) updateStatus(ctx, event.model);
 	});
 
 	// The window boundary can pass between messages, and the footer quotes a price
@@ -632,6 +623,10 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 		if (message.role !== "assistant") return;
 		if (adjusted.has(message)) return;
 		if (!message.usage?.cost) return;
+		if (handledUsage.has(message.usage)) {
+			updateStatus(ctx);
+			return;
+		}
 
 		// Pi providers stamp their output at invocation, before HTTP dispatch.
 		// This clock belongs to the foreground response even when the global
@@ -655,6 +650,7 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 		}
 
 		adjusted.add(message);
+		handledUsage.add(message.usage);
 		updateStatus(ctx);
 		const replacement = {
 			...message,
@@ -663,10 +659,11 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 				cost: applyMultiplier(message.usage.cost, multiplier),
 			},
 		};
-		// pi copies this onto the original, so the original's identity already
-		// carries the guard; registering the replacement covers a caller that
-		// replays the returned value instead.
+		// pi consumes the returned replacement, so the original identity carries
+		// the guard for a retry that re-delivers it; registering the replacement
+		// covers a caller that replays the returned value instead.
 		adjusted.add(replacement);
+		handledUsage.add(replacement.usage);
 		return { message: replacement };
 	});
 
@@ -681,6 +678,8 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 			const arg = args.trim().toLowerCase();
 			if (!arg || arg === "status") {
 				refresh();
+				await pricing.reconcile(ctx);
+				if (!pricing.isCurrent(ctx)) return;
 				updateStatus(ctx);
 				notifyStatus(ctx);
 				return;
@@ -689,8 +688,13 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 				ctx.ui.notify("Usage: /peak-hours [on|off|status]", "error");
 				return;
 			}
-			writeActive(configPath, arg === "on");
+			if (!writeActive(configPath, arg === "on")) {
+				ctx.ui.notify(`Peak hours: failed to save configuration at ${configPath}; keeping the previous setting.`, "error");
+				return;
+			}
 			refresh();
+			await pricing.reconcile(ctx);
+			if (!pricing.isCurrent(ctx)) return;
 			updateStatus(ctx);
 			notifyStatus(ctx);
 		},

package/extensions/request-pricing.ts

@@ -0,0 +1,147 @@
+import { registerSessionResourceCleanup, type Usage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const OBSERVE_USAGE = "pi-provider-compaction:observe-usage";
+export const USAGE_OBSERVER_READY = "pi-provider-compaction:usage-observer-ready";
+type TargetModel = NonNullable<ExtensionContext["model"]>;
+type ModelKey = Pick<TargetModel, "provider" | "id">;
+
+export interface UsageLease {
+	provider: string;
+	api: TargetModel["api"];
+	isInstalled(): boolean;
+	remove(): void;
+}
+
+export interface UsageRequest {
+	context: ExtensionContext;
+	model: TargetModel;
+	priceFor(model: ModelKey): (timestamp: number, usage: Usage) => void;
+	respond(lease: UsageLease | undefined): void;
+	handled?: boolean;
+}
+
+// Shared with foreground fallback and separately loaded copies of the extension.
+// Unchanged decisions (1x, disabled, uncovered) are handled too: a later config
+// refresh must not reprice a request whose decision was sampled at dispatch.
+const PRICED_USAGE = Symbol.for("pi-peak-hours.priced-usage");
+const shared = globalThis as typeof globalThis & { [PRICED_USAGE]?: WeakSet<object> };
+export const handledUsage = shared[PRICED_USAGE] ??= new WeakSet<object>();
+
+export function applyMultiplier(cost: Usage["cost"], multiplier: number): Usage["cost"] {
+	const scaled = {
+		...cost,
+		input: cost.input * multiplier,
+		output: cost.output * multiplier,
+		cacheRead: cost.cacheRead * multiplier,
+		cacheWrite: cost.cacheWrite * multiplier,
+	};
+	scaled.total = scaled.input + scaled.output + scaled.cacheRead + scaled.cacheWrite;
+	return scaled;
+}
+
+interface PricingRules {
+	covers(model: ModelKey): boolean;
+	/** Called at dispatch; return a timestamp selector with no mutable config. */
+	snapshot(model: ModelKey): (timestamp: number) => number;
+}
+
+function leaseKey(target: Pick<TargetModel, "provider" | "api">): string {
+	return JSON.stringify([target.provider, target.api]);
+}
+
+/** Usage-only client of the companion's safe shared provider dispatcher. */
+export function requestPricing(pi: ExtensionAPI, rules: PricingRules, onRetire: () => void) {
+	let owner: { context: ExtensionContext; sessionId: string; revision: number; available: readonly TargetModel[] } | undefined;
+	const leases = new Map<string, UsageLease>();
+	let unsubscribeReady: (() => void) | undefined;
+	let unregisterCleanup: (() => void) | undefined;
+
+	function owns(context: ExtensionContext): boolean {
+		return owner !== undefined && context.modelRegistry === owner.context.modelRegistry &&
+			context.sessionManager.getSessionId() === owner.sessionId;
+	}
+
+	function stop(): void {
+		owner = undefined;
+		unsubscribeReady?.();
+		unsubscribeReady = undefined;
+		unregisterCleanup?.();
+		unregisterCleanup = undefined;
+		for (const lease of leases.values()) lease.remove();
+		leases.clear();
+		onRetire();
+	}
+
+	function priceFor(model: ModelKey): (timestamp: number, usage: Usage) => void {
+		const selectMultiplier = rules.snapshot(model);
+		return (timestamp, usage) => {
+			if (handledUsage.has(usage)) return;
+			handledUsage.add(usage);
+			const multiplier = selectMultiplier(timestamp);
+			if (multiplier !== 1) usage.cost = applyMultiplier(usage.cost, multiplier);
+		};
+	}
+
+	async function reconcile(context: ExtensionContext, model = context.model): Promise<void> {
+		if (!owns(context) || !owner) return;
+		const current = owner;
+		current.context = context;
+		const revision = ++current.revision;
+		const live = () => owner === current && current.revision === revision;
+		for (const [key, lease] of leases) {
+			if (!lease.isInstalled()) { lease.remove(); leases.delete(key); }
+		}
+		const tryModel = (candidate: TargetModel) => {
+			if (!live() || !rules.covers(candidate) || leases.has(leaseKey(candidate))) return;
+			const request: UsageRequest = {
+				context: current.context,
+				model: candidate,
+				priceFor,
+				respond(lease) {
+					if (!lease) return;
+					const key = leaseKey(lease);
+					if (!live() || leases.has(key) || !lease.isInstalled()) { lease.remove(); return; }
+					leases.set(key, lease);
+				},
+			};
+			pi.events.emit(OBSERVE_USAGE, request);
+		};
+		// Do not await catalog/auth discovery before covering the selected model:
+		// the companion's ready notification is synchronous and can precede dispatch.
+		if (model) tryModel(model);
+		// A source-first start can answer immediately. A client-first start has
+		// already discovered available models by the time the source says ready;
+		// retry those synchronously too, before any auxiliary request can dispatch.
+		for (const candidate of current.available) tryModel(candidate);
+		try {
+			const available = await context.modelRegistry.getAvailable();
+			if (!live()) return;
+			current.available = available;
+			// A lease covers only its provider/API pair. Keep trying other APIs
+			// even after one succeeds, and other candidates when a lease fails.
+			for (const candidate of available) tryModel(candidate);
+		} catch { /* Optional discovery failure leaves foreground fallback usable. */ }
+		// Keep acquired leases until retirement, even after schedule removal, so
+		// requests already in flight can finish with their dispatch snapshots.
+	}
+
+	return {
+		async start(context: ExtensionContext): Promise<void> {
+			stop();
+			const sessionId = context.sessionManager.getSessionId();
+			owner = { context, sessionId, revision: 0, available: [] };
+			unsubscribeReady = pi.events.on(USAGE_OBSERVER_READY, (value) => {
+				const ready = value as { context?: ExtensionContext } | undefined;
+				if (ready?.context && owns(ready.context) && owner) void reconcile(owner.context);
+			});
+			unregisterCleanup = registerSessionResourceCleanup((disposedId) => {
+				if (disposedId === undefined || disposedId === sessionId) stop();
+			});
+			await reconcile(context);
+		},
+		reconcile,
+		isCurrent: owns,
+		stop,
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-peak-hours",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "description": "Correct pi's recorded cost for providers that bill by time of day, with a peak multiplier in the footer status.",
   "keywords": [
@@ -24,7 +24,7 @@
   },
   "pi": {
     "extensions": [
-      "./extensions"
+      "./extensions/index.ts"
     ]
   },
   "scripts": {
@@ -34,13 +34,14 @@
     "check": "bun test && oxlint extensions/ tests/ && tsc --noEmit"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "1.3.0",
-    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-ai": "1.4.0",
+    "@earendil-works/pi-coding-agent": "1.4.0",
     "@types/bun": "latest",
     "oxlint": "latest",
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*"
   },
   "files": [