toolroll 0.5.0

package/dist/proposal.d.ts

@@ -0,0 +1,82 @@
+import type { Filer } from "./approval-policy.js";
+export { validateTaskText } from "./task-text.js";
+import type { Store } from "./store.js";
+import { type UnattendedPermissionMode } from "./scope.js";
+import type { QualityMode } from "./quality.js";
+export type ProposalRefusal = {
+    ok: false;
+    /** Stable, machine-readable — joins the envelope like every reason. */
+    reason: "bad-title" | "bad-goal" | "bad-id" | "bad-name" | "bad-terms" | "bad-repo" | "outside-ceiling" | "bad-provenance" | "bad-acceptance" | "acceptance-required" | "backlog-full" | "duplicate";
+    message: string;
+};
+export type TaskProposalInput = {
+    id?: string;
+    title: string;
+    repo?: string;
+    goal?: string;
+    outOfScope?: string | null;
+    touches?: string[];
+    /** v39: the signed acceptance rubric — unparsed, checked by
+     * `store.createConsoleTask` the same way every other filing text is
+     * checked here: identically for every caller of this one door. */
+    acceptance?: unknown;
+    /** Which door filed this: 'cli', 'console', 'intake', 'template:<name>'. */
+    filedVia: string;
+    /** v102: who filed it — the person, or the person a coordinator acts for (separation of duties reads it). */
+    filedBy?: Filer;
+    /** The scope text's author when it is an LLM's (ruling 2; §10 for a
+     * scout's follow-up): mode coverage never seals it. */
+    proposedVia?: "mate" | "coordinator" | "scout";
+    /** What comes back (v34): 'report' files a scout task. Set once, at filing. */
+    deliverable?: "branch" | "report";
+    /** Planning policy at the filing door. `required` is an explicit
+     * operator choice, `skip` is an explicit direct-to-scope choice, and
+     * `auto` (the default) plans implementation work whose breadth suggests
+     * repository discovery will materially improve the approved scope. */
+    planning?: "auto" | "required" | "skip";
+    /** Concrete per-task unattended permission choice. When absent, the
+     * installation default is resolved as the scope is filed. */
+    permissionMode?: UnattendedPermissionMode;
+    /** Concrete per-task evidence depth. Absent inherits the installation
+     * default when the scope is filed. */
+    qualityMode?: QualityMode;
+    /**
+     * The caller's ceiling as canonical repo paths. undefined = the caller
+     * genuinely has none (the CLI on the operator's own machine). A surface
+     * that HAS a ceiling must pass it — an empty list refuses every repo,
+     * which is the fail-closed reading of an empty ceiling (finding 4).
+     */
+    admittedRepos?: readonly string[];
+};
+/** One deterministic planning policy for console, chat, MCP, and sync
+ * filings. A planner needs a repository to inspect; report/scout work is
+ * already the discovery phase and never recursively plans itself. */
+export declare function shouldPlanTask(input: TaskProposalInput): boolean;
+export type RoutineProposalInput = {
+    name: string;
+    /** v102: who is making it (its instances are filed as theirs). */
+    createdBy?: string | null;
+    repo: string;
+    goal: string;
+    outOfScope: string | null;
+    touches: string[];
+    /** v39: the signed rubric every instance's scope copies forward. */
+    acceptance: unknown;
+    requirements: string[];
+    schedule: string;
+    costCeilingUsd: number | null;
+    /** Per-instance dollar cap in micro-USD (v16); optional, digest-bound. */
+    budgetPerRunMicrousd?: number | null;
+    filedVia: string;
+    admittedRepos?: readonly string[];
+};
+export declare function fileTaskProposal(store: Store, input: TaskProposalInput, now: Date): {
+    ok: true;
+    id: string;
+    planning: boolean;
+} | ProposalRefusal;
+export declare function fileRoutineProposal(store: Store, input: RoutineProposalInput, now: Date): {
+    ok: true;
+    id: number;
+    digest: string;
+} | ProposalRefusal;

package/dist/proposal.js

