@wjarka/cezarion 0.10.0-pr30.54

package/dist/core/tool-display.js

@@ -0,0 +1,179 @@
+/**
+ * Tool display model — turns a backend tool name + raw input into the
+ * `{toolKind, title, subtitle?}` a tool card renders. Computed ONCE here in
+ * the protocol layer (paseo's pattern), never in components, so the thread,
+ * activity groups and notifications all say the same thing.
+ *
+ * Pure function over untrusted input: tool inputs come off the wire and may
+ * be null, partial (streamed incrementally) or arbitrarily malformed —
+ * `toolDisplay` must never throw.
+ *
+ * Known names covered (matched case-insensitively so claude's `Bash` and
+ * opencode's `bash` share one row):
+ *  - claude:   Bash, Edit, Write, NotebookEdit, Read, Glob, Grep, WebFetch,
+ *              WebSearch, Task, Agent, Skill, TodoWrite, TaskCreate,
+ *              TaskUpdate, TaskList, mcp__server__tool
+ *  - codex:    commandExecution, contextCompaction, fileChange, imageView,
+ *              mcpToolCall, webSearch, plan
+ *              (codex's checklist arrives as the `turn/plan/updated`
+ *              notification, not as a tool call — `todoList` is kept below only
+ *              as tolerance for its non-app-server transports)
+ *  - opencode: bash, edit, write, read, grep, glob, webfetch, task, todowrite
+ */
+/** Longest title/subtitle we emit — display truncation belongs here, not in
+ *  every component that renders a tool line. */
+const MAX_LABEL = 120;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Collapse whitespace (multi-line commands become one line) and cap length. */
+function oneLine(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length > MAX_LABEL ? `${collapsed.slice(0, MAX_LABEL - 1)}…` : collapsed;
+}
+/** First non-empty string among `input[keys...]`, normalized for display. */
+function field(input, ...keys) {
+    if (!isRecord(input))
+        return undefined;
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === 'string' && value.trim() !== '')
+            return oneLine(value);
+    }
+    return undefined;
+}
+/** claude Bash carries `command: string`; codex commandExecution may carry
+ *  a string or an argv array — join the string members. */
+function commandText(input) {
+    if (!isRecord(input))
+        return undefined;
+    const command = input.command;
+    if (typeof command === 'string' && command.trim() !== '')
+        return oneLine(command);
+    if (Array.isArray(command)) {
+        const argv = command.filter((part) => typeof part === 'string');
+        if (argv.length > 0)
+            return oneLine(argv.join(' '));
+    }
+    return undefined;
+}
+/** File paths listed by a codex `fileChange` item (`changes: [{path}]`). */
+function changePaths(input) {
+    if (!isRecord(input) || !Array.isArray(input.changes))
+        return [];
+    const paths = [];
+    for (const change of input.changes) {
+        if (isRecord(change) && typeof change.path === 'string' && change.path.trim() !== '') {
+            paths.push(change.path);
+        }
+    }
+    return paths;
+}
+/** The opencode research heuristic for unknown tools: the first plausible
+ *  human label in the input, in a fixed priority order. */
+function heuristicLabel(input) {
+    return field(input, 'description', 'query', 'url', 'filePath', 'file_path', 'path', 'pattern', 'name');
+}
+/** Verb + optional object → "Read src/a.ts", or just the verb when the
+ *  input gave us nothing usable. */
+function titled(verb, label) {
+    return label ? `${verb} ${label}` : verb;
+}
+export function toolDisplay(name, input) {
+    const key = typeof name === 'string' ? name.toLowerCase() : '';
+    switch (key) {
+        case 'bash':
+        case 'commandexecution':
+            return {
+                toolKind: 'execute',
+                title: titled('Ran', commandText(input)),
+                subtitle: field(input, 'description'),
+            };
+        case 'edit':
+        case 'multiedit':
+            return { toolKind: 'edit', title: titled('Edit', field(input, 'file_path', 'filePath', 'path')) };
+        case 'write':
+            return { toolKind: 'edit', title: titled('Write', field(input, 'file_path', 'filePath', 'path')) };
+        case 'notebookedit':
+            return {
+                toolKind: 'edit',
+                title: titled('Edit', field(input, 'notebook_path', 'notebookPath', 'file_path', 'filePath', 'path')),
+            };
+        case 'filechange': {
+            const paths = changePaths(input);
+            const label = paths.length === 1 ? paths[0] : paths.length > 1 ? `${paths.length} files` : undefined;
+            return { toolKind: 'edit', title: titled('Edit', label) };
+        }
+        case 'read':
+            return { toolKind: 'read', title: titled('Read', field(input, 'file_path', 'filePath', 'path')) };
+        case 'imageview':
+            return { toolKind: 'read', title: titled('View image', field(input, 'path')) };
+        case 'glob':
+        case 'grep':
+            return {
+                toolKind: 'search',
+                title: titled('Search', field(input, 'pattern', 'query')),
+                subtitle: field(input, 'path'),
+            };
+        case 'webfetch':
+            return { toolKind: 'fetch', title: titled('Fetch', field(input, 'url')) };
+        case 'websearch':
+            return { toolKind: 'fetch', title: titled('Web search', field(input, 'query')) };
+        // Sub-agent spawns. claude dispatches these through `Agent` today and
+        // `Task` historically (opencode uses `task`) — both spellings resolve, and
+        // the row says which agent, falling back to the subagent type when the
+        // call carried no description.
+        case 'task':
+        case 'agent': {
+            const verb = key === 'agent' ? 'Agent' : 'Task';
+            const subagent = field(input, 'subagent_type', 'subagentType');
+            const label = field(input, 'description', 'prompt') ?? subagent;
+            return {
+                toolKind: 'task',
+                title: label ? `${verb}: ${label}` : verb,
+                // Don't repeat the subagent type when it is already the title.
+                subtitle: label === subagent ? undefined : subagent,
+            };
+        }
+        // claude's `Skill` invocation: `{skill, args?}` — the skill name is the
+        // whole point of the row, so it goes in the title.
+        case 'skill': {
+            const skill = field(input, 'skill', 'name', 'command');
+            return {
+                toolKind: 'task',
+                title: skill ? `Skill: ${skill}` : 'Skill',
+                subtitle: field(input, 'args', 'description'),
+            };
+        }
+        case 'todowrite':
+        case 'todolist':
+        case 'plan':
+        case 'taskcreate':
+        case 'taskupdate':
+        case 'tasklist':
+            return { toolKind: 'plan', title: 'Update plan' };
+        case 'contextcompaction':
+            return { toolKind: 'other', title: 'Compacted context' };
+        case 'mcptoolcall': {
+            const server = field(input, 'server');
+            const tool = field(input, 'tool');
+            if (server && tool)
+                return { toolKind: 'other', title: `${server}.${tool}` };
+            return { toolKind: 'other', title: 'MCP tool', subtitle: heuristicLabel(input) };
+        }
+    }
+    // claude/opencode MCP tools are named `mcp__server__tool` → "server.tool".
+    if (key.startsWith('mcp__')) {
+        const parts = name.split('__').filter((part) => part !== '');
+        if (parts.length >= 3) {
+            return { toolKind: 'other', title: `${parts[1]}.${parts.slice(2).join('__')}` };
+        }
+    }
+    // Unknown tool: keep the backend's name as the title, heuristic subtitle.
+    return {
+        toolKind: 'other',
+        title: typeof name === 'string' && name.trim() !== '' ? oneLine(name) : 'Tool',
+        subtitle: heuristicLabel(input),
+    };
+}
+//# sourceMappingURL=tool-display.js.map

