pi-harness-runtime 0.10.13 → 0.10.14

package/mirror.js

@@ -0,0 +1,205 @@
+/**
+ * MirrorStore — cached per-provider quota snapshot.
+ *
+ * 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.).
+ *
+ * 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";
+/**
+ * Canonical lowercase provider ids — mirrors the KNOWN_AI_PROVIDERS from
+ * packages/types/src/ai-providers.ts. Duplicated here to avoid import path
+ * resolution issues in the root workspace.
+ */
+const KNOWN_PROVIDER_IDS = [
+    "minimax",
+    "openai",
+    "anthropic",
+    "glm",
+    "openrouter",
+    "openai-codex",
+    "deepseek",
+    "gemini",
+    "kimi",
+];
+function isKnownProvider(id) {
+    return KNOWN_PROVIDER_IDS.includes(id);
+}
+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) {
+    if (!raw || typeof raw !== "object")
+        return false;
+    const obj = raw;
+    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) {
+    const provider = legacy.provider ?? "minimax";
+    const known = isKnownProvider(provider) ? provider : "minimax";
+    const rec = {
+        synced_at: legacy.synced_at ?? new Date().toISOString(),
+        provider: known,
+        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 { [known]: rec };
+}
+export class MirrorStore {
+    path;
+    constructor(path = getMirrorPath()) {
+        this.path = path;
+    }
+    /** Read the mirror record. LEGACY: returns whatever is in the file. */
+    read() {
+        const raw = readJson(this.path);
+        if (!raw || typeof raw !== "object")
+            return null;
+        return raw;
+    }
+    /**
+     * 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() {
+        const raw = readJson(this.path);
+        if (!raw || typeof raw !== "object")
+            return null;
+        if (isLegacyShape(raw)) {
+            const upgraded = upgradeLegacyRecord(raw);
+            if (upgraded) {
+                // Persist the upgrade so subsequent reads are fast.
+                try {
+                    writeJson(this.path, upgraded);
+                }
+                catch {
+                    // best-effort
+                }
+                return upgraded;
+            }
+            // Unknown legacy provider — treat as absent.
+            return null;
+        }
+        // Already per-provider shape.
+        const out = {};
+        for (const [k, v] of Object.entries(raw)) {
+            if (v && typeof v === "object") {
+                out[k] = v;
+            }
+        }
+        return Object.keys(out).length > 0 ? out : null;
+    }
+    /** Read a single provider's record. Returns null if missing. */
+    readProvider(provider) {
+        const all = this.readAll();
+        if (!all)
+            return null;
+        return all[provider] ?? null;
+    }
+    /** Write a single provider's record (overwrites just that key). */
+    writeProvider(provider, record) {
+        const all = this.readAll() ?? {};
+        all[provider] = record;
+        writeJson(this.path, all);
+    }
+    /** Write a new mirror record (overwrites). LEGACY: deprecated, use writeProvider. */
+    write(record) {
+        // 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.provider === "string") {
+            const r = record;
+            const provider = r.provider ?? "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, nowMs) {
+        if (!record || !record.synced_at)
+            return "missing";
+        const syncedMs = Date.parse(record.synced_at);
+        if (isNaN(syncedMs))
+            return "missing";
+        const ageMs = nowMs - syncedMs;
+        if (ageMs < STALE_WARN_MS)
+            return "fresh";
+        if (ageMs < STALE_ERROR_MS)
+            return "stale";
+        return "expired";
+    }
+    /** True if data is too stale to trust (> 2 hours old). */
+    isExpired(record, nowMs) {
+        return this.freshness(record, nowMs) === "expired";
+    }
+    /** Convenience: human-readable age like "5 min ago" or "1 d 2 h ago". */
+    ageString(record, nowMs) {
+        if (!record || !record.synced_at)
+            return "never";
+        const syncedMs = Date.parse(record.synced_at);
+        if (isNaN(syncedMs))
+            return "unknown";
+        const delta = nowMs - syncedMs;
+        const sec = Math.floor(delta / 1000);
+        if (sec < 60)
+            return `${sec}s ago`;
+        const min = Math.floor(sec / 60);
+        if (min < 60)
+            return `${min} min ago`;
+        const hr = Math.floor(min / 60);
+        if (hr < 24)
+            return `${hr} h ago`;
+        const day = Math.floor(hr / 24);
+        return `${day} d ago`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "0.10.13",
+  "version": "0.10.14",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {
@@ -16,15 +16,17 @@
     "auth:minimax:scrape": "bun packages/auth/src/run-minimax-auth.ts scrape",
     "skills:sync": "bun scripts/skills-sync.ts",
     "skills:sync:check": "bun scripts/skills-sync.ts --check-only",
-    "build": "for pkg in packages/*/; do [ -f \"${pkg}tsconfig.json\" ] && [ \"$pkg\" != \"packages/provider-router/\" ] && node_modules/.bin/tsc -p \"${pkg}tsconfig.json\" --skipLibCheck > /dev/null 2>&1 || true; done",
+    "build": "bun run build:packages && bun run build:root",
+    "build:root": "for f in *.ts; do [ -f \"$f\" ] && tsc \"$f\" --outDir . --skipLibCheck --module ESNext --moduleResolution node --target ES2022 > /dev/null 2>&1 || true; done",
+    "build:packages": "for pkg in packages/*/; do [ -f \"${pkg}tsconfig.json\" ] && [ \"$pkg\" != \"packages/provider-router/\" ] && tsc -p \"${pkg}tsconfig.json\" --skipLibCheck > /dev/null 2>&1 || true; done",
     "prepublishOnly": "bun run build"
   },
   "bin": {
     "harness-auth": "packages/auth/src/run-minimax-auth.ts"
   },
   "files": [
-    "*.ts",
-    "harness/**/*.ts",
+    "*.{ts,js}",
+    "harness/**/*.{ts,js}",
     "packages/*/dist/**/*",
     "packages/*/src/**/*.ts",
     "skills/**/*",

package/proactive-compact.js

@@ -0,0 +1,42 @@
+export const PROACTIVE_COMPACT_THRESHOLD = 0.9;
+export const PROACTIVE_COMPACT_HEADROOM_TOKENS = 15_000;
+export const PROACTIVE_COMPACT_COOLDOWN_MS = 10 * 60 * 1000;
+export const MAX_PROACTIVE_COMPACT_FAILURES = 3;
+export const OUTPUT_LIMIT_AUTO_RESUME_LIMIT = 3;
+export const OUTPUT_LIMIT_RESUME_PROMPT = "Output token limit hit. Resume directly — no apology, no recap. Pick up mid-thought if the cut happened there. Break remaining work into smaller pieces.";
+export function shouldTriggerProactiveCompact(usage, options) {
+    if (!usage) {
+        return false;
+    }
+    const headroomTokens = options?.headroomTokens ?? PROACTIVE_COMPACT_HEADROOM_TOKENS;
+    if (usage.tokens !== null &&
+        usage.contextWindow - usage.tokens <= headroomTokens) {
+        return true;
+    }
+    const threshold = options?.threshold ?? PROACTIVE_COMPACT_THRESHOLD;
+    return usage.percent !== null && usage.percent >= threshold;
+}
+export function isOutputLimitAssistantMessage(message) {
+    if (message.role !== "assistant") {
+        return false;
+    }
+    if (message.stopReason === "length" ||
+        message.stopReason === "max_output_tokens" ||
+        message.stopReason === "max_tokens") {
+        return true;
+    }
+    return (typeof message.errorMessage === "string" &&
+        /reached the maximum output token limit|maximum output token limit|output token limit/i.test(message.errorMessage));
+}
+export function shouldQueueOutputLimitResume(message, resumeAttempts, hasPendingMessages, options) {
+    const maxAttempts = options?.maxAttempts ?? OUTPUT_LIMIT_AUTO_RESUME_LIMIT;
+    return (isOutputLimitAssistantMessage(message) &&
+        resumeAttempts < maxAttempts &&
+        !hasPendingMessages);
+}
+export function shouldQueuePostCompactionResume(event, hasPendingMessages, options) {
+    if (event.reason === "manual" && options?.force !== true) {
+        return false;
+    }
+    return ((options?.force === true || event.willRetry !== true) && !hasPendingMessages);
+}

package/renderer.js

@@ -0,0 +1,134 @@
+/**
+ * StatusRenderer — Codex-style output formatting.
+ *
+ * Produces the same visual style as Codex's `/status`:
+ *   5h limit:     [████████░░░░░░░░░░░░] 18% left (resets in 4h 56m)
+ *   Weekly limit: [████████████████░░░░] 81% left (resets in 2d 13h)
+ *
+ * We render with plain text (no TUI dependency) so it's testable with
+ * node --test and works in `ctx.ui.notify()`.
+ */
+import { formatDuration, formatRelative, formatTokens, formatUsd, } from "./cli.ts";
+import { FIVE_HOURS_MS, SEVEN_DAYS_MS, computeLocalResetTime, } from "./windows.ts";
+const BAR_WIDTH = 20;
+const FILLED = "█";
+const EMPTY = "░";
+export function renderProgressBar(pct, width = BAR_WIDTH) {
+    const clamped = Math.max(0, Math.min(100, pct));
+    const filledCount = Math.round((clamped / 100) * width);
+    const emptyCount = width - filledCount;
+    return "[" + FILLED.repeat(filledCount) + EMPTY.repeat(emptyCount) + "]";
+}
+/** Render the "18% left" style label (what's REMAINING, like Codex). */
+function renderLeftLabel(pct) {
+    const left = Math.max(0, Math.min(100, 100 - pct));
+    return `${left.toFixed(0)}% left`;
+}
+/** Render the full status block. */
+export function renderStatus(input) {
+    const lines = [];
+    const divider = "-".repeat(64);
+    // --- Header ----------------------------------------------------------
+    lines.push("Codex-style usage status for pi");
+    lines.push(divider);
+    lines.push(` Model:        ${input.model ?? "unknown"}`);
+    lines.push(` Directory:    ${input.cwd}`);
+    lines.push("");
+    // --- Local tracking -------------------------------------------------
+    lines.push(" ① LOCAL TRACKED (ground truth — we count this)");
+    lines.push(`    This session:   ${formatUsd(input.local.lifetime.cost)} · ${formatTokens(input.local.lifetime.tokens)} tokens · ${input.local.lifetime.requests} requests`);
+    lines.push(`    This 5h:        ${formatTokens(input.local.five_h.tokens)} tokens · ${input.local.five_h.requests} requests · ${formatUsd(input.local.five_h.cost)}`);
+    lines.push(`    This week:      ${formatTokens(input.local.weekly.tokens)} tokens · ${input.local.weekly.requests} requests · ${formatUsd(input.local.weekly.cost)}`);
+    lines.push(`    Lifetime:       ${input.local.lifetime.requests} requests · ${formatUsd(input.local.lifetime.cost)}`);
+    lines.push("");
+    // --- Provider mirror -------------------------------------------------
+    if (input.mirror) {
+        const fresh = input.mirrorStore.freshness(input.mirror, input.nowMs);
+        const freshnessLabel = fresh === "fresh"
+            ? "fresh"
+            : fresh === "stale"
+                ? "stale"
+                : fresh === "expired"
+                    ? "EXPIRED"
+                    : "missing";
+        lines.push(` ② PROVIDER MIRROR (auto-fetched from MiniMax console)`);
+        lines.push(`    Last sync:      ${formatRelative(input.mirror.synced_at, input.nowMs)} [${freshnessLabel}]`);
+        lines.push(`    Provider:       ${input.mirror.provider ?? "unknown"}`);
+        // 5h line
+        if (input.mirror.h5_used_pct !== undefined) {
+            const pct = input.mirror.h5_used_pct;
+            const resetStr = input.mirror.h5_resets_at
+                ? formatDuration(Date.parse(input.mirror.h5_resets_at) - input.nowMs)
+                : "unknown";
+            lines.push(`    5h limit:       ${renderProgressBar(pct)} ${renderLeftLabel(pct)} (resets in ${resetStr})`);
+        }
+        else {
+            lines.push(`    5h limit:       (waiting for next auto refresh)`);
+        }
+        // Weekly line
+        if (input.mirror.weekly_used_pct !== undefined) {
+            const pct = input.mirror.weekly_used_pct;
+            const resetStr = input.mirror.weekly_resets_at
+                ? formatDuration(Date.parse(input.mirror.weekly_resets_at) - input.nowMs)
+                : "unknown";
+            lines.push(`    Weekly limit:   ${renderProgressBar(pct)} ${renderLeftLabel(pct)} (resets in ${resetStr})`);
+        }
+        else {
+            lines.push(`    Weekly limit:   (waiting for next auto refresh)`);
+        }
+        lines.push("");
+    }
+    else {
+        lines.push(` ② PROVIDER MIRROR`);
+        lines.push(`    Not synced yet. Auto refresh will populate data from MiniMax console.`);
+        lines.push("");
+    }
+    // --- Local reset times (derived) ------------------------------------
+    lines.push(" ③ LOCAL RESET TIMES (derived from your data)");
+    const local5hReset = computeLocalResetTime(input.local.five_h, FIVE_HOURS_MS);
+    const localWeekReset = computeLocalResetTime(input.local.weekly, SEVEN_DAYS_MS);
+    if (local5hReset) {
+        const remaining = local5hReset - input.nowMs;
+        lines.push(`    Local 5h reset:    in ${formatDuration(remaining)} (oldest request falls out of window)`);
+    }
+    else {
+        lines.push(`    Local 5h reset:    no requests in last 5 hours`);
+    }
+    if (localWeekReset) {
+        const remaining = localWeekReset - input.nowMs;
+        lines.push(`    Local week reset:  in ${formatDuration(remaining)} (oldest request falls out of window)`);
+    }
+    else {
+        lines.push(`    Local week reset:  no requests in last 7 days`);
+    }
+    // --- Local-vs-mirror divergence -------------------------------------
+    if (input.mirror?.h5_used_pct !== undefined) {
+        const localPct = input.localFiveHLimitTokens
+            ? (input.local.five_h.tokens / input.localFiveHLimitTokens) * 100
+            : 0;
+        const delta = localPct - input.mirror.h5_used_pct;
+        const deltaStr = delta >= 0 ? `+${delta.toFixed(1)}%` : `${delta.toFixed(1)}%`;
+        const warning = Math.abs(delta) > 5 ? " ⚠️  divergence > 5%" : "";
+        lines.push(`    Local-vs-mirror:  ${deltaStr}${warning}`);
+    }
+    // --- Burn rate ------------------------------------------------------
+    if (input.mirror?.weekly_used_pct !== undefined &&
+        input.mirror.weekly_resets_at) {
+        const resetMs = Date.parse(input.mirror.weekly_resets_at);
+        const elapsedMs = input.nowMs - resetMs;
+        const elapsedDays = elapsedMs / (24 * 60 * 60 * 1000);
+        if (elapsedDays > 0) {
+            const pctPerDay = input.mirror.weekly_used_pct / elapsedDays;
+            const remaining = 100 - input.mirror.weekly_used_pct;
+            const daysLeft = pctPerDay > 0 ? remaining / pctPerDay : Infinity;
+            const daysLeftStr = daysLeft === Infinity ? "∞" : `${daysLeft.toFixed(1)} d`;
+            lines.push(`    Burn rate:        ${pctPerDay.toFixed(1)}% / day → 100% in ${daysLeftStr}`);
+        }
+    }
+    lines.push(divider);
+    lines.push(` Data dir:    ${process.env.PI_USAGE_DIR ?? "~/.pi/usage-status"}`);
+    lines.push(` Local time:  ${new Date(input.nowMs).toISOString()}`);
+    lines.push("");
+    lines.push(" Run `/usage refresh` to fetch the latest provider mirror now.");
+    return lines.join("\n");
+}

package/status-parsers.js

@@ -0,0 +1,63 @@
+/**
+ * Status Line Parsers
+ *
+ * Keep quota usage data and model context usage separate:
+ * - Quota usage data: h5_used_pct / weekly_used_pct
+ * - Context window usage: 68.4%/205k
+ */
+function parseTokenCount(raw) {
+    const trimmed = raw.trim().replace(/,/g, '');
+    const match = trimmed.match(/^(\d+(?:\.\d+)?)([kKmMbB]?)$/);
+    if (!match)
+        return null;
+    const value = Number.parseFloat(match[1]);
+    if (!Number.isFinite(value))
+        return null;
+    const suffix = match[2].toLowerCase();
+    if (suffix === 'k')
+        return Math.round(value * 1_000);
+    if (suffix === 'm')
+        return Math.round(value * 1_000_000);
+    if (suffix === 'b')
+        return Math.round(value * 1_000_000_000);
+    return Math.round(value);
+}
+/**
+ * Parse a quota usage status line such as `5h: 100% left · week: 26% left`.
+ * Returns the underlying usage fields used by the mirror: `h5_used_pct` and
+ * `weekly_used_pct`.
+ */
+export function parseQuotaUsageStatusLine(value) {
+    const h5Match = value.match(/5h:\s*(\d+(?:\.\d+)?)%\s*left/i);
+    const weeklyMatch = value.match(/week:\s*(\d+(?:\.\d+)?)%\s*left/i);
+    if (!h5Match && !weeklyMatch) {
+        return null;
+    }
+    const h5Left = h5Match ? Number.parseFloat(h5Match[1]) : null;
+    const weeklyLeft = weeklyMatch ? Number.parseFloat(weeklyMatch[1]) : null;
+    return {
+        h5UsedPct: h5Left === null || !Number.isFinite(h5Left) ? null : 100 - h5Left,
+        weeklyUsedPct: weeklyLeft === null || !Number.isFinite(weeklyLeft)
+            ? null
+            : 100 - weeklyLeft,
+    };
+}
+/**
+ * Parse a context-window status line such as `68.4%/205k`.
+ * Returns the usage percentage, total context window, and inferred used tokens.
+ */
+export function parseContextWindowStatusLine(value) {
+    const match = value.match(/(\d+(?:\.\d+)?)%\s*\/\s*([\d,.]+(?:[kKmMbB])?)/);
+    if (!match)
+        return null;
+    const usagePct = Number.parseFloat(match[1]);
+    const contextWindowTokens = parseTokenCount(match[2]);
+    if (!Number.isFinite(usagePct) || contextWindowTokens === null) {
+        return null;
+    }
+    return {
+        usagePct,
+        contextWindowTokens,
+        usedTokens: Math.round((contextWindowTokens * usagePct) / 100),
+    };
+}

package/tracker.js

@@ -0,0 +1,49 @@
+/**
+ * UsageTracker — append-only JSONL log of every assistant message.
+ *
+ * Stores one record per assistant message with: timestamp, model id,
+ * input/output tokens, cache read/write tokens, total cost USD.
+ *
+ * File: ~/.pi/usage-status/usage.jsonl (one JSON object per line)
+ *
+ * No locking — single-process pi uses single-writer. Multi-process safety
+ * is not a goal; SQLite would be needed for that.
+ */
+import { appendJsonl, ensureUsageDir, getUsageLogPath, readJsonl, } from "./cli.ts";
+import { unlinkSync } from "node:fs";
+export class UsageTracker {
+    path;
+    constructor(path = getUsageLogPath()) {
+        this.path = path;
+        ensureUsageDir();
+    }
+    /** Append one usage record. */
+    append(record) {
+        appendJsonl(this.path, record);
+    }
+    /** Read all records (newest last). Returns [] if file missing. */
+    all() {
+        return readJsonl(this.path);
+    }
+    /** Filter records newer than `sinceMs` (inclusive). */
+    since(sinceMs) {
+        return this.all().filter((r) => r.ts >= sinceMs);
+    }
+    /** Filter records within [fromMs, toMs). */
+    between(fromMs, toMs) {
+        return this.all().filter((r) => r.ts >= fromMs && r.ts < toMs);
+    }
+    /** Clear all records (testing only). */
+    clear() {
+        try {
+            unlinkSync(this.path);
+        }
+        catch {
+            // ignore
+        }
+    }
+    /** Total record count. */
+    count() {
+        return this.all().length;
+    }
+}

package/windows.js

@@ -0,0 +1,90 @@
+/**
+ * WindowAggregator — compute rolling 5h + weekly windows from local records.
+ *
+ * We do NOT need provider-reported reset times — we can DERIVE them from our
+ * own data: oldest record in window + window duration = when that record
+ * will fall out of the window = the "reset" moment for OUR local usage.
+ *
+ * For provider-mirror reset times, we just read them from MirrorStore.
+ */
+export const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+export const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+function emptyWindow() {
+    return { tokens: 0, requests: 0, cost: 0, oldest_ts: null };
+}
+function rollUp(records) {
+    const stats = emptyWindow();
+    for (const r of records) {
+        const tokens = r.input + r.output + r.cache_read + r.cache_write;
+        stats.tokens += tokens;
+        stats.requests += 1;
+        stats.cost += r.cost;
+        if (stats.oldest_ts === null || r.ts < stats.oldest_ts) {
+            stats.oldest_ts = r.ts;
+        }
+    }
+    return stats;
+}
+/** Compute reset time for a rolling window from its oldest record. */
+export function computeLocalResetTime(stats, windowMs) {
+    if (stats.oldest_ts === null)
+        return null;
+    return stats.oldest_ts + windowMs;
+}
+/** Filter records within a rolling window. */
+function withinWindow(records, nowMs, windowMs) {
+    const cutoff = nowMs - windowMs;
+    return records.filter((r) => r.ts >= cutoff);
+}
+/** UTC midnight (ms) of the day containing `nowMs`. */
+function utcMidnight(nowMs) {
+    const d = new Date(nowMs);
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+/** Monday 00:00 UTC of the week containing `nowMs`. */
+function weeklyCutoff(nowMs) {
+    const d = new Date(nowMs);
+    const day = d.getUTCDay(); // 0=Sun..6=Sat
+    const diff = (day + 6) % 7; // days since Monday
+    const mondayMidnight = utcMidnight(nowMs) - diff * 86400 * 1000;
+    return mondayMidnight;
+}
+/** Main entry: aggregate all windows from raw records. */
+export function aggregateWindows(records, nowMs = Date.now()) {
+    const five_h = rollUp(withinWindow(records, nowMs, FIVE_HOURS_MS));
+    const weekly = rollUp(withinWindow(records, nowMs, SEVEN_DAYS_MS));
+    const today = rollUp(records.filter((r) => r.ts >= utcMidnight(nowMs)));
+    const lifetime = rollUp(records);
+    return { five_h, weekly, today, lifetime };
+}
+/**
+ * Compute burn rate (% per day) from the weekly mirror.
+ * mirror.weekly_used_pct used, time since weekly reset = nowMs - weekly_resets_at.
+ */
+export function computeBurnRate(mirrorWeeklyUsedPct, weeklyResetsAtMs, nowMs) {
+    const elapsedMs = nowMs - weeklyResetsAtMs;
+    if (elapsedMs <= 0) {
+        return { pct_per_day: 0, days_until_full: null };
+    }
+    const elapsedDays = elapsedMs / (24 * 60 * 60 * 1000);
+    const pctPerDay = mirrorWeeklyUsedPct / elapsedDays;
+    const remainingPct = 100 - mirrorWeeklyUsedPct;
+    if (pctPerDay <= 0) {
+        return { pct_per_day: 0, days_until_full: null };
+    }
+    const daysUntilFull = remainingPct / pctPerDay;
+    return { pct_per_day: pctPerDay, days_until_full: daysUntilFull };
+}
+/**
+ * Compute the divergence between local-tracked usage and provider mirror.
+ * Returns the difference in percentage points (positive = local > mirror).
+ *
+ * This is a rough check: if local tracking shows 5% used but provider
+ * mirror shows 30%, you know other clients (or pre-existing quota) are
+ * using the same provider account.
+ */
+export function computeLocalVsMirrorDelta(localFiveHPct, mirrorFiveHPct) {
+    if (mirrorFiveHPct === undefined)
+        return null;
+    return localFiveHPct - mirrorFiveHPct;
+}