@@ -0,0 +1,210 @@
+import { validateTaskText } from "./task-text.js";
+export { validateTaskText } from "./task-text.js";
+/**
+ * The one door work enters through (Codex adoption review, finding 7).
+ *
+ * Before this module, each filing surface — CLI, console, intake — validated
+ * what it happened to think of: createConsoleTask checked title and goal but
+ * not disguised text, the routine command checked terms but nothing checked a
+ * repo against the caller's ceiling, and nothing stamped who filed what. The
+ * review's ruling: one canonical service that every filer calls, with an
+ * exact field allowlist, so a careless caller CANNOT spread a template or
+ * model object into scope rows and smuggle approval metadata.
+ *
+ * The contract, in order:
+ *   - every text field is validated here, identically for every caller:
+ *     length bounds, control characters, and DISGUISED text (invisibles,
+ *     bidi overrides) on the fields an approver reads;
+ *   - the repo is canonicalized, and when the caller has a ceiling the
+ *     canonical repo must be inside it — an absent ceiling is the CLI's
+ *     honest "no ceiling", never a wildcard for surfaces that have one;
+ *   - approval fields are hardcoded null by the store methods this calls;
+ *     nothing a caller passes can reach them (exact allowlist, no spread);
+ *   - the digest is computed HERE, never accepted from the caller;
+ *   - provenance (filedVia) is stamped in the same transaction and is
+ *     immutable — there is no API to change it, anywhere.
+ *
+ * Filing carries NO authority. Everything this module creates is unapproved
+ * and stays inert until the operator's own ceremony says otherwise.
+ */
+import { resolveRoutineAuthority } from "./agentconfig.js";
+import { resolve } from "node:path";
+import { hasForbiddenControls, hasDisguisedText } from "./decision.js";
+import { canonicalProject } from "./project.js";
+import { ROUTINE_NAME, routineDigestOf, validateRoutineTerms, } from "./routine.js";
+import { parseAcceptanceCriteria } from "./scope.js";
+/** Provenance tokens are part of the audit surface: lowercase, bounded,
+ * nothing that could render as anything but itself. */
+const FILED_VIA = /^[a-z][a-z0-9:-]{0,63}$/;
+const SUBSTANTIAL_WORK = /\b(?:architecture|end[- ]to[- ]end|migrat(?:e|ion)|moderni[sz]e|redesign|refactor|rework|workflow|navigation|accessibility|responsive|performance|security|unif(?:y|ied)|multi[- ](?:step|project|service))\b/i;
+/** One deterministic planning policy for console, chat, MCP, and sync
+ * filings. A planner needs a repository to inspect; report/scout work is
+ * already the discovery phase and never recursively plans itself. */
+export function shouldPlanTask(input) {
+    if (input.deliverable === "report" || input.planning === "skip")
+        return false;
+    // Remote coordinators only propose work. Keep their submissions quarantined
+    // until an operator has restated the scope; automatic planning must not turn
+    // an untrusted MCP filing into executable workflow state.
+    if (input.proposedVia === "coordinator" || input.filedVia?.startsWith("mcp:"))
+        return false;
+    if (input.repo === undefined || input.repo.trim() === "")
+        return false;
+    if (input.planning === "required")
+        return true;
+    const goal = input.goal ?? "";
+    const descriptionSize = input.title.length + goal.length + (input.outOfScope?.length ?? 0);
+    return ((input.touches?.length ?? 0) >= 2 ||
+        descriptionSize >= 280 ||
+        SUBSTANTIAL_WORK.test(`${input.title}\n${goal}`));
+}
+function refuse(reason, message) {
+    return { ok: false, reason, message };
+}
+/** The fields an approver reads must BE what they appear to be: no control
+ * characters anywhere, no invisible or direction-override text either. */
+function dishonest(text) {
+    return hasForbiddenControls(text) || hasDisguisedText(text);
+}
+/** Byte caps beside the character caps (Codex v3 review, change 8): a
+ * 2000-character goal of astral-plane text is 8000 bytes — model-authored
+ * fields must bound STORAGE, not just what a screen shows. */
+const BYTE_CAPS = { title: 800, name: 200, text: 8_000, path: 800, requirement: 400 };
+function overBytes(text, cap) {
+    return Buffer.byteLength(text, "utf8") > cap;
+}
+function checkRepo(given, admitted) {
+    if (given === undefined || given === "") {
+        // A ceiling names the ONLY repos this surface may file into. Filing
+        // repo-less under a ceiling would bypass it wholesale (MCP spec v2,
+        // Codex round 2 finding 2) — a bounded surface must say where.
+        if (admitted !== undefined) {
+            return refuse("outside-ceiling", "this surface must name a repository — it is limited to specific ones");
+        }
+        return { ok: true, repo: undefined };
+    }
+    // Best-effort canonicalization, the codebase's one convention: a real
+    // directory resolves through symlinks; a path that does not exist yet
+    // still normalizes, because filing must not depend on this machine
+    // seeing every repo the plane knows about.
+    const canonical = canonicalProject(given) ?? resolve(given);
+    if (admitted !== undefined && !admitted.includes(canonical)) {
+        return refuse("outside-ceiling", "that repository is outside what this surface was configured to show");
+    }
+    return { ok: true, repo: canonical };
+}
+export function fileTaskProposal(store, input, now) {
+    if (!FILED_VIA.test(input.filedVia)) {
+        return refuse("bad-provenance", "filedVia is an audit token: lowercase letters, digits, dashes, colons");
+    }
+    const badText = validateTaskText(input);
+    if (badText !== null)
+        return badText;
+    const outOfScope = input.outOfScope ?? null;
+    const touches = input.touches ?? [];
+    const repo = checkRepo(input.repo, input.admittedRepos);
+    if (!repo.ok)
+        return repo;
+    // Exact allowlist — built field by field, never spread from the input.
+    const made = store.createConsoleTask({
+        ...(input.id === undefined ? {} : { id: input.id }),
+        title: input.title,
+        ...(repo.repo === undefined ? {} : { repo: repo.repo }),
+        ...(input.goal === undefined ? {} : { goal: input.goal }),
+        ...(input.permissionMode === undefined ? {} : { permissionMode: input.permissionMode }),
+        ...(input.qualityMode === undefined ? {} : { qualityMode: input.qualityMode }),
+        outOfScope,
+        touches,
+        acceptance: input.acceptance,
+        filedVia: input.filedVia,
+        ...(input.filedBy === undefined ? {} : { filedBy: input.filedBy }),
+        proposedVia: input.proposedVia ?? null,
+        ...(input.deliverable === undefined ? {} : { deliverable: input.deliverable }),
+    }, now);
+    if (!made.ok) {
+        return refuse(made.reason, made.reason === "backlog-full"
+            ? "the backlog is full — finish or cancel something first"
+            : made.reason === "duplicate"
+                ? "a task with that id already exists"
+                : made.reason === "acceptance-required"
+                    ? "a goal needs at least one signed acceptance criterion before it can be filed"
+                    : `the store refused the filing: ${made.reason}`);
+    }
+    let planning = false;
+    if (shouldPlanTask({ ...input, ...(repo.repo === undefined ? {} : { repo: repo.repo }) })) {
+        const ref = store.lookupRef(made.id);
+        if (ref !== null)
+            planning = store.requestPlan(ref.id, now).ok;
+    }
+    return { ok: true, id: made.id, planning };
+}
+export function fileRoutineProposal(store, input, now) {
+    if (!FILED_VIA.test(input.filedVia)) {
+        return refuse("bad-provenance", "filedVia is an audit token: lowercase letters, digits, dashes, colons");
+    }
+    const repo = checkRepo(input.repo, input.admittedRepos);
+    if (!repo.ok)
+        return repo;
+    if (repo.repo === undefined)
+        return refuse("bad-repo", "a routine needs the repository it runs in");
+    const acceptanceParse = parseAcceptanceCriteria(input.acceptance);
+    const terms = {
+        repo: repo.repo,
+        goal: input.goal,
+        outOfScope: input.outOfScope,
+        touches: input.touches,
+        acceptance: acceptanceParse.criteria,
+        requirements: input.requirements,
+        schedule: input.schedule,
+        // v1 routines run one instance at a time, period — hardcoded, not accepted.
+        singleFlight: true,
+        costCeilingUsd: input.costCeilingUsd,
+        ...(input.budgetPerRunMicrousd == null ? {} : { budgetPerRunMicrousd: input.budgetPerRunMicrousd }),
+    };
+    // EVERY problem at once — an operator fixing a form deserves the whole
+    // list, not one complaint per submission.
+    const problems = validateRoutineTerms(terms);
+    if (acceptanceParse.problems.length > 0) {
+        problems.push({ field: "acceptance", problem: acceptanceParse.problems.map(p => p.message).join("; ") });
+    }
+    if (!ROUTINE_NAME.test(input.name)) {
+        problems.unshift({ field: "name", problem: "lowercase letters, digits, and dashes — it becomes each instance's id" });
+    }
+    if (dishonest(input.goal) ||
+        overBytes(input.goal, BYTE_CAPS.text) ||
+        (input.outOfScope !== null && (dishonest(input.outOfScope) || overBytes(input.outOfScope, BYTE_CAPS.text)))) {
+        problems.push({ field: "goal", problem: "no control or disguised text, bounded bytes" });
+    }
+    // The v3 review, change 8: touches and requirements are approver-read
+    // text too — the door holds them to the same honesty everywhere.
+    if (input.touches.some(one => dishonest(one) || overBytes(one, BYTE_CAPS.path))) {
+        problems.push({ field: "touches", problem: "no control or disguised text, bounded bytes" });
+    }
+    if (input.requirements.some(one => dishonest(one) || overBytes(one, BYTE_CAPS.requirement))) {
+        problems.push({ field: "requirements", problem: "no control or disguised text, bounded bytes" });
+    }
+    if (problems.length > 0) {
+        const named = problems.map(one => `${one.field}: ${one.problem}`).join("; ");
+        return refuse(problems.some(one => one.field === "name") ? "bad-name" : "bad-terms", named);
+    }
+    // v24 filing invariant, routine flavor — since v48 the whole four-role
+    // ROUTE: resolve which agents plan, build, repair, and review a firing
+    // once, here, from the configuration of this moment, and bind route and
+    // profile into the digest a person will sign. Unresolved saves too
+    // (finding 19) — approval then refuses until the routine is restated.
+    const authority = resolveRoutineAuthority(store, repo.repo, terms.acceptance, now);
+    const routineProfile = authority.ok ? authority.profile : null;
+    const routineRoute = authority.ok ? authority.route : null;
+    const created = store.createRoutine({
+        name: input.name,
+        ...terms,
+        digest: routineDigestOf(terms, routineProfile, routineRoute),
+        filedVia: input.filedVia,
+        createdBy: input.createdBy ?? null,
+        ...(routineProfile === null ? {} : { profile: routineProfile }),
+        ...(routineRoute === null ? {} : { route: routineRoute }),
+    }, now);
+    if (!created.ok)
+        return refuse("duplicate", `a routine named ${input.name} already exists`);
+    return { ok: true, id: created.id, digest: routineDigestOf(terms, routineProfile, routineRoute) };
+}