package/dist/core/tool-display.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-display.js","sourceRoot":"","sources":["../../src/core/tool-display.ts"],"names":[],"mappings":"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"}

package/dist/core/ui-events.d.ts

@@ -0,0 +1,335 @@
+/**
+ * Normalized agent-event protocol v2 — the shared vocabulary every runner
+ * emits ALONGSIDE the v1 `AgentEvent` stream (never replacing it; mixed
+ * NDJSON files stay valid — old recordings must keep replaying).
+ *
+ * Contract sources (authoritative, in this order):
+ *  - `.ai/analysis/cockpit-ui-redesign/agent-event-protocols.md` §7 (schema)
+ *    and §7.1 (per-backend mapping tables);
+ *  - the spec `.ai/specs/2026-07-14-cockpit-ui-redesign.md`
+ *    §"Normalized agent-event protocol v2".
+ *
+ * Design rules baked in:
+ *  1. Item-lifecycle model (Codex/ACP style): one stable `id` per item with
+ *     started/delta/updated/completed phases — two of the three backends are
+ *     natively item-shaped and claude maps trivially.
+ *  2. ACP vocabulary wherever a choice is arbitrary (tool status/kind, plan
+ *     entries, diff shape, stop reasons) for ecosystem alignment.
+ *  3. Every v1 `AgentEvent` stays derivable from this stream, so consumers
+ *     can migrate one panel at a time.
+ *
+ * This module is pure vocabulary: no runtime imports, no runner coupling.
+ * Mirrored into `packages/api-client/src/protocol/`.
+ */
+/** The backend that produced a session — mirrors `RunnerId` in
+ *  `agent-runner.ts` (kept structurally identical; a type-level test
+ *  guards against drift so this module stays dependency-free). */
+export type UiBackend = 'claude' | 'codex' | 'opencode' | 'pi';
+/**
+ * Tool lifecycle status (ACP: pending/in_progress/completed/failed).
+ * `running` ≡ ACP `in_progress` (opencode's word — reads better in code);
+ * `declined` covers codex approval declines and claude `permission_denials`.
+ *
+ * Per backend: claude has no pending phase (`tool_use` arrives already
+ * running); codex maps `inProgress→running`, `completed/failed/declined`
+ * verbatim; opencode maps `pending/running` verbatim and `error→failed`.
+ */
+export type ToolStatus = 'pending' | 'running' | 'completed' | 'failed' | 'declined';
+/**
+ * Icon/verb hint for a tool item — a superset of ACP's ToolKind.
+ * `task` = subagent spawn (claude Task / opencode subtask / codex review).
+ */
+export type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'task' | 'plan' | 'other';
+/**
+ * Why a turn (or the session) stopped.
+ *
+ * Per backend: claude `result` subtype success→`end_turn`,
+ * error_max_turns→`max_tokens`, error_during_execution→`error`; codex
+ * turn/completed→`end_turn`, turn/failed→`error`, interrupt→`cancelled`;
+ * opencode `session.idle`→`end_turn` (or `error` when a session.error
+ * preceded it).
+ */
+export type StopReason = 'end_turn' | 'max_tokens' | 'refusal' | 'cancelled' | 'timeout' | 'error';
+/**
+ * Status of one plan/todo entry. claude TodoWrite/TaskUpdate use the first
+ * three words verbatim; codex `turn/plan/updated` sends camelCase
+ * (`inProgress`) and is normalized here; opencode `todowrite` adds
+ * `cancelled` ("no longer needed") — its status field is a free-form string
+ * whose documented vocabulary is pending|in_progress|completed|cancelled.
+ *
+ * `cancelled` is opencode-only today. It is a first-class status rather than a
+ * dropped row: an abandoned todo must stay visible (struck through) instead of
+ * silently vanishing from the dock mid-run.
+ */
+export type PlanStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
+/** One entry of the session plan — full-replacement semantics (ACP style). */
+export interface PlanEntry {
+    content: string;
+    status: PlanStatus;
+    priority?: 'high' | 'medium' | 'low';
+    /** Present-continuous label shown while the entry is in progress
+     *  (claude TodoWrite's `activeForm`). */
+    activeForm?: string;
+}
+/**
+ * Raw token counts — never pre-weighted (cost weighting is a presentation
+ * concern, not a wire concern).
+ *
+ * Per backend: claude `result.usage` (+ `total_cost_usd` as `costUsd` on the
+ * carrying event); codex `thread/tokenUsage/updated` (no USD); opencode
+ * `message.updated` info.tokens/cost and `step-finish` parts.
+ */
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    reasoning?: number;
+    /** The backend's own total when given, else the sum of the parts. */
+    total: number;
+    /** Model context-window size when known — feeds the fill gauge. */
+    contextWindow?: number;
+}
+/**
+ * One file change carried by an edit-tool item.
+ * claude `Edit`/`Write` input → `oldText`/`newText`; codex
+ * `fileChange.changes[]` → `unified`; opencode `patch` parts → `unified`.
+ * `oldText: null` means the file is newly created.
+ */
+export interface FileDiff {
+    path: string;
+    oldText: string | null;
+    newText?: string;
+    unified?: string;
+}
+/** A file location a tool touched (feeds "jump to file" affordances). */
+export interface ToolLocation {
+    path: string;
+    line?: number;
+}
+/** A choice offered by a permission request (ACP option kinds). */
+export type PermissionOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+export interface PermissionOption {
+    id: string;
+    label: string;
+    kind: PermissionOptionKind;
+}
+/**
+ * A chat message.
+ * claude: `assistant` `text` blocks (whole-block, or true deltas via
+ * `--include-partial-messages`); codex: `agentMessage` items (`phase` from
+ * the item's own phase field); opencode: text parts of a message.
+ */
+export interface UiMessageItem {
+    kind: 'message';
+    id: string;
+    role: 'assistant' | 'user';
+    text: string;
+    phase?: 'commentary' | 'final';
+    parentItemId?: string;
+}
+/**
+ * Extended thinking / reasoning summary.
+ * claude: `thinking` blocks; codex: `reasoning` items (+ textDelta);
+ * opencode: `reasoning` parts.
+ */
+export interface UiReasoningItem {
+    kind: 'reasoning';
+    id: string;
+    text: string;
+    parentItemId?: string;
+}
+/**
+ * One tool invocation with its full lifecycle.
+ * claude: `tool_use` (started, status `running`) + `tool_result`
+ * (completed/failed; `permission_denials` → `declined`); codex: typed items
+ * (`commandExecution`→execute with `exitCode`, `fileChange`→edit with
+ * `diffs`, `mcpToolCall`→other, `webSearch`→fetch); opencode: tool parts
+ * (state pending/running/completed/error, `patch` parts → `diffs`).
+ *
+ * `parentItemId` nests subagent work under its spawning task item —
+ * claude `parent_tool_use_id`, opencode `subtask` parts, codex review items.
+ */
+export interface UiToolItem {
+    kind: 'tool';
+    id: string;
+    /** The backend's tool name / item type (e.g. `Bash`, `commandExecution`). */
+    name: string;
+    /** ACP-style icon/verb hint — see `toolDisplay()` in `tool-display.ts`. */
+    toolKind: ToolKind;
+    /** Human line, computed once in the protocol layer: "Ran npm test". */
+    title: string;
+    status: ToolStatus;
+    /** Raw input — may arrive incrementally. */
+    input?: unknown;
+    output?: string;
+    error?: string;
+    diffs?: FileDiff[];
+    locations?: ToolLocation[];
+    /** commandExecution / bash exit code, when the backend reports one. */
+    exitCode?: number;
+    parentItemId?: string;
+}
+export type UiItem = UiMessageItem | UiReasoningItem | UiToolItem;
+/**
+ * Session opened.
+ * claude: `system/init` (model, tools, cwd); codex: `thread/started` or the
+ * `thread/start` result; opencode: `POST /session` response.
+ */
+export interface UiSessionStartedEvent {
+    type: 'session.started';
+    sessionId: string;
+    backend: UiBackend;
+    model?: string;
+    cwd?: string;
+    tools?: string[];
+}
+/** Session over (replaces v1 `done` / fatal `error`). */
+export interface UiSessionEndedEvent {
+    type: 'session.ended';
+    reason: StopReason;
+    message?: string;
+}
+/** v1 `note` + `error` unified — severity explicit instead of implied. */
+export interface UiSessionErrorEvent {
+    type: 'session.error';
+    message: string;
+    fatal: boolean;
+}
+/**
+ * A turn began.
+ * claude: on each stdin user message; codex: `turn/started`;
+ * opencode: on each prompt POST.
+ */
+export interface UiTurnStartedEvent {
+    type: 'turn.started';
+    turnId: string;
+}
+/**
+ * A turn finished.
+ * claude: `result` (usage + `total_cost_usd`); codex: `turn/completed` /
+ * `turn/failed`; opencode: `session.idle`.
+ */
+export interface UiTurnCompletedEvent {
+    type: 'turn.completed';
+    turnId: string;
+    stopReason: StopReason;
+    usage?: TokenUsage;
+    costUsd?: number;
+}
+/** An item entered the stream (tools usually with status pending/running). */
+export interface UiItemStartedEvent {
+    type: 'item.started';
+    item: UiItem;
+}
+/**
+ * Streaming append to one field of a live item.
+ * claude: partial-message text deltas; codex: `item/agentMessage/delta`
+ * (`text`), `item/reasoning/textDelta` (`reasoning`),
+ * `item/commandExecution/outputDelta` (`output` — live terminal); opencode:
+ * text/reasoning part cursor deltas, running-state metadata for `output`.
+ * claude has no live command output — the tool card fills on completion
+ * (per-capability degradation, never per-backend).
+ */
+export interface UiItemDeltaEvent {
+    type: 'item.delta';
+    itemId: string;
+    field: 'text' | 'reasoning' | 'output';
+    delta: string;
+}
+/** Status flips and streamed-content snapshots (codex `item/updated`,
+ *  opencode part-state flips such as pending→running). */
+export interface UiItemUpdatedEvent {
+    type: 'item.updated';
+    item: UiItem;
+}
+/** Final snapshot of an item — safe to persist (snapshots, not deltas). */
+export interface UiItemCompletedEvent {
+    type: 'item.completed';
+    item: UiItem;
+}
+/**
+ * Full-replacement plan snapshot (ACP semantics).
+ * claude: `TodoWrite` tool input, or a snapshot folded from the incremental
+ * `TaskCreate`/`TaskUpdate`/`TaskList` calls (keyed by the task id the harness
+ * reports in each tool's RESULT — see `claude-ui-mapper`); codex: the
+ * `turn/plan/updated` notification carrying the whole `update_plan` list (it is
+ * a turn-level notification, NOT an item — the app-server `ThreadItem` union has
+ * no todo variant); opencode: `todowrite` tool input — identical
+ * full-replacement semantics across all three.
+ */
+export interface UiPlanUpdatedEvent {
+    type: 'plan.updated';
+    entries: PlanEntry[];
+}
+/**
+ * RESERVED — wired when auto-approve becomes optional. Types only for now.
+ * claude: `control_request can_use_tool`; codex: the per-item
+ * `requestApproval` JSON-RPC requests; opencode: `permission.updated`.
+ */
+export interface UiPermissionRequestedEvent {
+    type: 'permission.requested';
+    requestId: string;
+    itemId?: string;
+    title: string;
+    options: PermissionOption[];
+}
+/** RESERVED — the counterpart resolution (see `permission.requested`). */
+export interface UiPermissionResolvedEvent {
+    type: 'permission.resolved';
+    requestId: string;
+    optionId: string;
+}
+/** One option in an AskUser question — see `src/core/ask.ts`. */
+export interface UiAskOption {
+    label: string;
+    description?: string;
+}
+/** One structured multiple-choice question — modeled on Claude Code's
+ *  `AskUserQuestion` (see `src/core/ask.ts`). */
+export interface UiAskQuestion {
+    id?: string;
+    header: string;
+    question: string;
+    options: UiAskOption[];
+    multiSelect?: boolean;
+}
+/**
+ * The agent asked the user a structured multiple-choice question via a
+ * `CEZ:ASK` marker (spec `2026-07-18-askuser-across-runners`). Emitted by the
+ * RunManager off the assembled turn text — uniform across claude/codex/opencode
+ * with no per-backend mapper work. The run parks `waiting`; the cockpit renders
+ * clickable option chips. Resolution is client-side — the next user message for
+ * the run closes the card — so there is no separate `ask.resolved` event.
+ */
+export interface UiAskRequestedEvent {
+    type: 'ask.requested';
+    requestId: string;
+    questions: UiAskQuestion[];
+}
+/**
+ * Cumulative-for-session raw telemetry.
+ * claude: `result.usage` + `total_cost_usd`; codex:
+ * `thread/tokenUsage/updated` (cost stays absent); opencode:
+ * `message.updated` tokens/cost + `step-finish` increments.
+ */
+export interface UiUsageUpdatedEvent {
+    type: 'usage.updated';
+    usage: TokenUsage;
+    costUsd?: number;
+}
+/**
+ * An image emitted mid-stream (kept from v1) — raw base64 on the wire here;
+ * the run manager persists it and re-emits a URL. claude: image blocks in
+ * `tool_result` (with `itemId` linking back to the tool item).
+ */
+export interface UiImageEvent {
+    type: 'image';
+    itemId?: string;
+    mediaType: string;
+    data: string;
+}
+export type UiEvent = UiSessionStartedEvent | UiSessionEndedEvent | UiSessionErrorEvent | UiTurnStartedEvent | UiTurnCompletedEvent | UiItemStartedEvent | UiItemDeltaEvent | UiItemUpdatedEvent | UiItemCompletedEvent | UiPlanUpdatedEvent | UiPermissionRequestedEvent | UiPermissionResolvedEvent | UiAskRequestedEvent | UiUsageUpdatedEvent | UiImageEvent;
+/** Every v2 event discriminator — `satisfies Record<UiEventType, …>` maps
+ *  downstream keep new event types honest at compile time. */
+export type UiEventType = UiEvent['type'];

