@nijaru/pi-peak-hours 0.0.1 → 0.0.3

package/README.md

@@ -2,9 +2,13 @@
 
 Correct pi's recorded cost for providers that bill by time of day, and show the rate in force in the footer.
 
-DeepSeek is the current example. Its published prices are the **off-peak** rates, and a **2x** multiplier applies during peak windows — `01:00–04:00` and `06:00–10:00` UTC, Monday to Friday, with every other hour (including all weekend) off-peak. 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 running during a peak window understates its cost by up to 2x.
+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.
 
-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. While peak is in force the status shows `▲ peak`; off-peak it clears. The indicator stays generic because the multiplier differs per service — `/peak-hours status` names the schedule and the rate in force.
+Both built-in entries follow what DeepSeek advertises: ×2 inside those windows and ×1 outside, because the published rate is the off-peak one and peak is a surcharge on it. Since the extension scales whatever rate pi recorded, an entry is right only where that rate really is the off-peak one — true of the OpenRouter route, which pi rates at `0.15/0.60`, and of the direct provider wherever `models.json` pins it to off-peak. Stock pi.dev rates direct as `deepseek-flash` at `0.30/1.20`, its peak number, so the configuration below inverts that one entry; the pair exists because each entry is scoped, covering the DeepSeek models on both routes without claiming unrelated OpenRouter models. Naming your own providers replaces both.
+
+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. `/peak-hours status` names the schedule behind it.
+
+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.
 
 ## Install
 