package/dist/provider-connection.d.ts

@@ -0,0 +1,22 @@
+import { run, type ExecResult } from "./exec.js";
+import { type ProviderId } from "./provider.js";
+import { type AuthMode, type KeyVerdict } from "./keys.js";
+export type ProviderConnection = {
+    state: "connected" | "signed-out" | "not-installed" | "unverified" | "key-present" | "key-works" | "key-refused" | "missing-key";
+    /** A saved key that was just tested: what the provider said. */
+    verdict?: KeyVerdict;
+    mode: AuthMode;
+    email?: string;
+    plan?: string;
+    method?: string;
+    checkedAt: string;
+};
+export type ConnectionChecker = (provider: ProviderId, fresh?: boolean) => Promise<ProviderConnection>;
+export declare function signInFacts(provider: ProviderId, result: ExecResult, now?: Date): ProviderConnection;
+export declare function createConnectionChecker(options?: {
+    probe?: typeof run;
+    home?: string;
+    clock?: () => Date;
+    env?: NodeJS.ProcessEnv;
+    verify?: (provider: ProviderId, key: string) => Promise<KeyVerdict>;
+}): ConnectionChecker;

package/dist/provider-connection.js

@@ -0,0 +1,98 @@
+/** Non-spending account checks. Only normalized facts leave this module. */
+import { homedir } from "node:os";
+import { run } from "./exec.js";
+import { ALL_CREDENTIAL_ENV, inspectionOf } from "./provider.js";
+import { keyStatus, PROVIDER_KEY_ENV, readAuthMode, readProviderKey, verifyProviderKey } from "./keys.js";
+export function signInFacts(provider, result, now = new Date()) {
+    const base = { mode: "subscription", checkedAt: now.toISOString() };
+    if (result.notFound)
+        return { ...base, state: "not-installed" };
+    if (result.timedOut)
+        return { ...base, state: "unverified" };
+    if (provider === "claude") {
+        try {
+            const value = JSON.parse(result.stdout);
+            if (value?.loggedIn === false && (result.code === 0 || result.code === 1))
+                return { ...base, state: "signed-out" };
+            if (value?.loggedIn !== true || result.code !== 0)
+                return { ...base, state: "unverified" };
+            const email = typeof value.email === "string" && value.email.length <= 254 && /^[\x21-\x7e]+$/.test(value.email) && /^[^\s@<>\x00-\x1f\x7f]+@[^\s@<>\x00-\x1f\x7f]+\.[^\s@<>\x00-\x1f\x7f]+$/.test(value.email) ? value.email : undefined;
+            const plans = { max: "Max", pro: "Pro", team: "Team", enterprise: "Enterprise" };
+            const methods = { "claude.ai": "Claude account", api_key: "API key", bedrock: "Amazon Bedrock", vertex: "Google Vertex AI" };
+            const plan = typeof value.subscriptionType === "string" && Object.hasOwn(plans, value.subscriptionType) ? plans[value.subscriptionType] : undefined;
+            const method = typeof value.authMethod === "string" && Object.hasOwn(methods, value.authMethod) ? methods[value.authMethod] : undefined;
+            return { ...base, state: value.authMethod === "claude.ai" ? "connected" : "unverified", ...(email ? { email } : {}), ...(plan ? { plan } : {}), ...(method ? { method } : {}) };
+        }
+        catch {
+            return { ...base, state: "unverified" };
+        }
+    }
+    if (provider === "codex") {
+        const text = `${result.stdout}\n${result.stderr}`;
+        if (result.code === 0 && /^Logged in using ChatGPT\s*$/m.test(text))
+            return { ...base, state: "connected", method: "ChatGPT account" };
+        if (result.code === 0 && /^Logged in using an? API key\b/m.test(text))
+            return { ...base, state: "unverified", method: "API key; subscription sign-in is not verified" };
+        if (result.code === 1 && /^Not logged in\s*$/m.test(text))
+            return { ...base, state: "signed-out" };
+    }
+    return { ...base, state: "unverified" };
+}
+export function createConnectionChecker(options = {}) {
+    const probe = options.probe ?? run;
+    const verify = options.verify ?? ((provider, key) => verifyProviderKey(provider, key));
+    const home = options.home ?? homedir();
+    const clock = options.clock ?? (() => new Date());
+    const cache = new Map();
+    const pending = new Map();
+    return async (provider, fresh = false) => {
+        const mode = readAuthMode(provider, home);
+        const keyFacts = keyStatus(provider, home);
+        const ambient = !!(options.env ?? process.env)[PROVIDER_KEY_ENV[provider]];
+        const key = JSON.stringify([provider, mode, keyFacts.set, keyFacts.updatedAt, ambient]);
+        const now = clock();
+        const existing = cache.get(provider);
+        if (!fresh && existing?.key === key && existing.until > now.getTime())
+            return existing.value;
+        const inFlight = pending.get(key);
+        if (inFlight)
+            return inFlight;
+        const check = (async () => {
+            if (mode === "api-key") {
+                // A saved key is tested only when asked (Check again, or just after it is saved): one small request to the provider, never a model.
+                const stored = fresh && keyFacts.set ? readProviderKey(provider, home) : null;
+                if (stored === null)
+                    return { state: keyFacts.set || ambient ? "key-present" : "missing-key", mode, checkedAt: now.toISOString() };
+                const verdict = await verify(provider, stored);
+                return { state: verdict.ok ? "key-works" : verdict.reason === "rejected" ? "key-refused" : "key-present", mode, checkedAt: clock().toISOString(), verdict };
+            }
+            const facts = inspectionOf(provider);
+            const identityProbe = provider === "claude" ? ["auth", "status", "--json"] : facts.identityProbe;
+            if (identityProbe === null)
+                return { state: "unverified", mode, checkedAt: now.toISOString() };
+            try {
+                // Same subscription credential stripping as provider invocations.
+                // No model prompt, repository scripts, or stored API keys are used.
+                const result = await probe(facts.binary, [...identityProbe], { cwd: home, timeoutMs: 5000, maxBuffer: 32 * 1024, omitEnv: ALL_CREDENTIAL_ENV });
+                return signInFacts(provider, result, clock());
+            }
+            catch {
+                return { state: "unverified", mode, checkedAt: clock().toISOString() };
+            }
+        })();
+        pending.set(key, check);
+        try {
+            const value = await check;
+            // Only cache against the same credential mode that began this check.
+            // A slow subscription probe must not overwrite a newer API-key result.
+            const currentKeyFacts = keyStatus(provider, home);
+            const currentKey = JSON.stringify([provider, readAuthMode(provider, home), currentKeyFacts.set, currentKeyFacts.updatedAt, !!(options.env ?? process.env)[PROVIDER_KEY_ENV[provider]]]);
+            if (currentKey === key)
+                cache.set(provider, { key, until: value.verdict !== undefined ? Number.POSITIVE_INFINITY : clock().getTime() + 30_000, value });
+            return value;
+        }
+        finally {
+            pending.delete(key);
+        }
+    };
+}