package/dist/core/ui-events.js

@@ -0,0 +1,25 @@
+/**
+ * Normalized agent-event protocol v2 — the shared vocabulary every runner
+ * emits ALONGSIDE the v1 `AgentEvent` stream (never replacing it; mixed
+ * NDJSON files stay valid — old recordings must keep replaying).
+ *
+ * Contract sources (authoritative, in this order):
+ *  - `.ai/analysis/cockpit-ui-redesign/agent-event-protocols.md` §7 (schema)
+ *    and §7.1 (per-backend mapping tables);
+ *  - the spec `.ai/specs/2026-07-14-cockpit-ui-redesign.md`
+ *    §"Normalized agent-event protocol v2".
+ *
+ * Design rules baked in:
+ *  1. Item-lifecycle model (Codex/ACP style): one stable `id` per item with
+ *     started/delta/updated/completed phases — two of the three backends are
+ *     natively item-shaped and claude maps trivially.
+ *  2. ACP vocabulary wherever a choice is arbitrary (tool status/kind, plan
+ *     entries, diff shape, stop reasons) for ecosystem alignment.
+ *  3. Every v1 `AgentEvent` stays derivable from this stream, so consumers
+ *     can migrate one panel at a time.
+ *
+ * This module is pure vocabulary: no runtime imports, no runner coupling.
+ * Mirrored into `packages/api-client/src/protocol/`.
+ */
+export {};
+//# sourceMappingURL=ui-events.js.map

