pi-harness-runtime 0.9.6 → 0.9.10

package/index.ts

@@ -23,6 +23,20 @@ import { UsageTracker } from "./tracker.ts";
 import { MirrorStore, type MirrorRecord } from "./mirror.ts";
 import { MiniMaxQuotaScraper } from "./harness/e2e/minimax-quota-scraper.js";
 import { parseMiniMaxQuotaText } from "./harness/e2e/minimax-quota-parser.js";
+import {
+	CookieWatcher,
+	DEFAULT_DROP_DIR as COOKIE_DROP_DIR,
+	hasAnyCookieSource as sanitizerHasAnyCookieSource,
+} from "./packages/cookie-sanitizer/src/index.ts";
+import {
+	providerFromModelId,
+	type ProviderId,
+} from "./packages/providers/src/provider-id.ts";
+import {
+	TUIUsageMonitor,
+	type TUIUsageSignal,
+} from "./packages/quota-manager/src/tui-usage-monitor.ts";
+import { QuotaManager } from "./packages/quota-manager/src/quota-manager.ts";
 import { buildFooterStatusValue } from "./footer-status.ts";
 import {
 	MAX_PROACTIVE_COMPACT_FAILURES,
@@ -66,6 +80,39 @@ interface HarnessSession {
 
 let currentSession: HarnessSession | null = null;
 
+/**
+ * Safely extract a text view from an LLM message. Used to feed the TUI
+ * quota-signal extractor. Handles string content, array-of-parts content
+ * (with `text` fields), and falls back to a stringified JSON for unknown
+ * shapes. Never throws.
+ */
+function readMessageText(message: unknown): string {
+	try {
+		if (!message || typeof message !== "object") return "";
+		const m = message as { role?: unknown; content?: unknown };
+		if (typeof m.content === "string") return m.content;
+		if (Array.isArray(m.content)) {
+			const parts: string[] = [];
+			for (const p of m.content) {
+				if (!p) continue;
+				if (typeof p === "string") {
+					parts.push(p);
+				} else if (typeof p === "object") {
+					const obj = p as { text?: unknown; content?: unknown };
+					if (typeof obj.text === "string") parts.push(obj.text);
+					else if (typeof obj.content === "string") parts.push(obj.content);
+				}
+			}
+			return parts.join("\n");
+		}
+		// Fallback: best-effort stringification. Never include cookie-shaped
+		// data; we only stringify LLM message shapes which are JSON-safe.
+		return JSON.stringify(message).slice(0, 8000);
+	} catch {
+		return "";
+	}
+}
+
 function ensureHarnessDir() {
 	if (!existsSync(HARNESS_ROOT_DIR)) {
 		mkdirSync(HARNESS_ROOT_DIR, { recursive: true });
@@ -81,6 +128,33 @@ async function getCheckpointManager(): Promise<CheckpointManager> {
 	) as unknown as CheckpointManager;
 }
 
+function isOutputLimitResumePromptMessage(message: {
+	role?: string;
+	content?: unknown;
+}): boolean {
+	if (message.role !== "user") {
+		return false;
+	}
+	if (typeof message.content === "string") {
+		return message.content === OUTPUT_LIMIT_RESUME_PROMPT;
+	}
+	if (!Array.isArray(message.content)) {
+		return false;
+	}
+	return (
+		message.content
+			.filter(
+				(part): part is { type: "text"; text: string } =>
+					part &&
+					typeof part === "object" &&
+					(part as { type?: unknown }).type === "text" &&
+					typeof (part as { text?: unknown }).text === "string",
+			)
+			.map((part) => part.text)
+			.join("\n") === OUTPUT_LIMIT_RESUME_PROMPT
+	);
+}
+
 export default function (pi: ExtensionAPI) {
 	const tracker = new UsageTracker();
 	const mirrorStore = new MirrorStore();
@@ -88,6 +162,10 @@ export default function (pi: ExtensionAPI) {
 
 	// ─── Auto-track every assistant message ──────────────────────────────
 	pi.on("message_end", async (event, ctx) => {
+		if (isOutputLimitResumePromptMessage(event.message)) {
+			pendingOutputLimitResumeAfterSettled = false;
+			return;
+		}
 		if (event.message.role !== "assistant") return;
 		const m = event.message as {
 			role?: string;
@@ -111,9 +189,11 @@ export default function (pi: ExtensionAPI) {
 		) {
 			outputLimitResumeAttempts += 1;
 			pendingOutputLimitResumeAfterCompact = true;
+			pendingOutputLimitResumeAfterSettled = true;
 			queueAutoResume("output-limit", OUTPUT_LIMIT_RESUME_PROMPT, "steer");
 		} else if (m.stopReason === "stop") {
 			outputLimitResumeAttempts = 0;
+			pendingOutputLimitResumeAfterSettled = false;
 		}
 
 		if (!m.usage) return;
@@ -126,6 +206,19 @@ export default function (pi: ExtensionAPI) {
 			cache_write: m.usage.cacheWrite ?? 0,
 			cost: m.usage.cost?.total ?? 0,
 		});
+
+		// Feed TUI quota-signal extractor with the assistant message text.
+		// Best-effort — never throws. Coalesces provider quota notifications
+		// (e.g. "OpenAI: context length exceeded, reset in 3 hr 27 min") into
+		// the per-provider mirror via `tuiMonitor`.
+		try {
+			const text = readMessageText(event.message);
+			if (text) {
+				tuiMonitor.processMessage(text);
+			}
+		} catch {
+			// best-effort
+		}
 	});
 
 	// ─── Smart quota fetch for MiniMax status ────────────────────────
@@ -135,7 +228,84 @@ export default function (pi: ExtensionAPI) {
 	const quotaScraper = process.env.QUOTA_COOKIE_FILE
 		? new MiniMaxQuotaScraper({ cookieFile: process.env.QUOTA_COOKIE_FILE })
 		: new MiniMaxQuotaScraper();
-	const cookieQuotaAutoFetchAvailable = quotaScraper.hasCookieFile();
+
+	// ─── Cookie sanitizer integration ────────────────────────────────────
+	// The drop folder is the user-facing, forgiving input. The canonical
+	// cache (`~/.config/minimax-cookies.txt`) is the runtime-owned,
+	// normalized output that `MiniMaxQuotaScraper` reads. Either being
+	// present enables scraping.
+	const cookieDropDir = COOKIE_DROP_DIR;
+	const cookieCachePath = join(homedir(), ".config", "minimax-cookies.txt");
+
+	const hasCookieSource = (): boolean => {
+		try {
+			if (existsSync(cookieCachePath)) return true;
+		} catch {
+			// ignore
+		}
+		try {
+			return sanitizerHasAnyCookieSource(cookieDropDir);
+		} catch {
+			return false;
+		}
+	};
+
+	const cookieQuotaAutoFetchAvailable = hasCookieSource();
+
+	// ─── TUI quota signal plumbing (OpenAI / GLM / Anthropic / OpenRouter) ──
+	// The TUIUsageMonitor parses provider quota-exhaustion messages from pi's
+	// TUI / message stream and emits signals we write to per-provider mirror
+	// entries. For providers that don't expose a continuous usage API this is
+	// the only path to surface data in the footer.
+	const quotaManager = new QuotaManager();
+	const tuiMonitor = new TUIUsageMonitor({ quotaManager });
+
+	tuiMonitor.on("signal", (signal: TUIUsageSignal) => {
+		try {
+			writeMirrorRecord(signal.provider as ProviderId, {
+				synced_at: signal.timestamp,
+				source: "tui-signal",
+				exhausted: signal.exhausted,
+				limitType: signal.limitType,
+				remainingPct: signal.remainingPct,
+				resets_at: signal.resetsAt,
+			});
+		} catch (e) {
+			console.error(
+				"[pi-harness] tui-signal write failed:",
+				e instanceof Error ? e.message : String(e),
+			);
+		}
+	});
+
+	// Live watcher — sanitises on every change in the drop folder.
+	const cookieWatcher = new CookieWatcher({
+		dropDir: cookieDropDir,
+		syncOptions: { cachePath: cookieCachePath },
+		onEvent: (event) => {
+			if (event.kind === "sync-error" || event.kind === "watcher-error") {
+				console.error(
+					"[pi-harness] cookie-sanitizer:",
+					"message" in event ? event.message : "",
+				);
+			}
+			// A successful sync means the canonical cache is fresh; the
+			// next autoFetchQuota() should pick it up immediately. Reset
+			// the rate-limit so we don't wait 15 min for the first scrape.
+			if (event.kind === "sync-ok") {
+				lastQuotaAutoFetchAt = 0;
+			}
+		},
+	});
+	try {
+		cookieWatcher.start();
+	} catch (e) {
+		console.error(
+			"[pi-harness] cookie-sanitizer watcher failed to start:",
+			e instanceof Error ? e.message : String(e),
+		);
+	}
+
 	let footerStatusCtx: {
 		ui: { setStatus: (key: string, value: string) => void };
 	} | null = null;
@@ -147,11 +317,21 @@ export default function (pi: ExtensionAPI) {
 	let proactiveCompactCircuitReported = false;
 	let outputLimitResumeAttempts = 0;
 	let pendingOutputLimitResumeAfterCompact = false;
+	let pendingOutputLimitResumeAfterSettled = false;
 
-	function writeMirrorRecord(record: MirrorRecord): void {
-		mirrorStore.write(record);
+	function writeMirrorRecord(
+		provider: ProviderId,
+		record: Omit<import("./mirror.js").ProviderMirrorRecord, "provider">,
+	): void {
+		mirrorStore.writeProvider(provider, { ...record, provider });
 		if (footerStatusCtx) {
-			refreshFooterStatus(footerStatusCtx, tracker, mirrorStore);
+			refreshFooterStatus(
+				footerStatusCtx,
+				tracker,
+				mirrorStore,
+				hasCookieSource,
+				() => lastActiveProvider,
+			);
 		}
 	}
 
@@ -167,7 +347,27 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	function isMiniMaxModel(modelId: string | null | undefined): boolean {
-		return /minimax/i.test(modelId ?? "");
+		return providerFromModelId(modelId) === "minimax";
+	}
+
+	/** Active provider for the current/last-seen model. Updated by event handlers. */
+	let lastActiveProvider: ProviderId | null = null;
+
+	/** Set the active provider; triggers a footer refresh. */
+	function noteActiveProvider(modelId: string | null | undefined): void {
+		const p = providerFromModelId(modelId);
+		if (p !== lastActiveProvider) {
+			lastActiveProvider = p;
+			if (footerStatusCtx) {
+				refreshFooterStatus(
+					footerStatusCtx,
+					tracker,
+					mirrorStore,
+					hasCookieSource,
+					() => lastActiveProvider,
+				);
+			}
+		}
 	}
 
 	function getMiniMaxUsageSince(sinceMs: number): {
@@ -246,7 +446,15 @@ export default function (pi: ExtensionAPI) {
 		const profileRecord =
 			await autoFetchQuotaFromBrowserProfile(suppressErrors);
 		if (profileRecord) {
-			writeMirrorRecord(profileRecord);
+			writeMirrorRecord("minimax", {
+				synced_at: profileRecord.synced_at,
+				source: "scrape",
+				model: profileRecord.model,
+				h5_used_pct: profileRecord.h5_used_pct,
+				h5_resets_at: profileRecord.h5_resets_at,
+				weekly_used_pct: profileRecord.weekly_used_pct,
+				weekly_resets_at: profileRecord.weekly_resets_at,
+			});
 			return true;
 		}
 
@@ -256,9 +464,9 @@ export default function (pi: ExtensionAPI) {
 
 		try {
 			const data = await quotaScraper.scrape();
-			writeMirrorRecord({
+			writeMirrorRecord("minimax", {
 				synced_at: data.scrapedAt,
-				provider: "minimax",
+				source: "scrape",
 				h5_used_pct: data.h5UsedPct,
 				h5_resets_at: data.h5ResetsAt,
 				weekly_used_pct: data.weeklyUsedPct,
@@ -339,8 +547,8 @@ export default function (pi: ExtensionAPI) {
 				(await hasBrowserProfileAutoFetchSource());
 			if (!autoFetchAvailable) {
 				ctx.ui.notify(
-					"Quota auto-fetch is unavailable. Set `QUOTA_COOKIE_FILE` or run `bun packages/auth/src/run-minimax-auth.ts auth` first.",
-					"info",
+					"MiniMax cookies not found. Drop any cookie file (Netscape or EditThisCookie JSON) into ~/.pi-harness-runtime/cookies/ — the runtime normalizes it for you. Or run `bun packages/auth/src/run-minimax-auth.ts auth`.",
+					"warning",
 				);
 				return;
 			}
@@ -418,7 +626,13 @@ export default function (pi: ExtensionAPI) {
 					"info",
 				);
 				footerStatusCtx = ctx;
-				refreshFooterStatus(ctx, tracker, mirrorStore);
+				refreshFooterStatus(
+					ctx,
+					tracker,
+					mirrorStore,
+					hasCookieSource,
+					() => lastActiveProvider,
+				);
 			} catch (e) {
 				ctx.ui.notify(`Failed to clear mirror: ${e}`, "error");
 			}
@@ -673,23 +887,56 @@ export default function (pi: ExtensionAPI) {
 	// ─── Footer status (persistent badge) ────────────────────────────────
 	pi.on("session_start", (_event, ctx) => {
 		footerStatusCtx = ctx;
-		refreshFooterStatus(ctx, tracker, mirrorStore);
+		refreshFooterStatus(
+			ctx,
+			tracker,
+			mirrorStore,
+			hasCookieSource,
+			() => lastActiveProvider,
+		);
 	});
 
 	pi.on("turn_end", (_event, ctx) => {
+		noteActiveProvider(ctx.model?.id ?? null);
 		footerStatusCtx = ctx;
-		refreshFooterStatus(ctx, tracker, mirrorStore);
+		refreshFooterStatus(
+			ctx,
+			tracker,
+			mirrorStore,
+			hasCookieSource,
+			() => lastActiveProvider,
+		);
 		void maybeAutoFetchQuota(ctx.model?.id ?? null);
 		maybeTriggerProactiveCompact(ctx);
 	});
 
+	pi.on("agent_end", () => {
+		setTimeout(() => {
+			if (!pendingOutputLimitResumeAfterSettled) {
+				return;
+			}
+			pendingOutputLimitResumeAfterSettled = false;
+			queueAutoResume(
+				"output-limit-settled",
+				OUTPUT_LIMIT_RESUME_PROMPT,
+				"followUp",
+			);
+		}, 0);
+	});
+
 	pi.on("session_compact", (event, ctx) => {
 		footerStatusCtx = ctx;
 		proactiveCompactInFlight = false;
 		lastProactiveCompactAt = Date.now();
 		consecutiveCompactFailures = 0;
 		proactiveCompactCircuitReported = false;
-		refreshFooterStatus(ctx, tracker, mirrorStore);
+		refreshFooterStatus(
+			ctx,
+			tracker,
+			mirrorStore,
+			hasCookieSource,
+			() => lastActiveProvider,
+		);
 
 		const forceOutputLimitResume = pendingOutputLimitResumeAfterCompact;
 		pendingOutputLimitResumeAfterCompact = false;
@@ -784,13 +1031,22 @@ function refreshFooterStatus(
 	ctx: { ui: { setStatus: (key: string, value: string) => void } },
 	tracker: UsageTracker,
 	mirrorStore: MirrorStore,
+	hasCookieSource: () => boolean,
+	getActiveProvider: () => ProviderId | null = () => null,
 ) {
 	const nowMs = Date.now();
 	const local = aggregateWindows(tracker.all());
-	const mirror = mirrorStore.read();
+	const provider = getActiveProvider();
+	const mirror = provider ? mirrorStore.readProvider(provider) : null;
 	const freshness = mirrorStore.freshness(mirror, nowMs);
 	ctx.ui.setStatus(
 		"harness-runtime",
-		buildFooterStatusValue(local, mirror, freshness),
+		buildFooterStatusValue(
+			local,
+			mirror,
+			freshness,
+			hasCookieSource(),
+			provider,
+		),
 	);
 }

package/mirror.ts

@@ -1,29 +1,132 @@
 /**
- * MirrorStore — cached provider quota snapshot.
+ * MirrorStore — cached per-provider quota snapshot.
  *
- * Auto refresh fetches MiniMax quota data from the web console and writes it to
- * ~/.pi/usage-status/mirror.json so footer status and `/usage` can render the
- * latest provider-side 5h/weekly usage.
+ * Auto refresh writes per-provider data to ~/.pi/usage-status/mirror.json so
+ * the footer status and `/usage` can render the latest provider-side
+ * usage. Local tracking counts OUR usage; the mirror counts what's
+ * currently knowable from the provider (continuous for MiniMax via
+ * scrape; one-shot TUI signal for OpenAI / GLM / etc.).
  *
- * Local tracking counts OUR usage only; the mirror counts TOTAL quota usage
- * across all clients visible in the provider console.
+ * Shape (per-provider map):
+ *
+ * ```jsonc
+ * {
+ *   "minimax": {
+ *     "synced_at": "2026-07-23T06:20:04Z",
+ *     "source": "scrape" | "tui-signal",
+ *     "h5_used_pct": 15,
+ *     "h5_resets_at": "3 hr 39 min",
+ *     "weekly_used_pct": 21,
+ *     "weekly_resets_at": "3 days 17 hr 39 min"
+ *   },
+ *   "openai": { ... }
+ * }
+ * ```
+ *
+ * Back-compat: legacy single-row files are read and upgraded in place
+ * on the first `readAll()` call after upgrade. Old rows that match a
+ * known provider (have a `provider` field) are placed under that key.
+ *
+ * Models live here: `~/.pi/usage-status/mirror.json`.
  */
 
 import { getMirrorPath, readJson, writeJson } from "./cli.ts";
 
+/** Where a piece of data came from. */
+export type MirrorSource = "scrape" | "tui-signal" | "manual";
+
+/** Per-provider mirror record. */
+export interface ProviderMirrorRecord {
+	/** ISO-8601 UTC timestamp when this row was last updated. */
+	synced_at: string;
+	/** Provider id (e.g. "minimax", "openai", "glm"). Must match the key. */
+	provider: string;
+	/** Source of the data — used for diagnostics. */
+	source: MirrorSource;
+	/** Optional model id the data was captured for. */
+	model?: string;
+	/** 5h window used percent (0-100). Provider-reported when available. */
+	h5_used_pct?: number;
+	/** When the 5h window resets — human-readable or ISO. */
+	h5_resets_at?: string;
+	/** Weekly used percent. */
+	weekly_used_pct?: number;
+	/** When the weekly window resets. */
+	weekly_resets_at?: string;
+	/** Set when a limit was hit and we have the exhaustion signal. */
+	exhausted?: boolean;
+	/** Limit type from TUI signal: tokens, context_window, rate_limit, unknown. */
+	limitType?: "tokens" | "context_window" | "rate_limit" | "unknown";
+	/** Remaining pct (0-100) at exhaustion — 0 means exactly exhausted. */
+	remainingPct?: number;
+	/** ISO-8601 reset timestamp from TUI signal, if absolute. */
+	resets_at?: string;
+}
+
+/** Map of provider id → its mirror record. */
+export type PerProviderMirror = Record<string, ProviderMirrorRecord>;
+
+/**
+ * Legacy single-row shape — accepted on read and migrated forward on
+ * the first `readAll()` call after upgrade. Writers should use the
+ * per-provider shape via `writeProvider(provider, record)`.
+ */
 export interface MirrorRecord {
-	synced_at: string; // ISO 8601 UTC
-	provider: string; // e.g. "minimax"
-	model?: string; // optional, e.g. "minimax/MiniMax-M3"
-	h5_used_pct?: number; // 0-100
-	h5_resets_at?: string; // ISO 8601 UTC — provider-reported
-	weekly_used_pct?: number; // 0-100
-	weekly_resets_at?: string; // ISO 8601 UTC — provider-reported
+	synced_at: string;
+	provider?: string;
+	model?: string;
+	h5_used_pct?: number;
+	h5_resets_at?: string;
+	weekly_used_pct?: number;
+	weekly_resets_at?: string;
 }
 
+/** Known provider ids used as keys in the per-provider map. */
+export type KnownProviderId =
+	| "minimax"
+	| "openai"
+	| "openai-codex"
+	| "glm"
+	| "anthropic"
+	| "openrouter"
+	| (string & {}); // allow extension
+
 const STALE_WARN_MS = 30 * 60 * 1000; // 30 min → orange
 const STALE_ERROR_MS = 2 * 60 * 60 * 1000; // 2 h   → red
 
+/**
+ * Detect whether a raw read looks like a legacy single-row shape
+ * (i.e. not yet the per-provider map). Used to gate the upgrade path.
+ */
+function isLegacyShape(raw: unknown): raw is MirrorRecord & {
+	provider: string;
+	[key: string]: unknown;
+} {
+	if (!raw || typeof raw !== "object") return false;
+	const obj = raw as Record<string, unknown>;
+	if ("provider" in obj && typeof obj.provider === "string") {
+		// Legacy single-row shape: has flat provider string, no map-of-records structure.
+		return true;
+	}
+	return false;
+}
+
+/** Convert a legacy single-row record to per-provider shape. */
+function upgradeLegacyRecord(legacy: MirrorRecord): PerProviderMirror {
+	const provider = legacy.provider ?? "minimax";
+	const rec: ProviderMirrorRecord = {
+		synced_at: legacy.synced_at ?? new Date().toISOString(),
+		provider,
+		source: "scrape", // legacy was always scrape
+		model: legacy.model,
+		h5_used_pct: legacy.h5_used_pct,
+		h5_resets_at: legacy.h5_resets_at,
+		weekly_used_pct: legacy.weekly_used_pct,
+		weekly_resets_at: legacy.weekly_resets_at,
+	};
+	return { [provider]: rec };
+}
+
 export class MirrorStore {
 	private path: string;
 
@@ -31,21 +134,88 @@ export class MirrorStore {
 		this.path = path;
 	}
 
-	/** Read the mirror record. Returns null if missing/corrupted. */
+	/** Read the mirror record. LEGACY: returns whatever is in the file. */
 	read(): MirrorRecord | null {
 		const raw = readJson(this.path);
 		if (!raw || typeof raw !== "object") return null;
 		return raw as MirrorRecord;
 	}
 
-	/** Write a new mirror record (overwrites). */
+	/**
+	 * Read the entire per-provider mirror. Auto-migrates legacy shape
+	 * on first read after upgrade. Returns null if the file is missing
+	 * or corrupted.
+	 */
+	readAll(): PerProviderMirror | null {
+		const raw = readJson(this.path);
+		if (!raw || typeof raw !== "object") return null;
+
+		if (isLegacyShape(raw)) {
+			const upgraded = upgradeLegacyRecord(raw as MirrorRecord);
+			// Persist the upgrade so subsequent reads are fast.
+			try {
+				writeJson(this.path, upgraded);
+			} catch {
+				// best-effort
+			}
+			return upgraded;
+		}
+
+		// Already per-provider shape.
+		const out: PerProviderMirror = {};
+		for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+			if (v && typeof v === "object") {
+				out[k] = v as ProviderMirrorRecord;
+			}
+		}
+		return Object.keys(out).length > 0 ? out : null;
+	}
+
+	/** Read a single provider's record. Returns null if missing. */
+	readProvider(provider: string): ProviderMirrorRecord | null {
+		const all = this.readAll();
+		if (!all) return null;
+		return all[provider] ?? null;
+	}
+
+	/** Write a single provider's record (overwrites just that key). */
+	writeProvider(provider: string, record: ProviderMirrorRecord): void {
+		const all = this.readAll() ?? {};
+		all[provider] = record;
+		writeJson(this.path, all);
+	}
+
+	/** Write a new mirror record (overwrites). LEGACY: deprecated, use writeProvider. */
 	write(record: MirrorRecord): void {
+		// If the caller passes a record that already has a provider key,
+		// route through writeProvider so we keep the per-provider shape.
+		if (
+			record &&
+			typeof record === "object" &&
+			"provider" in record &&
+			typeof (record as { provider: unknown }).provider === "string"
+		) {
+			const r = record as MirrorRecord;
+			const provider = (r.provider as string) ?? "minimax";
+			const prev = this.readProvider(provider);
+			this.writeProvider(provider, {
+				synced_at: r.synced_at ?? new Date().toISOString(),
+				provider,
+				source: prev?.source ?? "scrape",
+				model: r.model ?? prev?.model,
+				h5_used_pct: r.h5_used_pct ?? prev?.h5_used_pct,
+				h5_resets_at: r.h5_resets_at ?? prev?.h5_resets_at,
+				weekly_used_pct: r.weekly_used_pct ?? prev?.weekly_used_pct,
+				weekly_resets_at: r.weekly_resets_at ?? prev?.weekly_resets_at,
+			});
+			return;
+		}
 		writeJson(this.path, record);
 	}
 
 	/** Returns "fresh" | "stale" | "expired" based on age. */
 	freshness(
-		record: MirrorRecord | null,
+		record: ProviderMirrorRecord | MirrorRecord | null,
 		nowMs: number,
 	): "fresh" | "stale" | "expired" | "missing" {
 		if (!record || !record.synced_at) return "missing";
@@ -58,12 +228,18 @@ export class MirrorStore {
 	}
 
 	/** True if data is too stale to trust (> 2 hours old). */
-	isExpired(record: MirrorRecord | null, nowMs: number): boolean {
+	isExpired(
+		record: ProviderMirrorRecord | MirrorRecord | null,
+		nowMs: number,
+	): boolean {
 		return this.freshness(record, nowMs) === "expired";
 	}
 
 	/** Convenience: human-readable age like "5 min ago" or "1 d 2 h ago". */
-	ageString(record: MirrorRecord | null, nowMs: number): string {
+	ageString(
+		record: ProviderMirrorRecord | MirrorRecord | null,
+		nowMs: number,
+	): string {
 		if (!record || !record.synced_at) return "never";
 		const syncedMs = Date.parse(record.synced_at);
 		if (isNaN(syncedMs)) return "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "0.9.6",
+  "version": "0.9.10",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "0.9.6",
+  "version": "0.9.10",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "0.9.6",
+  "version": "0.9.10",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",