package/dist/provider-limits.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Subscription limits (v105): how much of each plan's usage windows is used,
+ * as the provider itself says. A subscription costs nothing per run, so these
+ * windows (not dollars) are what bind it. Claude says on every turn (a
+ * `rate_limit_event` in its stream: the 5-hour and weekly windows); Codex
+ * answers when asked (its app server's `account/rateLimits/read`, which spends
+ * nothing). The latest reading of each window is kept; the Tasks page shows
+ * them beside the monthly budgets.
+ */
+import type { Billing } from "./spend.js";
+export type LimitWindow = {
+    window: string;
+    usedPercent: number;
+    windowMinutes: number | null;
+    resetsAt: string | null;
+    reached: boolean;
+};
+/** A provider's reading: its windows (all of them, or `partial` when it named only one), and how it was seen billing. */
+export type LimitReading = {
+    provider: "claude" | "codex";
+    plan: string | null;
+    windows: LimitWindow[];
+    partial?: boolean;
+    billing?: Billing;
+};
+export declare const record: (value: unknown) => Record<string, unknown> | null;
+/** A Claude stream event's limits, or null when it isn't a `rate_limit_event` or says nothing usable. */
+export declare function claudeLimitsOf(event: unknown): LimitReading | null;
+/** Codex's `account/rateLimits/read` answer as a reading, or null. */
+export declare function codexLimitsOf(result: unknown): LimitReading | null;
+export declare function pushLimitSink(next: (reading: LimitReading) => void): () => void;
+/** A reading from a stream; never throws into the run that carried it. */
+export declare function noteLimits(reading: LimitReading | null): void;
+/** A window in words: "5-hour", "Weekly", "Weekly (Opus)". */
+export declare function windowLabel(window: string, minutes: number | null): string;