@@ -21,14 +25,17 @@ 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
 ```
 
+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
 
-Optional. `~/.pi/agent/extensions/pi-peak-hours.json` overlays the built-in DeepSeek schedule; anything you leave out keeps its default.
+Optional. `~/.pi/agent/extensions/pi-peak-hours.json` overlays the DeepSeek schedule; anything you leave out keeps its default. The OpenRouter route for the same models is covered out of the box, and setting `providers` yourself replaces both built-in schedules with the one you describe.
 
 ```json
 {
   "active": true,
   "multiplier": 2,
+  "outside": 1,
   "windows": [["01:00", "04:00"], ["06:00", "10:00"]],
   "days": ["mon", "tue", "wed", "thu", "fri"],
   "providers": ["deepseek"],
@@ -36,20 +43,71 @@ Optional. `~/.pi/agent/extensions/pi-peak-hours.json` overlays the built-in Deep
 }
 ```
 
-Times are **UTC**. `days` accepts names or `0`–`6` (`0` is Sunday). `providers` and `models` accept `*` globs, so an OpenRouter route (`"providers": ["openrouter"], "models": ["deepseek/*"]`) picks up the same schedule.
+Times are **UTC**. `days` accepts names or `0`–`6` (`0` is Sunday). `providers` and `models` accept `*` globs, so a self-hosted gateway or a reseller (`"providers": ["tokenrouter"], "models": ["deepseek/*"]`) can pick up the same schedule.
+
+`multiplier` applies **inside** `windows` and `outside` applies everywhere else. Either may be below 1, because not every provider prices the same way round. A window may carry its own `multiplier`, which wins for that window:
+
+```json
+"windows": [{ "start": "22:00", "end": "08:00", "multiplier": 0.4 }]
+```
+
+**Pick the side that matches your own rate card.** The extension applies the difference from the rate pi recorded; it does not guess which side that is. The built-in pair encodes today's pi.dev catalog — DeepSeek direct at its **peak** rate, the same model through OpenRouter at its **off-peak** rate — and if your catalog changes, or you override rates in `models.json` as below, say so in the config instead of relying on the default. `/peak-hours status` reports what it would charge right now, and the numbers are in the provider's docs.
+
+```json
+// Your models.json pins DeepSeek direct to the off-peak rate: scale up at peak.
+{ "multiplier": 2, "outside": 1 }
+
+// Stock pi.dev lists DeepSeek direct at the peak rate: scale down off-peak.
+{ "providers": ["deepseek"], "multiplier": 1, "outside": 0.5 }
+```
+
+### Other providers
+
+A `schedules` list replaces the built-in schedules with one entry per service. Each entry starts from a clean slate rather than inheriting DeepSeek's windows.
+
+**Z.ai coding plan** — the standard credit rate during the weekday peak window, half of it everywhere else (docs.z.ai/devpack). This is inverted relative to DeepSeek: `06:00–10:00` UTC Monday–Friday is the *expensive* side, so the windows match and the multiplier lands below 1.
+
+```json
+{
+  "schedules": [
+    { "providers": ["zai"], "windows": [["06:00", "10:00"]], "days": ["mon", "tue", "wed", "thu", "fri"],
+      "multiplier": 1, "outside": 0.5 }
+  ]
+}
+```
+
+Note that a coding plan is billed in credits against a subscription, so pi's cost for it is a list-price estimate either way.
+
+**Alibaba Model Studio (Qwen)** — a limited-time night discount: night is `22:00–08:00` UTC+8 (`14:00–00:00` UTC) and the percentage is quoted per model, so the schedule is per model too. The example below is the published `night 60% off / daytime 20% off` shape.
+
+```json
+{
+  "schedules": [
+    { "providers": ["qwen"], "models": ["qwen3.8-max"],
+      "windows": [
+        { "start": "14:00", "end": "00:00", "multiplier": 0.4 },
+        { "start": "00:00", "end": "14:00", "multiplier": 0.8 }
+      ], "outside": 1 }
+  ]
+}
+```
+
+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 once 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.
 
 ## 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.
+- **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 request start.** DeepSeek bills by arrival time, so the multiplier is chosen from the `message_start` timestamp rather than `message_end`. A request spanning a window boundary would otherwise land on the wrong side.
-- **Scaled once.** Retries and overflow recovery can re-deliver the same message object, so adjustments are guarded by identity.
+- **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.
 - **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.** Assistant messages carry the bulk of a session's spend. Compaction and branch-summary usage, plus token usage reported by tools, also feed the footer but cannot be adjusted after the fact, so totals stay an estimate rather than an invoice.
 
 ## Stack
 
-TypeScript, Bun. Pi extension API (`@earendil-works/pi-coding-agent`, `@earendil-works/pi-ai`). No build step — pi loads the extension directly.
+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.
 
 ## Testing
 

package/extensions/index.ts

@@ -1,12 +1,12 @@
 /**
  * pi-peak-hours — correct recorded cost for providers that bill by time of day.
  *
- * DeepSeek is the clearest example: its published prices are the off-peak
- * rates, and a 2x multiplier applies during peak windows (01:00-04:00 and
- * 06:00-10:00 UTC, Monday-Friday, as of September 2026). 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 the footer understates such sessions by
- * up to 2x while a peak window is open.
+ * 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
+ * off-peak rate is half of it. 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, 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
@@ -14,12 +14,36 @@
  * corrected number appears in the footer, the per-model breakdown, and the
  * HTML export without further plumbing.
  *
+ * The footer indicator is scoped to the selected model and quotes the rate that
+ * applies to it right now, in dollars per million tokens: `· ▲ peak
+ * $0.30/$1.20/M` at 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.
+ *
+ * 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
+ * quoting a rate that has already expired. See `arm`.
+ *
+ * Schedules are provider-scoped and there can be several, because the shape of
+ * the correction differs: DeepSeek's list price is its off-peak rate, so peak is
+ * a surcharge (×2), while Z.ai's coding plan and Alibaba's night discount are
+ * priced the other way round and land below the recorded rate. A multiplier
+ * above 1 reads as `peak`, below 1 as `off-peak`, and the footer names the
+ * direction so a discount is never reported as a peak.
+ *
  * Design constraints:
  *
  * - 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.
+ * - 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. pi's own
+ *   catalog disagrees with itself here — it lists DeepSeek direct at peak rates
+ *   and the same model through OpenRouter at off-peak rates — so a schedule that
+ *   guesses would double-charge one of them.
  * - A message is never scaled twice. Retries and overflow recovery can deliver
  *   the same message object again, so adjustments are guarded by identity.
  * - Only the four cost fields are touched, and `total` is recomputed from
@@ -37,7 +61,6 @@
  */
 
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
@@ -48,6 +71,10 @@ export const STATUS_KEY = "peak-hours";
  * `/peak-hours status`, which names the schedule and the rate in force.
  */
 export const STATUS_PEAK = "▲ peak";
+/** Shown when the rate in force is below the recorded one, e.g. an off-peak discount. */
+export const STATUS_OFF_PEAK = "▼ off-peak";
+/** Rates are quoted per million tokens, like every provider rate card. */
+export const RATE_UNIT = "/M";
 export const COMMAND_PEAK_HOURS = "peak-hours";
 export const CONFIG_BASENAME = "pi-peak-hours.json";
 export const CONFIG_PATH = join(getAgentDir(), "extensions", CONFIG_BASENAME);
@@ -56,10 +83,17 @@ export const CONFIG_PATH = join(getAgentDir(), "extensions", CONFIG_BASENAME);
 export interface ClockWindow {
 	start: number;
 	end: number;
+	/** Overrides the schedule multiplier inside this window. */
+	multiplier?: number;
 }
 
+/**
+ * The rate in force inside `windows` versus `outside` them. Either side may be
+ * the cheaper one: above 1 is a surcharge, below 1 a discount.
+ */
 export interface Schedule {
 	multiplier: number;
+	outside: number;
 	windows: ClockWindow[];
 	/** 0 = Sunday, matching Date#getUTCDay. */
 	days: number[];
@@ -67,20 +101,28 @@ export interface Schedule {
 	models: string[];
 }
 
-export interface ConfigFile {
-	active?: boolean;
+/** Everything a single schedule accepts. */
+export interface ScheduleConfig {
 	multiplier?: number;
-	windows?: [string, string][];
+	outside?: number;
+	windows?: (readonly [string, string] | { start: string; end: string; multiplier?: number })[];
 	days?: (string | number)[];
 	providers?: string[];
 	models?: string[];
 }
 
+export interface ConfigFile extends ScheduleConfig {
+	active?: boolean;
+	/** Provider-scoped schedules, each resolved on its own rather than over the DeepSeek default. */
+	schedules?: ScheduleConfig[];
+}
+
 export const DAY_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] as const;
 
 /** DeepSeek's published schedule: peak mornings on UTC weekdays, everything else off-peak. */
 export const DEFAULT_SCHEDULE: Schedule = {
 	multiplier: 2,
+	outside: 1,
 	windows: [
 		{ start: 60, end: 240 },
 		{ start: 360, end: 600 },
@@ -90,8 +132,51 @@ export const DEFAULT_SCHEDULE: Schedule = {
 	models: ["*"],
 };
 
+/**
+ * The same model resold by OpenRouter, which pi's catalog rates at the off-peak
+ * price while its own `deepseek` provider is rated at peak. Without this the
+ * route silently keeps pi's flat rate.
+ */
+export const OPENROUTER_SCHEDULE: Schedule = {
+	multiplier: 2,
+	outside: 1,
+	windows: [
+		{ start: 60, end: 240 },
+		{ start: 360, end: 600 },
+	],
+	days: [1, 2, 3, 4, 5],
+	providers: ["openrouter"],
+	models: ["deepseek/*"],
+};
+
+/** What a config that says nothing about schedules resolves to. */
+export const DEFAULT_SCHEDULES: Schedule[] = [DEFAULT_SCHEDULE, OPENROUTER_SCHEDULE];
+
+/**
+ * Base for schedules listed explicitly in `schedules`: no windows, no
+ * correction, every provider and model. An entry supplies its own shape rather
+ * than inheriting DeepSeek's, which would be a surprising default for a
+ * different service.
+ */
+export const NEUTRAL_SCHEDULE: Schedule = {
+	multiplier: 1,
+	outside: 1,
+	windows: [],
+	days: [0, 1, 2, 3, 4, 5, 6],
+	providers: ["*"],
+	models: ["*"],
+};
+
 export const DEFAULT_ACTIVE = true;
 
+/**
+ * Only an explicit boolean is a toggle. A malformed `active` falls back like
+ * every other field, so a typo disables nothing silently.
+ */
+export function parseActive(value: unknown): boolean {
+	return typeof value === "boolean" ? value : DEFAULT_ACTIVE;
+}
+
 /** "HH:MM" in UTC to minutes from midnight, or undefined when unparseable. */
 export function parseClock(value: unknown): number | undefined {
 	if (typeof value !== "string") return undefined;
@@ -116,69 +201,154 @@ function parseWindows(value: unknown): ClockWindow[] | undefined {
 	if (!Array.isArray(value)) return undefined;
 	const windows: ClockWindow[] = [];
 	for (const entry of value) {
-		if (!Array.isArray(entry) || entry.length !== 2) return undefined;
-		const start = parseClock(entry[0]);
-		const end = parseClock(entry[1]);
-		if (start === undefined || end === undefined || start === end) return undefined;
-		windows.push({ start, end });
+		let start: unknown;
+		let end: unknown;
+		let multiplier: unknown;
+		if (Array.isArray(entry) && entry.length === 2) {
+			[start, end] = entry;
+		} else if (isRecord(entry)) {
+			start = entry.start;
+			end = entry.end;
+			multiplier = entry.multiplier;
+		} else {
+			return undefined;
+		}
+		const startMinutes = parseClock(start);
+		const endMinutes = parseClock(end);
+		if (startMinutes === undefined || endMinutes === undefined || startMinutes === endMinutes) return undefined;
+		const window: ClockWindow = { start: startMinutes, end: endMinutes };
+		if (multiplier !== undefined) {
+			const parsed = parseMultiplier(multiplier);
+			if (parsed === undefined) return undefined;
+			window.multiplier = parsed;
+		}
+		windows.push(window);
 	}
 	return windows;
 }
 
+/** A positive finite multiplier: above 1 for a surcharge, below 1 for a discount. */
+export function parseMultiplier(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return undefined;
+	return value;
+}
+
 function parseStringList(value: unknown): string[] | undefined {
 	if (!Array.isArray(value)) return undefined;
 	const items = value.filter((item): item is string => typeof item === "string" && item.trim() !== "");
 	return items.length === value.length ? items.map((item) => item.trim()) : undefined;
 }
 
-/** Overlay a parsed config file onto the defaults. Invalid fields fall back to the default. */
-export function resolveSchedule(config: ConfigFile): Schedule {
-	const schedule: Schedule = {
-		multiplier: DEFAULT_SCHEDULE.multiplier,
-		windows: DEFAULT_SCHEDULE.windows,
-		days: DEFAULT_SCHEDULE.days,
-		providers: DEFAULT_SCHEDULE.providers,
-		models: DEFAULT_SCHEDULE.models,
+/** Overlay a parsed config onto `base`. Invalid fields keep the base value. */
+export function resolveSchedule(config: ScheduleConfig, base: Schedule = DEFAULT_SCHEDULE): Schedule {
+	return {
+		multiplier: parseMultiplier(config.multiplier) ?? base.multiplier,
+		outside: parseMultiplier(config.outside) ?? base.outside,
+		// Copied, so a resolved schedule never aliases an exported default.
+		windows: parseWindows(config.windows) ?? base.windows.map((window) => ({ ...window })),
+		days: parseDays(config.days) ?? [...base.days],
+		providers: parseStringList(config.providers) ?? [...base.providers],
+		models: parseStringList(config.models) ?? [...base.models],
 	};
+}
 
-	if (typeof config.multiplier === "number" && Number.isFinite(config.multiplier) && config.multiplier >= 1) {
-		schedule.multiplier = config.multiplier;
-	}
-	const windows = parseWindows(config.windows);
-	if (windows) schedule.windows = windows;
-	if (Array.isArray(config.days)) {
-		const days = config.days.map(parseDay);
-		if (days.every((day): day is number => day !== undefined)) schedule.days = days;
-	}
-	const providers = parseStringList(config.providers);
-	if (providers) schedule.providers = providers;
-	const models = parseStringList(config.models);
-	if (models) schedule.models = models;
+/** Day names or numbers, or undefined when the list is absent or partly invalid. */
+function parseDays(value: unknown): number[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const days = value.map(parseDay);
+	return days.every((day): day is number => day !== undefined) ? days : undefined;
+}
 
-	return schedule;
+/**
+ * Every schedule the config describes. An explicit `schedules` list replaces the
+ * built-in schedules; a flat config overlays the DeepSeek one and drops the
+ * built-in OpenRouter route once it names its own providers.
+ */
+export function resolveSchedules(config: ConfigFile): Schedule[] {
+	if (Array.isArray(config.schedules)) {
+		const entries = config.schedules.filter(isRecord).map((entry) => resolveSchedule(entry, NEUTRAL_SCHEDULE));
+		if (entries.length > 0) return entries;
+	}
+	const schedule = resolveSchedule(config);
+	return config.providers === undefined ? [schedule, OPENROUTER_SCHEDULE] : [schedule];
 }
 
-/** Whether a request that started at `startedAt` falls inside a peak window. */
-export function isPeakAt(startedAt: Date, schedule: Schedule): boolean {
+/** Whether a window covers the given instant, including windows that wrap midnight. */
+function windowCovers(window: ClockWindow, startedAt: Date, days: number[]): boolean {
 	const minutes = startedAt.getUTCHours() * 60 + startedAt.getUTCMinutes();
 	const day = startedAt.getUTCDay();
 
+	if (window.end > window.start) return days.includes(day) && minutes >= window.start && minutes < window.end;
+	// A window that runs past midnight started on the previous UTC day.
+	const previous = (day + 6) % 7;
+	return (days.includes(day) && minutes >= window.start) || (days.includes(previous) && minutes < window.end);
+}
+
+/** The multiplier in force at `startedAt`: a window's own, the schedule's, or `outside`. */
+export function multiplierAt(startedAt: Date, schedule: Schedule): number {
 	for (const window of schedule.windows) {
-		if (window.end > window.start) {
-			if (schedule.days.includes(day) && minutes >= window.start && minutes < window.end) return true;
-			continue;
+		if (windowCovers(window, startedAt, schedule.days)) return window.multiplier ?? schedule.multiplier;
+	}
+	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;
+
+/**
+ * Every instant the multiplier could move: the edges of each window, over a week
+ * of days plus a day of slack so a window that wraps midnight always contributes
+ * its closing edge and every weekday appears at least once. Sorted, and only
+ * ahead of `now`.
+ */
+function candidateEdges(now: Date, schedule: Schedule): number[] {
+	const nowMs = now.getTime();
+	const edges: number[] = [];
+
+	for (let offset = 0; offset <= 8; offset++) {
+		const midnight = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + offset);
+		const day = new Date(midnight).getUTCDay();
+		const previousDay = (day + 6) % 7;
+
+		for (const window of schedule.windows) {
+			// A window opens on its own day and closes on that day, or on the next one
+			// when it runs past midnight.
+			const closesOn = window.end > window.start ? day : previousDay;
+			if (schedule.days.includes(day)) edges.push(midnight + window.start * MS_PER_MINUTE);
+			if (schedule.days.includes(closesOn)) edges.push(midnight + window.end * MS_PER_MINUTE);
 		}
-		// A window that runs past midnight started on the previous UTC day.
-		const previous = (day + 6) % 7;
-		if (schedule.days.includes(day) && minutes >= window.start) return true;
-		if (schedule.days.includes(previous) && minutes < window.end) return true;
 	}
 
-	return false;
+	return edges.filter((edge) => edge > nowMs).sort((left, right) => left - right);
 }
 
-export function multiplierAt(startedAt: Date, schedule: Schedule): number {
-	return isPeakAt(startedAt, schedule) ? schedule.multiplier : 1;
+/**
+ * The earliest instant after `now` at which the schedule's multiplier changes,
+ * or undefined when it never does.
+ *
+ * A window edge is not enough: windows can overlap, so the edge that opens one
+ * may land inside another and leave the rate where it was. Testing the
+ * multiplier on both sides of each edge keeps the footer's trigger and the
+ * footer's value on the same function, and leaves a schedule whose multiplier
+ * never moves — a `multiplier` equal to its `outside`, say — with no timer at
+ * all.
+ */
+export function nextTransitionAt(now: Date, schedule: Schedule): Date | undefined {
+	if (schedule.windows.length === 0) return undefined;
+
+	// Edges are ordered, so the multiplier is constant between consecutive ones:
+	// the first edge that moves it is the first change after `now`.
+	for (const edge of candidateEdges(now, schedule)) {
+		if (multiplierAt(new Date(edge), schedule) !== multiplierAt(new Date(edge - 1), schedule)) {
+			return new Date(edge);
+		}
+	}
+
+	return undefined;
 }
 
 /** Glob match supporting `*` only, which is all a provider/model filter needs. */
@@ -195,11 +365,91 @@ export function matchesSchedule(schedule: Schedule, provider: string, model: str
 	);
 }
 
-export interface CostBreakdown {
+/** The provider/model pair a request belongs to, as pi reports it. */
+export interface ModelKey {
+	provider: string;
+	id: string;
+}
+
+/** Per-million-token rates, in the shape pi records them. */
+export interface RateCard {
 	input: number;
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+}
+
+/** A selected model with the rates pi would charge it at, which the schedule scales. */
+export interface ModelRate extends ModelKey {
+	cost: RateCard;
+}
+
+/** The first schedule covering a provider/model pair. */
+export function scheduleFor(schedules: Schedule[], provider: string, model: string): Schedule | undefined {
+	return schedules.find((schedule) => matchesSchedule(schedule, provider, model));
+}
+
+/** Whether the rate in force costs more (`peak`), less (`off-peak`), or the same (`none`). */
+export type RateState = "peak" | "off-peak" | "none";
+
+export function rateStateAt(when: Date, schedule: Schedule): RateState {
+	const multiplier = multiplierAt(when, schedule);
+	if (multiplier > 1) return "peak";
+	if (multiplier < 1) return "off-peak";
+	return "none";
+}
+
+/**
+ * The rate in force for a model, e.g. `$0.30/$1.20/M`. Empty when the rate in
+ * force is free, which keeps free models out of the footer instead of printing a
+ * zero rate.
+ */
+export function describeRate(cost: RateCard, multiplier: number): string {
+	const input = cost.input * multiplier;
+	const output = cost.output * multiplier;
+	if (input <= 0 && output <= 0) return "";
+	return `$${formatRate(input)}/$${formatRate(output)}${RATE_UNIT}`;
+}
+
+/** Up to three decimals without trailing zeros, and finer for a smaller rate. */
+function formatRate(value: number): string {
+	for (const decimals of [3, 6]) {
+		const text = value.toFixed(decimals).replace(/\.?0+$/, "");
+		if (text !== "" && text !== "0") return text;
+	}
+	return "0";
+}
+
+/**
+ * The footer indicator for a selected model: the rate in force, prefixed with
+ * `peak` or `off-peak` when it differs from the rate pi recorded. Undefined when
+ * correction is disabled, no model is selected, no schedule covers it, or it has
+ * no recorded cost to report.
+ */
+export function statusIndicator(
+	schedules: Schedule[],
+	active: boolean,
+	model: ModelRate | undefined,
+	now: Date = new Date(),
+): string | undefined {
+	if (!active || !model) return undefined;
+	const schedule = scheduleFor(schedules, model.provider, model.id);
+	if (!schedule) return undefined;
+
+	const rate = describeRate(model.cost, multiplierAt(now, schedule));
+	if (!rate) return undefined;
+
+	switch (rateStateAt(now, schedule)) {
+		case "peak":
+			return `· ${STATUS_PEAK} ${rate}`;
+		case "off-peak":
+			return `· ${STATUS_OFF_PEAK} ${rate}`;
+		default:
+			return `· ${rate}`;
+	}
+}
+
+export interface CostBreakdown extends RateCard {
 	total: number;
 }
 
@@ -250,50 +500,132 @@ export function writeActive(path: string, active: boolean): void {
 	}
 }
 
+function formatClock(minutes: number): string {
+	return `${String(Math.floor(minutes / 60)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}`;
+}
+
 function describeSchedule(schedule: Schedule): string {
 	const windows = schedule.windows
 		.map((window) => {
-			const fmt = (minutes: number) =>
-				`${String(Math.floor(minutes / 60)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}`;
-			return `${fmt(window.start)}-${fmt(window.end)}`;
+			const multiplier = window.multiplier !== undefined ? ` ×${window.multiplier}` : "";
+			return `${formatClock(window.start)}-${formatClock(window.end)}${multiplier}`;
 		})
 		.join(", ");
 	const days = schedule.days.map((day) => DAY_NAMES[day]).join(",");
-	return `${windows} UTC (${days}) ×${schedule.multiplier} for ${schedule.providers.join(",")}`;
+	const inside = windows ? `×${schedule.multiplier} in ${windows}` : `×${schedule.multiplier} always`;
+	return `${inside}, ×${schedule.outside} outside (${days} UTC) for ${schedule.providers.join(",")}`;
+}
+
+function describeAll(schedules: Schedule[]): string {
+	const configured = schedules.filter(
+		(schedule) => schedule.windows.length > 0 || schedule.multiplier !== 1 || schedule.outside !== 1,
+	);
+	if (configured.length === 0) return "no schedule configured";
+	return configured.map(describeSchedule).join(" | ");
+}
+
+export interface PeakHoursOptions {
+	/** Config file to read; defaults to the one in pi's agent directory. */
+	configPath?: string;
+}
+
+/**
+ * Messages already scaled. Retries re-deliver the same object, and pi applies a
+ * returned replacement by copying it onto that same object in place, so object
+ * identity is what identifies a message here.
+ *
+ * Shared across extension instances through a global: with the npm package and a
+ * local checkout both loaded, each would otherwise keep its own set and scale
+ * every message twice.
+ */
+const ADJUSTED_KEY = Symbol.for("pi-peak-hours.adjusted");
+function adjustedMessages(): WeakSet<object> {
+	const registry = globalThis as unknown as Record<symbol, WeakSet<object> | undefined>;
+	registry[ADJUSTED_KEY] ??= new WeakSet<object>();
+	return registry[ADJUSTED_KEY];
 }
 
-export default function peakHours(pi: ExtensionAPI): void {
-	let config = readConfig(CONFIG_PATH) ?? {};
-	let schedule = resolveSchedule(config);
-	let active = config.active ?? DEFAULT_ACTIVE;
-	/** Messages already scaled; retries can re-deliver the same object. */
-	const adjusted = new WeakSet<AssistantMessage>();
+export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions = {}): void {
+	const configPath = options.configPath ?? CONFIG_PATH;
+	let config = readConfig(configPath) ?? {};
+	let schedules = resolveSchedules(config);
+	let active = parseActive(config.active);
+	const adjusted = adjustedMessages();
 	let pendingStart: number | undefined;
+	let timer: ReturnType<typeof setTimeout> | undefined;
 
 	function refresh(): void {
-		config = readConfig(CONFIG_PATH) ?? {};
-		schedule = resolveSchedule(config);
-		active = config.active ?? DEFAULT_ACTIVE;
+		config = readConfig(configPath) ?? {};
+		schedules = resolveSchedules(config);
+		active = parseActive(config.active);
 	}
 
-	function updateStatus(ctx: ExtensionContext): void {
-		if (!active) {
-			ctx.ui.setStatus(STATUS_KEY, undefined);
-			return;
-		}
-		const multiplier = multiplierAt(new Date(), schedule);
-		ctx.ui.setStatus(STATUS_KEY, multiplier > 1 ? `· ${STATUS_PEAK}` : undefined);
+	function disarm(): void {
+		if (timer === undefined) return;
+		clearTimeout(timer);
+		timer = undefined;
+	}
+
+	/**
+	 * Keep the footer in step with the window it quotes. pi fires no event while a
+	 * session sits idle, so a session idle across a boundary would keep describing
+	 * a rate that has expired. Armed only for a `status` that is on screen, and
+	 * from the instant that status was computed: `now` is the one clock reading
+	 * shared by the rate and the boundary that ends it, so the last millisecond of
+	 * a window cannot arm the timer past its own edge.
+	 */
+	function arm(ctx: ExtensionContext, model: ModelRate | undefined, status: string | undefined, now: Date): void {
+		disarm();
+		// Nothing to keep fresh, or no footer to keep fresh in.
+		if (status === undefined || !ctx.hasUI || !model) return;
+		const schedule = scheduleFor(schedules, model.provider, model.id);
+		if (!schedule) return;
+
+		const next = nextTransitionAt(now, schedule);
+		if (!next) return;
+		// Floored, 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(() => {
+			timer = undefined;
+			updateStatus(ctx);
+		}, Math.max(1000, next.getTime() - now.getTime()));
+		timer.unref?.();
 	}
 
-	function notifyStatus(ctx: ExtensionContext): void {
+	function updateStatus(ctx: ExtensionContext, model: ModelRate | undefined = ctx.model): void {
+		const now = new Date();
+		const status = statusIndicator(schedules, active, model, now);
+		ctx.ui.setStatus(STATUS_KEY, status);
+		arm(ctx, model, status, now);
+	}
+
+	function notifyStatus(ctx: ExtensionContext, model: ModelRate | undefined = ctx.model): void {
 		if (!active) {
 			ctx.ui.notify(`Peak hours: off.`, "info");
 			return;
 		}
-		const now = new Date();
-		const multiplier = multiplierAt(now, schedule);
-		const state = multiplier > 1 ? `peak ×${multiplier} right now` : "off-peak right now";
-		ctx.ui.notify(`Peak hours: ${state}. ${describeSchedule(schedule)}`, "info");
+		// Schedules are provider-scoped, so name why nothing applies to a model none
+		// of them cover instead of reporting a rate that will never be charged.
+		if (!model) {
+			ctx.ui.notify(`Peak hours: no model selected. ${describeAll(schedules)}`, "info");
+			return;
+		}
+		const schedule = scheduleFor(schedules, model.provider, model.id);
+		if (!schedule) {
+			ctx.ui.notify(`Peak hours: not applied to ${model.provider}/${model.id}. ${describeAll(schedules)}`, "info");
+			return;
+		}
+		const multiplier = multiplierAt(new Date(), 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 detail = rate ? `${state} (${rate})` : state;
+		ctx.ui.notify(`Peak hours: ${detail}. ${describeSchedule(schedule)}`, "info");
 	}
 
 	pi.on("session_start", async (_event, ctx) => {
@@ -303,10 +635,17 @@ export default function peakHours(pi: ExtensionAPI): void {
 
 	pi.on("session_shutdown", async (_event, ctx) => {
 		pendingStart = undefined;
+		disarm();
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 
-	pi.on("model_select", async (_event, ctx) => {
+	pi.on("model_select", async (event, ctx) => {
+		updateStatus(ctx, event.model);
+	});
+
+	// The window boundary can pass between messages, and the footer quotes a price
+	// that changes with it, so re-evaluate whenever a turn starts.
+	pi.on("turn_start", async (_event, ctx) => {
 		updateStatus(ctx);
 	});
 
@@ -325,7 +664,12 @@ export default function peakHours(pi: ExtensionAPI): void {
 		const startedAt = pendingStart ?? message.timestamp ?? Date.now();
 		pendingStart = undefined;
 
-		if (!active || !matchesSchedule(schedule, message.provider, message.model)) {
+		if (!active) {
+			updateStatus(ctx);
+			return;
+		}
+		const schedule = scheduleFor(schedules, message.provider, message.model);
+		if (!schedule) {
 			updateStatus(ctx);
 			return;
 		}
@@ -338,15 +682,18 @@ export default function peakHours(pi: ExtensionAPI): void {
 
 		adjusted.add(message);
 		updateStatus(ctx);
-		return {
-			message: {
-				...message,
-				usage: {
-					...message.usage,
-					cost: applyMultiplier(message.usage.cost, multiplier),
-				},
+		const replacement = {
+			...message,
+			usage: {
+				...message.usage,
+				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.
+		adjusted.add(replacement);
+		return { message: replacement };
 	});
 
 	pi.registerCommand(COMMAND_PEAK_HOURS, {
@@ -368,7 +715,7 @@ export default function peakHours(pi: ExtensionAPI): void {
 				ctx.ui.notify("Usage: /peak-hours [on|off|status]", "error");
 				return;
 			}
-			writeActive(CONFIG_PATH, arg === "on");
+			writeActive(configPath, arg === "on");
 			refresh();
 			updateStatus(ctx);
 			notifyStatus(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-peak-hours",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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": [
@@ -41,7 +41,6 @@
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*"
   },
   "files": [