package/dist/core/ui-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-events.js","sourceRoot":"","sources":["../../src/core/ui-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/core/usage-limit.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Provider usage-limit detection (spec 2026-08-03-auto-resume-after-usage-limit).
+ *
+ * A subscription that runs out of its window does not fail like an agent bug does: the work is
+ * fine, the account is simply closed until a KNOWN instant. That instant is the whole feature —
+ * without it there is nothing to schedule, so this module answers exactly one question about a
+ * terminal error string: "is this a usage limit, and when does it lift?".
+ *
+ * The evidence differs per backend, so the shapes are recognized in order of how exact they are:
+ *
+ *  1. Claude Code's machine-readable envelope, `Claude AI usage limit reached|<epoch>` — the CLI
+ *     puts it in an `is_error` result frame, which reaches cezar verbatim as the run's `error`.
+ *     Exact, no locale, no parsing of prose. This is the one that matters in practice.
+ *  2. An explicit reset instant in the prose (`try again at 2026-08-03T18:00:00Z`) — how Codex and
+ *     OpenCode phrase the same thing when they carry a timestamp at all.
+ *  3. A clock-only reset in prose (`resets 8:10pm (Europe/Warsaw)`) — how Claude Code phrases
+ *     session windows in some interactive output.
+ *  4. A relative delay (`try again in 42 minutes`, `retry-after: 3600`).
+ *
+ * Nothing else counts. A limit message with no recoverable reset instant returns `null` on
+ * purpose: guessing a window would turn one interruption into a retry loop against a provider
+ * that is still refusing, and "we don't know when" is an honest answer the caller can surface.
+ */
+export interface UsageLimitHit {
+    /** When the provider says the limit lifts. Never in the past — a stale instant clamps to now. */
+    resetAt: Date;
+    /** Which shape carried it — the lifecycle note quotes this so the schedule is auditable. */
+    evidence: 'claude-marker' | 'timestamp' | 'clock' | 'delay';
+}
+/**
+ * The furthest ahead a reset may sit and still be believed. Claude's weekly window is the real
+ * ceiling; anything beyond a week is a corrupt or unit-confused number, and parking a task on it
+ * would be indistinguishable from losing the task.
+ */
+export declare const MAX_USAGE_LIMIT_WAIT_MS: number;
+/**
+ * Read a usage limit out of a terminal error message, or `null` when it is not one (or carries no
+ * usable reset instant). `now` is injected so callers and tests share one clock.
+ *
+ * Never throws: this runs on the failure path of every run, where a second failure helps nobody.
+ */
+export declare function parseUsageLimit(message: string | undefined, now?: number): UsageLimitHit | null;