package/dist/provider-limits.js

@@ -0,0 +1,95 @@
+const WINDOW_NAME = /^[a-z][a-z0-9_]{0,39}$/;
+const CLAUDE_MINUTES = { five_hour: 300, seven_day: 10_080, seven_day_opus: 10_080, seven_day_sonnet: 10_080 };
+const finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+const percent = (value) => Math.max(0, Math.min(100, Math.round(value * 10) / 10));
+/** An epoch (seconds) as an ISO time, or null when it isn't a plausible one. */
+const epoch = (value) => {
+    const seconds = finite(value);
+    return seconds === null || seconds < 1_000_000_000 || seconds > 10_000_000_000 ? null : new Date(seconds * 1000).toISOString();
+};
+export const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+/** A Claude stream event's limits, or null when it isn't a `rate_limit_event` or says nothing usable. */
+export function claudeLimitsOf(event) {
+    const body = record(event);
+    if (body === null || body["type"] !== "rate_limit_event")
+        return null;
+    const info = record(body["rate_limit_info"]);
+    if (info === null)
+        return null;
+    const rejected = info["status"] === "rejected";
+    const current = typeof info["rateLimitType"] === "string" ? info["rateLimitType"] : null;
+    const windows = [];
+    const unified = record(info["unifiedWindows"]);
+    for (const [name, raw] of Object.entries(unified ?? {}).slice(0, 8)) {
+        const one = record(raw);
+        const used = finite(one?.["utilization"]);
+        if (!WINDOW_NAME.test(name) || one === null || used === null)
+            continue;
+        windows.push({ window: name, usedPercent: percent(used * 100), windowMinutes: Object.hasOwn(CLAUDE_MINUTES, name) ? CLAUDE_MINUTES[name] : null, resetsAt: epoch(one["resetsAt"]), reached: rejected && name === current });
+    }
+    if (windows.length === 0 && current !== null && WINDOW_NAME.test(current)) {
+        // An older CLI names only the window it's in; its use is known only when it's spent.
+        const used = finite(info["utilization"]);
+        if (used !== null || rejected)
+            windows.push({ window: current, usedPercent: rejected ? 100 : percent(used * 100), windowMinutes: Object.hasOwn(CLAUDE_MINUTES, current) ? CLAUDE_MINUTES[current] : null, resetsAt: epoch(info["resetsAt"]), reached: rejected });
+        // Only this window is known: the others keep their last reading.
+        return windows.length === 0 ? null : { provider: "claude", plan: null, windows, partial: true, billing: "subscription" };
+    }
+    // A plan's windows are a plan's: this turn ran on the sign-in.
+    return windows.length === 0 ? null : { provider: "claude", plan: null, windows, billing: "subscription" };
+}
+/** Codex's `account/rateLimits/read` answer as a reading, or null. */
+export function codexLimitsOf(result) {
+    const limits = record(record(result)?.["rateLimits"]);
+    if (limits === null)
+        return null;
+    // Codex names why it stopped ("rate_limit_reached", "…usage_limit_reached"), not which window: the fullest one.
+    const reachedType = typeof limits["rateLimitReachedType"] === "string" ? limits["rateLimitReachedType"] : null;
+    const windows = [];
+    for (const slot of ["primary", "secondary"]) {
+        const one = record(limits[slot]);
+        const used = finite(one?.["usedPercent"]);
+        if (one === null || used === null)
+            continue;
+        const minutes = finite(one["windowDurationMins"]);
+        const name = minutes === 300 ? "five_hour" : minutes === 10_080 ? "seven_day" : minutes !== null && minutes > 0 ? `window_${Math.round(minutes)}m` : slot;
+        windows.push({ window: name, usedPercent: percent(used), windowMinutes: minutes === null ? null : Math.round(minutes), resetsAt: epoch(one["resetsAt"]), reached: used >= 100 });
+    }
+    if (reachedType !== null && windows.length > 0)
+        windows.reduce((fullest, one) => one.usedPercent > fullest.usedPercent ? one : fullest).reached = true;
+    const plan = typeof limits["planType"] === "string" && /^[a-z0-9_-]{1,40}$/i.test(limits["planType"]) ? limits["planType"] : null;
+    return windows.length === 0 ? null : { provider: "codex", plan, windows };
+}
+/** Where readings go: the store, in any process that runs Claude. The latest one set wins; one that's done removes
+ * only itself, so a command that ends inside a longer one leaves the longer one's in place. Unset, readings drop. */
+const sinks = [];
+export function pushLimitSink(next) {
+    sinks.push(next);
+    return () => { const at = sinks.lastIndexOf(next); if (at !== -1)
+        sinks.splice(at, 1); };
+}
+/** A reading from a stream; never throws into the run that carried it. */
+export function noteLimits(reading) {
+    const sink = sinks[sinks.length - 1];
+    if (reading === null || sink === undefined)
+        return;
+    try {
+        sink(reading);
+    }
+    catch {
+        // A reading that can't be kept must not touch the turn.
+    }
+}
+/** A window in words: "5-hour", "Weekly", "Weekly (Opus)". */
+export function windowLabel(window, minutes) {
+    if (window === "five_hour")
+        return "5-hour";
+    if (window === "seven_day")
+        return "Weekly";
+    const model = /^seven_day_([a-z]+)$/.exec(window);
+    if (model !== null)
+        return `Weekly (${model[1].charAt(0).toUpperCase()}${model[1].slice(1)})`;
+    if (minutes !== null)
+        return minutes % 1440 === 0 ? `${minutes / 1440}-day` : minutes % 60 === 0 ? `${minutes / 60}-hour` : `${minutes}-minute`;
+    return window.replace(/_/g, " ");
+}