@oh-my-pi/pi-ai 17.1.2 → 17.1.4

package/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 ## [Unreleased]
 
+## [17.1.4] - 2026-07-26
+
+### Added
+
+- MiniMax Token Plan accounts now report quota in `omp usage`. `GET /v1/token_plan/remains` returns one bucket per plan quota, each carrying a rolling interval window and a weekly window, so `minimax-code` surfaces real remaining percentages instead of an empty report. A model the plan does not include comes back looking like an untouched quota; those buckets are dropped from the report and named in its metadata. The mainland id `minimax-code-cn` is untouched.
+- OAuth logins now stamp `authorizedAt` (epoch ms of the interactive login) on the stored credential, and every refresh-persist path preserves it. Anthropic expires the whole OAuth grant family ~30 days after authorization regardless of refresh-token rotation (observed as `invalid_grant: "Refresh token expired"` on the latest rotated token, exactly 30 days after login, across four production accounts), so the login anchor is what makes re-login deadlines computable. Exported `ANTHROPIC_OAUTH_GRANT_TTL_MS` alongside the anthropic OAuth flow.
+- Added `GET /v1/credentials/disabled` to the auth broker and `AuthBrokerClient.listDisabledCredentials`: disabled-credential tombstones (`DisabledCredentialSummary` — identity, verbatim disable cause, disable timestamp; never token material) so auto-disabled accounts stay visible to clients instead of silently vanishing from the snapshot. `AuthStorage.listDisabledCredentials` serves the same data locally from SQLite; clients of brokers predating the endpoint get an empty list (404 mapped, no error).
+- Added `AuthStorage.revalidateCredentials()` and the optional `AuthCredentialStore.refreshSnapshot` hook: remote broker stores re-fetch `GET /v1/snapshot` on demand so callers pairing live per-credential data with stored identities (`omp usage`) never render against the up-to-an-hour-stale disk-cached snapshot; local SQLite stores are always current and only reload.
+- Added an optional per-request `codexSseMaxAttempts` stream option to bound Codex SSE pre-response retries while preserving the six-attempt default when omitted.
+- Fixed Cursor requests failing with `Connect error internal: Unable to parse image: ...` whenever the session history contained an image: `rootPromptMessagesJson` image parts now embed a `data:<mime>;base64,` URI instead of bare base64, matching the convention used by the OpenAI-completions provider ([#6564](https://github.com/can1357/oh-my-pi/pull/6564)).
+
+### Fixed
+
+- Fixed OpenAI Responses native history replay sending output-only `status` fields back as input, preventing `input[N].status` failures in long-running sessions. ([#6513](https://github.com/can1357/oh-my-pi/pull/6513) by [@Ant39140](https://github.com/Ant39140))
+- Cursor no longer discards a local tool result when the transport fails mid-execution. The provider waits for in-flight exec dispatches before pushing `done`, but the error path skipped that wait, so a handler decoded from the last chunk landed its result after the Agent had already finalized the call from the terminal error and cleared its buffer — losing the real outcome of a tool that may already have run side effects. Both exits now drain the same barrier.
+- Cursor exec handlers returning the bare-result form no longer record a failed call as successful. When an SDK handler returns only a protocol result (no paired `toolResult`), the synthesized transcript entry was always `"Tool produced no transcript result"` with `isError: false`, even for a `rejected` or `error` result — so Cursor saw a failure while the rebuilt transcript showed success. The synthesized entry now derives its state and message from the result's own oneof variant — including MCP, where an application-level tool failure rides inside the `success` variant as `is_error` rather than as a separate variant.
+- Fixed Cursor models silently failing to maintain the todo list. Cursor resolves its native `update_todos`/`read_todos` tools server-side, but the bridge looked for them under flattened `updateTodosToolCall`/`readTodosToolCall` properties, which a decoded `agent.v1.ToolCall` never has — the variant only arrives through the `tool` oneof — so no native todo call was ever recognized. The synthesized `todo` tool call was also emitted as locally runnable with a `{todos}` payload the local tool's schema rejects, so any update that did surface ended as a validation error and local todo state never followed Cursor's. Todo calls are now read from the oneof, both native todo blocks are marked as already-resolved, and local state is mirrored from the server's confirmed success snapshot (leaving state untouched on `UpdateTodosError`). `TODO_STATUS_CANCELLED` now maps to `abandoned` instead of reverting the task to `pending`.
+- Hardened Cursor todo mirroring against partial `read_todos` responses: a read narrowed by `status_filter`/`id_filter`, or one returning fewer rows than the server's own `total_count`, is a subset rather than the list, and is no longer treated as authoritative. Previously such a response would have deleted every task it omitted.
+- Fixed an empty `update_todos` response whose `total_count` is nonzero being mirrored as an authoritative clear, deleting every local task at once. The count-mismatch guard skipped empty responses entirely; only a matching zero count is a genuine clear now. An empty `read_todos` stays refused outright, since proto3 decodes an unset `total_count` as `0` and it cannot be told apart from a filtered read that matched nothing.
+- Fixed a Cursor todo call being left unpaired when the completion frame carried no `tool_call` at all. `ToolCallCompletedUpdate.tool_call` is optional, but the block was already marked as server-resolved by the started frame, so nothing emitted a placeholder for it and every transcript rebuild stripped the interaction. It now settles as "nothing to mirror", the same as a refused snapshot.
+- Fixed local Cursor exec calls (`read`/`write`/`grep`/`delete`/`bash`/`lsp`/MCP) vanishing from rebuilt transcripts when the tool produced no result. The assistant block is synthesized and marked server-resolved before the handler runs, so the three result-less paths — no handler installed, a handler returning nothing, and a thrown handler — left the call unpaired. Each now pairs a result carrying the same text the server receives.
+- Fixed Cursor MCP tool calls being unrecognized on the wire. `ToolCall.tool` is a protobuf oneof, so a decoded message exposes the variant as `{ case, value }` and never as a flat `mcpToolCall` property — the same trap that made native todo calls invisible while hand-shaped fixtures kept passing. Both the streamed start and the completion arg merge now go through a shared selector.
+- Fixed a streamed Cursor MCP block being named from `name` while its paired result used `toolName`, so the two disagreed whenever the server sent different values. Both now prefer `toolName`.
+- Fixed the Cursor stream emitting `done` while a tool handler decoded from the final chunk was still running. Server messages are dispatched fire-and-forget so the socket keeps draining, but nothing waited for them: when an exec request, `turnEnded` and the stream close arrived in one chunk, the turn finished before the handler produced its result, and the result missed the buffer drain that pairs it with its call. In-flight dispatches are now awaited after the transport completes.
+- Fixed a server-resolved Cursor todo call leaving its transcript block stuck pending: the synthetic completion was emitted under a freshly generated id instead of the streamed call id the interactive transcript filed the block under, so the card animated indefinitely. The settled call id is now handed to the sync handler.
+- Fixed server-resolved Cursor todo blocks disappearing from rebuilt transcripts: nothing produced a `toolResult` for them, and `buildSessionContext` strips any `toolCall` left unpaired, so the interaction vanished on reload, branch switch, or transcript rebuild. The result the host builds is now persisted verbatim — it carries the `details.phases` the todo renderer rebuilds the list from, which a summary-only result would have replayed as `0 tasks`.
+- Fixed a refused or failed Cursor todo call leaving its card animating forever. Only a successful snapshot settled the block, so a `read_todos` narrowed by a filter and a server `UpdateTodosError` both went unanswered — no `tool_execution_end`, and no `toolResult` to keep the block from being stripped on rebuild. Every completed native todo call now settles. A server error is carried through as a failed result rather than collapsed into the benign "nothing to mirror" case, which would have replayed the failure as a success.
+- Hardened Cursor todo mirroring against snapshots whose rows collide on content. Cursor's wire model identifies todos by `id` and can represent two rows sharing the same text; the local list is keyed by content alone and the `todo` tool rejects a duplicate outright, so importing such a pair would leave every task-targeted `done`/`drop`/`rm` resolving to the first row and the second unreachable. The snapshot is now refused like any other that cannot be represented locally — local state is left untouched and the call still settles as a no-op.
+- Hardened Cursor todo mirroring against ambiguous empty `read_todos` responses. `total_count` is a proto3 scalar, so an unset field decodes as `0` and is indistinguishable from a genuinely empty list; accepting `todos=[]` + `total_count=0` would clear every local task. Empty and mismatched reads are now refused — `update_todos` remains the authoritative clear path.
+- Fixed refused Cursor todo results claiming `"No todo changes"`. A server-accepted `update_todos` can still be declined locally (content collision, etc.), so the persisted fallback now reads `"Todo snapshot not mirrored"` instead of implying the remote call changed nothing.
+- Hardened Cursor todo mirroring against snapshots carrying unresolved `TodoItem.dependencies`. The wire model blocks a row behind other rows by `id`; the local list has no ids and no edges, so an imported dependent row files as plain `pending` and `nextActionableTask` then offers work the server considers blocked. Snapshots with an edge pointing at a row that is not yet `completed`/`abandoned` are now refused like any other that cannot be represented locally. Edges whose blockers already finished constrain nothing and still mirror.
+- Extended the Cursor todo `total_count` mismatch guard to `update_todos`. A partial or size-limited merge response is as incomplete as a filtered read, but the check only applied to reads, so an update returning fewer rows than its own count was mirrored as the full list and deleted every task it omitted. An empty update still syncs — it remains the authoritative clear path, unlike an ambiguous empty read.
+- Hardened Cursor todo mirroring against rows with empty `content`. `content` is a proto3 string, so a missing or default value arrives as `""`; the local list is keyed by content and rejects a falsy one before lookup, leaving the imported row unreachable to every task-targeted `done`/`drop`/`rm`. Such snapshots are now refused like any other that cannot be represented locally.
+- Fixed a deterministic circular-import TDZ that crashed `packages/catalog`'s test process with `ReferenceError: Cannot access 'claudeCodeVersion' before initialization`: `registry/oauth/anthropic.ts` imported `claudeCodeVersion` from `providers/anthropic.ts`, which transitively pulls the registry back in (`providers/anthropic` → `stream` → `registry` → `registry/oauth/anthropic`), so the module-level `claude-code/${claudeCodeVersion}` bootstrap user-agent const read the binding while `providers/anthropic.ts` was still mid-initialization. `claudeCodeVersion` now lives in a zero-import leaf module (`providers/claude-code-fingerprint.ts`) that `providers/anthropic.ts`, `registry/oauth/anthropic.ts`, and `usage/claude.ts` all import from, removing the cycle at the source rather than deferring the read.
+- Fixed a circular initialization between the Anthropic provider and OAuth registry that could throw before `claudeCodeVersion` was initialized when package tests or consumers loaded modules in parallel ([#6628](https://github.com/can1357/oh-my-pi/pull/6628) by [@anatoli-tsinovoy](https://github.com/anatoli-tsinovoy)).
+- Stopped the account-level Codex `rate_limit.limit_reached` flag from being applied to individual chat windows. Codex reports one shared flag for the whole account, so a window with real headroom was marked `exhausted` because a different window (or a separate metered feature) was at its limit, which over-blocked sibling accounts during credential selection. Each window's status now reflects only its own usage
+- Scoped Codex reactive backoff per meter: a `usage_limit_reached` from a Spark request no longer persists a block that ordinary chat requests honour, and the reverse. Blocks written before scoping used a shared scope meaning "block everything", so requests still honour it and reconciliation still heals it
+- Implemented `scopeLimits` for the Codex ranking strategy so a request gates only on the windows it actually consumes: `-spark` models spend the Spark meter and every other model spends the 5h/weekly chat windows, instead of OR-ing every window and meter into one provider-wide block
+- Fixed native Anthropic adaptive-only models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5) keeping thinking ON when reasoning was meant to be off. `mapOptionsForApi` never consulted `disableReasoning` on the Anthropic branch, so a caller-side disable left adaptive thinking at full effort; and `disableThinkingIfToolChoiceForced` deleted `output_config.effort` alongside `thinking`, which for adaptive-only models silently re-enabled adaptive thinking (a bare omission defaults to adaptive-ON). Both paths now omit `thinking` and pin the lowest adaptive effort, so `disableReasoning` and forced `tool_choice` turns (e.g. the delivery reviewer's `report_delivery`) actually suppress reasoning instead of returning a thinking block with `end_turn` ([#6589](https://github.com/can1357/oh-my-pi/issues/6589)).
+- Fixed Bedrock Converse dropping captured Claude thinking signatures when replaying application-inference-profile ARN models, restoring adaptive-thinking multi-turn conversations ([#6610](https://github.com/can1357/oh-my-pi/issues/6610)).
+- Fixed the `alibaba-token-plan` login only supporting the international Singapore endpoint, which rejected China (Beijing) Token Plan `sk-sp-` keys with `401 invalid_api_key`. Login now selects a region (International / China (Beijing) / Custom), validates the key against that region's `/models` endpoint, and stores the chosen base URL in the credential so inference and discovery both target it ([#6682](https://github.com/can1357/oh-my-pi/issues/6682)).
+- Fixed statusless provider capacity errors such as `no_capacity` and high-demand responses being treated as terminal instead of retryable. ([#6503](https://github.com/can1357/oh-my-pi/issues/6503))
+- Fixed QwenCloud Token Plan quota reporting to call the current console usage RPC and document how to capture its optional Cookie during login.
+- Fixed Cursor exec-channel MCP calls such as `web_search` omitting `toolCall` blocks when no interaction block arrives, which rendered their tool cards below the final assistant answer or dropped them on transcript replay. ([#6501](https://github.com/can1357/oh-my-pi/issues/6501))
+- Fixed Claude scoped weekly limits (e.g. `Claude 7 Day (Fable)`) with `is_active: false` being dropped by the `/usage` parser, rendering as `not reported` in `omp usage` despite carrying real utilization. Live payloads mark only the currently binding limit active — an account pinned at a 100% Fable cap reports its 77% shared weekly row as inactive too — so `is_active` signals severity ranking, not bucket existence, and is now ignored. Exhaustion gating is unchanged: tier rows still hard-block only at confirmed 100% with a future reset.
+- Fixed a TDZ crash (`Cannot access 'claudeCodeVersion' before initialization`) when `providers/anthropic` was the first module loaded: `providers/anthropic` → `stream` → `registry` → `registry/oauth/anthropic` circled back into the still-initializing provider module. The Claude Code fingerprint constants now live in the leaf module `providers/claude-code-fingerprint` (star re-exported from `providers/anthropic`, so import paths are unchanged).
+
+## [17.1.3] - 2026-07-24
+
+### Fixed
+
+- Fixed Cursor sessions exposing `ast_edit` (and other staged-preview `xd://` devices) without a reachable resolver: the built-in `write` tool — which carries the `xd://resolve` / `xd://reject` transport that finalizes a staged preview — was filtered out of Cursor's forwarded catalog, so previews could never be resolved and the session aborted after three forced `write` turns. `write` is now re-included in the forwarded catalog whenever pi-agent devices are advertised ([#6536](https://github.com/can1357/oh-my-pi/issues/6536)).
+- Fixed OpenAI Responses and chat-completions streams honoring per-model first-event watchdog policy, allowing local llama.cpp-style backends to process arbitrarily large prompts without a premature client cancellation ([#6524](https://github.com/can1357/oh-my-pi/issues/6524)).
+
 ## [17.1.2] - 2026-07-24
 
 ### Added

package/README.md

@@ -73,7 +73,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **Xiaomi MiMo** (requires `XIAOMI_API_KEY`)
 - **ZenMux** (requires `ZENMUX_API_KEY`)
 - **Qwen Portal** (supports `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY`)
-- **QwenCloud Token Plan** (supports `/login alibaba-token-plan`, `ALIBABA_TOKEN_PLAN_API_KEY`, or `BAILIAN_TOKEN_PLAN_API_KEY`; interactive login optionally stores a `home.qwencloud.com` Cookie request header for best-effort 5-hour and 7-day quota reporting)
+- **QwenCloud Token Plan** (supports `/login alibaba-token-plan`, `ALIBABA_TOKEN_PLAN_API_KEY`, or `BAILIAN_TOKEN_PLAN_API_KEY`; interactive login first selects a region — International (Singapore, default), China (Beijing) for 百炼 Token Plan keys, or a custom base URL — since region keys are non-interchangeable, then optionally stores a `home.qwencloud.com` Cookie request header for best-effort 5-hour and 7-day quota reporting)
   To enable quota reporting, sign in to the Token Plan dashboard, copy the `Cookie` request-header value from a `home.qwencloud.com` request in browser developer tools, and paste it at the second login prompt. Press Enter to skip; the Cookie is sensitive and session-lived, so rerun login when it expires.
 - **Cloudflare AI Gateway** (requires `CLOUDFLARE_AI_GATEWAY_API_KEY` and provider-specific gateway base URL)
 - **Ollama** (local OpenAI-compatible runtime; optional `OLLAMA_API_KEY`)

package/dist/types/auth-broker/client.d.ts

@@ -1,4 +1,4 @@
-import type { AuthCredential } from "../auth-storage.js";
+import type { AuthCredential, DisabledCredentialSummary } from "../auth-storage.js";
 import type { ClientUsageReportRequest, ClientUsageReportResponse, ClientUsageSummaryResponse, CredentialBlockRequest, CredentialBlockResponse, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadResponse, HealthzResponse, SnapshotResponse, SnapshotStreamEvent, UsageHistoryResponse, UsageResponse, UsageStaleResponse } from "./types.js";
 export interface AuthBrokerClientOptions {
     /** Base URL (e.g. `https://broker.tailnet:8765`). Trailing slashes are trimmed. */
@@ -74,6 +74,12 @@ export declare class AuthBrokerClient {
     notifyUsageStale(signal?: AbortSignal): Promise<UsageStaleResponse>;
     refreshCredential(id: number, signal?: AbortSignal): Promise<CredentialRefreshResponse>;
     disableCredential(id: number, cause: string, signal?: AbortSignal): Promise<CredentialDisableResponse>;
+    /**
+     * Disabled-credential tombstones (identity + cause, no token material).
+     * Returns an empty list against brokers predating `GET
+     * /v1/credentials/disabled` (404).
+     */
+    listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;
     uploadCredential(provider: string, credential: AuthCredential, signal?: AbortSignal): Promise<CredentialUploadResponse>;
     upsertCredentialBlock(id: number, block: CredentialBlockRequest, signal?: AbortSignal): Promise<CredentialBlockResponse>;
     deleteCredentialBlocks(id: number, signal?: AbortSignal): Promise<CredentialBlocksDeleteResponse>;

package/dist/types/auth-broker/remote-store.d.ts

@@ -1,4 +1,4 @@
-import { type AuthCredential, type AuthCredentialStore, type OAuthCredential, type StoredAuthCredential, type StoredCredentialBlock } from "../auth-storage.js";
+import { type AuthCredential, type AuthCredentialStore, type DisabledCredentialSummary, type OAuthCredential, type StoredAuthCredential, type StoredCredentialBlock } from "../auth-storage.js";
 import type { OAuthCredentials } from "../registry/oauth/types.js";
 import type { Provider } from "../types.js";
 import type { ObservedUsageEntry, UsageReport } from "../usage.js";
@@ -44,10 +44,13 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     /** Re-hydrate the in-memory snapshot from the broker. */
     refreshSnapshot(): Promise<SnapshotResponse>;
     listAuthCredentials(provider?: string): StoredAuthCredential[];
+    /** Broker-backed disabled tombstones; empty against brokers predating the endpoint. */
+    listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;
     getCredentialBlock(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     getCredentialBlockReconcileAfter(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     listCredentialBlocks(credentialIds: readonly number[]): StoredCredentialBlock[];
     upsertCredentialBlock(block: StoredCredentialBlock): void;
+    deleteCredentialBlock(_credentialId: number, _providerKey: string, _blockScope: string): void;
     deleteCredentialBlocks(credentialId: number): void;
     cleanExpiredCredentialBlocks(nowMs: number): void;
     /**

package/dist/types/auth-broker/types.d.ts

@@ -5,7 +5,7 @@
  * clients use `access` tokens directly and call back to the broker when a
  * credential expires or a 401 surfaces on a supposedly-fresh credential.
  */
-import type { AuthCredential, AuthCredentialSnapshot, AuthCredentialSnapshotEntry, StoredCredentialBlock } from "../auth-storage.js";
+import type { AuthCredential, AuthCredentialSnapshot, AuthCredentialSnapshotEntry, DisabledCredentialSummary, StoredCredentialBlock } from "../auth-storage.js";
 import type { ClientUsageClientSummary, ClientUsageReport, UsageHistoryEntry, UsageReport } from "../usage.js";
 /** GET /v1/healthz response body. */
 export interface HealthzResponse {
@@ -66,6 +66,11 @@ export interface CredentialDisableRequest {
 export interface CredentialDisableResponse {
     ok: boolean;
 }
+/** GET /v1/credentials/disabled response body — tombstones of auto-disabled rows. */
+export interface DisabledCredentialsResponse {
+    generatedAt: number;
+    disabled: DisabledCredentialSummary[];
+}
 /** POST /v1/credential/:id/block request body. */
 export type CredentialBlockRequest = CredentialBlockSnapshot;
 /** POST /v1/credential/:id/block response body. */

package/dist/types/auth-broker/wire-schemas.d.ts

@@ -11,6 +11,7 @@ export declare const oauthCredentialSchema: import("arktype/internal/variants/ob
     accountId?: string | undefined;
     orgId?: string | undefined;
     orgName?: string | undefined;
+    authorizedAt?: number | undefined;
 }, {}>;
 /** OAuth credential as it appears in broker snapshots — refresh replaced with sentinel. */
 export declare const remoteOauthCredentialSchema: import("arktype/internal/variants/object.ts").ObjectType<{
@@ -25,6 +26,7 @@ export declare const remoteOauthCredentialSchema: import("arktype/internal/varia
     accountId?: string | undefined;
     orgId?: string | undefined;
     orgName?: string | undefined;
+    authorizedAt?: number | undefined;
 }, {}>;
 export declare const apiKeyCredentialSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     type: "api_key";
@@ -44,6 +46,7 @@ export declare const writableAuthCredentialSchema: import("arktype/internal/vari
     accountId?: string | undefined;
     orgId?: string | undefined;
     orgName?: string | undefined;
+    authorizedAt?: number | undefined;
 } | {
     type: "api_key";
     key: string;
@@ -62,6 +65,7 @@ export declare const snapshotCredentialSchema: import("arktype/internal/variants
     accountId?: string | undefined;
     orgId?: string | undefined;
     orgName?: string | undefined;
+    authorizedAt?: number | undefined;
 } | {
     type: "api_key";
     key: string;
@@ -82,6 +86,7 @@ export declare const credentialSnapshotEntrySchema: import("arktype/internal/var
         accountId?: string | undefined;
         orgId?: string | undefined;
         orgName?: string | undefined;
+        authorizedAt?: number | undefined;
     } | {
         type: "api_key";
         key: string;
@@ -110,6 +115,7 @@ export declare const snapshotEntrySchema: import("arktype/internal/variants/obje
         accountId?: string | undefined;
         orgId?: string | undefined;
         orgName?: string | undefined;
+        authorizedAt?: number | undefined;
     } | {
         type: "api_key";
         key: string;
@@ -155,6 +161,7 @@ export declare const snapshotResponseSchema: import("arktype/internal/variants/o
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;
@@ -196,6 +203,7 @@ export declare const snapshotStreamSnapshotEventSchema: import("arktype/internal
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;
@@ -238,6 +246,7 @@ export declare const snapshotStreamEntryEventSchema: import("arktype/internal/va
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;
@@ -292,6 +301,7 @@ export declare const snapshotStreamEventSchema: import("arktype/internal/variant
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;
@@ -332,6 +342,7 @@ export declare const snapshotStreamEventSchema: import("arktype/internal/variant
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;
@@ -489,6 +500,7 @@ export declare const credentialRefreshResponseSchema: import("arktype/internal/v
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;
@@ -503,6 +515,33 @@ export declare const credentialDisableRequestSchema: import("arktype/internal/va
 export declare const credentialDisableResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     ok: boolean;
 }, {}>;
+/** One disabled-credential tombstone — identity + cause, never token material. */
+export declare const disabledCredentialSummarySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: number;
+    provider: string;
+    type: "api_key" | "oauth";
+    email?: string | undefined;
+    accountId?: string | undefined;
+    orgId?: string | undefined;
+    orgName?: string | undefined;
+    cause: string;
+    disabledAtMs?: number | undefined;
+}, {}>;
+/** Broker `GET /v1/credentials/disabled` response. */
+export declare const disabledCredentialsResponseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    generatedAt: number;
+    disabled: {
+        id: number;
+        provider: string;
+        type: "api_key" | "oauth";
+        email?: string | undefined;
+        accountId?: string | undefined;
+        orgId?: string | undefined;
+        orgName?: string | undefined;
+        cause: string;
+        disabledAtMs?: number | undefined;
+    }[];
+}, {}>;
 export declare const credentialBlockRequestSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     providerKey: string;
     blockScope: string;
@@ -532,6 +571,7 @@ export declare const credentialUploadRequestSchema: import("arktype/internal/var
         accountId?: string | undefined;
         orgId?: string | undefined;
         orgName?: string | undefined;
+        authorizedAt?: number | undefined;
     } | {
         type: "api_key";
         key: string;
@@ -554,6 +594,7 @@ export declare const credentialUploadResponseSchema: import("arktype/internal/va
             accountId?: string | undefined;
             orgId?: string | undefined;
             orgName?: string | undefined;
+            authorizedAt?: number | undefined;
         } | {
             type: "api_key";
             key: string;

package/dist/types/auth-storage.d.ts

@@ -75,6 +75,27 @@ export interface StoredCredentialBlock {
     /** Last row update timestamp in epoch milliseconds, when provided by the backing store. */
     updatedAtMs?: number;
 }
+/**
+ * Identity slice of a disabled (soft-deleted) credential tombstone — cause and
+ * account identity only, never token material. Surfaced so auto-disabled
+ * accounts (e.g. an expired Anthropic OAuth grant) stay visible in `omp usage`
+ * instead of silently vanishing until the user notices missing quota.
+ */
+export interface DisabledCredentialSummary {
+    /** Database row id (matches {@link StoredAuthCredential.id}). */
+    id: number;
+    provider: string;
+    type: AuthCredential["type"];
+    email?: string;
+    accountId?: string;
+    /** Organization/workspace the credential was scoped to (Anthropic/ChatGPT multi-subscription). */
+    orgId?: string;
+    orgName?: string;
+    /** Verbatim disable cause captured when the row was torn down. */
+    cause: string;
+    /** Epoch ms the row was disabled (SQLite `updated_at`), when known. */
+    disabledAtMs?: number;
+}
 /**
  * Per-credential health record returned by {@link AuthStorage.checkCredentials}.
  *
@@ -239,6 +260,21 @@ export interface AuthCredentialStore {
     /** Optional hook to notify the underlying store that usage report cache is stale. */
     invalidateUsageCache?(signal?: AbortSignal): Promise<void>;
     listAuthCredentials(provider?: string): StoredAuthCredential[];
+    /**
+     * Optional store hook to re-hydrate the credential snapshot from its
+     * backing source. Remote broker stores re-fetch `GET /v1/snapshot` so a
+     * disk-cached snapshot (up to an hour stale) cannot be paired with live
+     * per-credential data; local SQLite stores omit it — their reads are
+     * always current.
+     */
+    refreshSnapshot?(): Promise<unknown>;
+    /**
+     * Disabled credential tombstones (see {@link DisabledCredentialSummary}).
+     * Optional: remote stores forward to the broker's
+     * `GET /v1/credentials/disabled` (empty list when the broker predates the
+     * endpoint); stores without tombstones omit it.
+     */
+    listDisabledCredentials?(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;
     updateAuthCredential(id: number, credential: AuthCredential): void;
     deleteAuthCredential(id: number, disabledCause: string): void;
     tryDisableAuthCredentialIfMatches(id: number, expectedData: string, disabledCause: string, lease?: CredentialRefreshLeaseFence): boolean;
@@ -259,6 +295,8 @@ export interface AuthCredentialStore {
     getCredentialBlockReconcileAfter?(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     /** Upsert with MAX semantics: keep the later blockedUntilMs on conflict. */
     upsertCredentialBlock?(block: StoredCredentialBlock): void;
+    /** Drop one block row for a credential/provider/scope key. */
+    deleteCredentialBlock?(credentialId: number, providerKey: string, blockScope: string): void;
     /** Drop every block row for a credential (all providerKeys/scopes). */
     deleteCredentialBlocks?(credentialId: number): void;
     /** Prune rows with blocked_until_ms <= nowMs. */
@@ -1119,6 +1157,20 @@ export declare class AuthStorage {
      * (the broker server's HTTP handler does this).
      */
     exportSnapshot(): AuthCredentialSnapshot;
+    /**
+     * Disabled credential tombstones for display surfaces (`omp usage`,
+     * broker `GET /v1/credentials/disabled`). Empty when the backing store
+     * keeps no tombstones or the remote broker predates the endpoint.
+     */
+    listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;
+    /**
+     * Force the backing store to revalidate its credential snapshot, then
+     * reload. Remote broker stores re-fetch the snapshot; local stores are
+     * always current, so only the reload runs. Callers that pair live
+     * per-credential data with stored identities (`omp usage`) use this so a
+     * disk-cached snapshot cannot misattribute fresh reports.
+     */
+    revalidateCredentials(): Promise<void>;
     /**
      * Refresh the OAuth credential with the given id through a per-credential
      * single-flight. Concurrent callers for the same row await the same upstream
@@ -1162,6 +1214,7 @@ export declare class AuthStorage {
     /**
      * Broker-server seam: clear all persisted blocks for one credential and notify snapshot waiters.
      */
+    deleteCredentialBlock(credentialId: number, providerKey: string, blockScope: string): void;
     deleteCredentialBlocks(credentialId: number): void;
     /**
      * Describe where the active credential for a provider came from.
@@ -1198,6 +1251,7 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     constructor(db: Database);
     static open(dbPath?: string): Promise<SqliteAuthCredentialStore>;
     listAuthCredentials(provider?: string): StoredAuthCredential[];
+    listDisabledCredentials(provider?: string): Promise<DisabledCredentialSummary[]>;
     replaceAuthCredentialsForProvider(provider: string, credentials: AuthCredential[]): StoredAuthCredential[];
     upsertAuthCredentialForProvider(provider: string, credential: AuthCredential): StoredAuthCredential[];
     updateAuthCredential(id: number, credential: AuthCredential): void;
@@ -1221,6 +1275,7 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     getCredentialBlock(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     getCredentialBlockReconcileAfter(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     upsertCredentialBlock(block: StoredCredentialBlock): void;
+    deleteCredentialBlock(credentialId: number, providerKey: string, blockScope: string): void;
     deleteCredentialBlocks(credentialId: number): void;
     cleanExpiredCredentialBlocks(nowMs: number): void;
     listCredentialBlocks(credentialIds: readonly number[]): StoredCredentialBlock[];

package/dist/types/providers/anthropic.d.ts

@@ -26,12 +26,7 @@ type AnthropicCacheControl = NonNullable<TextBlockParam["cache_control"]>;
  * hasn't been materialized yet.
  */
 export declare function clearAnthropicFastModeFallback(providerSessionState: Map<string, ProviderSessionState> | undefined): void;
-export declare const claudeCodeVersion = "2.1.165";
-export declare const claudeAgentSdkVersion = "0.3.165";
-export declare const claudeClientVersion = "1.11187.4";
-export declare const claudeToolPrefix: string;
-export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-export declare const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64000;
+export * from "./claude-code-fingerprint.js";
 export declare function mapStainlessOs(platform: string): "MacOS" | "Windows" | "Linux" | "FreeBSD" | `Other::${string}`;
 export declare function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other::${string}`;
 export declare const claudeCodeHeaders: {
@@ -258,4 +253,3 @@ export declare function convertAnthropicMessages(messages: Message[], model: Mod
     serverSideFallbackEnabled?: boolean;
 }): AnthropicMessageParam[];
 export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;
-export {};

package/dist/types/providers/claude-code-fingerprint.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Claude Code stealth-fingerprint constants, kept in a leaf module so
+ * fingerprint consumers outside the provider (`registry/oauth/anthropic`,
+ * `usage/claude`) don't import the heavy `providers/anthropic` module.
+ * That import edge was a live init cycle: `providers/anthropic` → `stream` →
+ * `registry` → `registry/oauth/anthropic` → back into the still-initializing
+ * provider module, which threw a TDZ ReferenceError whenever
+ * `providers/anthropic` was the first module loaded.
+ */
+export declare const claudeCodeVersion = "2.1.165";
+export declare const claudeAgentSdkVersion = "0.3.165";
+export declare const claudeClientVersion = "1.11187.4";
+export declare const claudeToolPrefix: string;
+export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+export declare const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64000;

package/dist/types/providers/cursor.d.ts

@@ -2,7 +2,7 @@ import http2 from "node:http2";
 import { type JsonValue } from "@bufbuild/protobuf";
 import type { McpToolDefinition } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
 import { type AgentServerMessage, type ConversationStateStructure } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
-import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, TextContent, ThinkingContent, ToolCall, ToolResultMessage } from "../types.js";
+import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorExecPairing, CursorTodoSyncHandler, CursorToolResultHandler, Message, StreamFunction, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage } from "../types.js";
 import { kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
@@ -43,7 +43,7 @@ export interface BlockState {
         [kStreamingBlockIndex]: number;
     }) | null;
     currentToolCall: ToolCallState | null;
-    /** MCP call IDs executed through Cursor's exec channel before their stream block arrives. */
+    /** MCP call IDs synthesized from exec frames before their redundant streamed block arrives. */
     resolvedMcpToolCallIds: Set<string>;
     firstTokenTime: number | undefined;
     setTextBlock: (b: (TextContent & {
@@ -54,14 +54,36 @@ export interface BlockState {
     }) | null) => void;
     setToolCall: (t: ToolCallState | null) => void;
     setFirstTokenTime: () => void;
+    /** Mirror a server-confirmed todo snapshot into local session state. */
+    onTodoSnapshot?: CursorTodoSyncHandler;
+    /**
+     * Persist a paired `toolResult` for a server-resolved call. Native todo calls
+     * never travel the exec channel, so without this the resolved block has no
+     * matching result and every transcript rebuild strips it as dangling.
+     */
+    onToolResult?: CursorToolResultHandler;
 }
 export interface UsageState {
     sawTokenDelta: boolean;
 }
 /** Exported for tests: drives one Cursor server message through the stream (exec waits mark the stream busy). */
 export declare function handleServerMessage(msg: AgentServerMessage, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, blobStore: Map<string, Uint8Array>, h2Request: http2.ClientHttp2Stream, execHandlers: CursorExecHandlers | undefined, onToolResult: CursorToolResultHandler | undefined, usageState: UsageState, requestContextTools: McpToolDefinition[], onConversationCheckpoint?: (checkpoint: ConversationStateStructure) => void): Promise<void>;
-/** Exported for tests: verifies handler is invoked with correct `this` when passed as bound. */
-export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult): Promise<{
+/**
+ * Exported for tests: verifies handler is invoked with correct `this` when passed as bound.
+ *
+ * Every exit pairs a `toolResult`. The synthesized block was already marked
+ * `kCursorExecResolved` before this runs (`synthesizeCursorExecToolCall`), so
+ * `agent-loop.ts` emits no placeholder for it: a path that returns without a
+ * result leaves the call unpaired and `buildSessionContext` strips the whole
+ * interaction on replay. The three result-less paths — no handler installed, a
+ * handler that produced nothing, and a thrown handler — therefore synthesize
+ * one from the same text the server sees in `execResult`.
+ *
+ * `pairing` is required so a new callsite cannot silently recreate the orphan,
+ * and nullable for the one caller whose block is NOT pre-resolved: MCP without
+ * an `mcp` handler, which `agent-loop.ts` runs locally and pairs itself.
+ */
+export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult, pairing: CursorExecPairing | null): Promise<{
     execResult: TResult;
     toolResult?: ToolResultMessage;
 }>;
@@ -99,14 +121,14 @@ export declare function emptyGrepPatternRejection(pattern: string | undefined, g
 export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unknown> | undefined, completion: Record<string, unknown> | undefined): Record<string, unknown>;
 /**
  * Synthesize a completed `toolCall` content block for a Cursor exec-channel
- * native tool (`shell`, `read`, `write`, `grep`, `ls`, `delete`, `diagnostics`).
+ * native tool (`shell`, `read`, `write`, `grep`, `ls`, `delete`, `diagnostics`)
+ * or for an MCP exec frame whose corresponding interaction block is absent.
  *
  * Args arrive complete on the exec message, so the block opens and closes in
  * one step — no partial-JSON streaming path. Without this the persisted
  * assistant message carries only text/thinking blocks, and on replay the
  * following `toolResult` messages have no matching `toolCall.id` in
- * `renderSessionContext`, so they render as header-less `⎿` lines beneath the
- * last text block instead of proper tool components (issue #4348).
+ * `renderSessionContext`, so they render beneath the final answer or disappear.
  *
  * The block is stamped with {@link kCursorExecResolved} so the shared
  * `agent-loop.ts` execution pass skips it — Cursor's server-driven exec
@@ -119,6 +141,7 @@ export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unkn
 export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>): void;
 /** Exported for tests: drives one Cursor interaction update through the streaming state machine. */
 export declare function processInteractionUpdate(update: any, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, usageState: UsageState): void;
+export declare function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[];
 /**
  * Build `ConversationStateStructure.rootPromptMessagesJson` blob IDs for the
  * system prompt plus prior conversation history, as JSON blobs matching

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -96,10 +96,11 @@ export interface CodexLiteShapedBody {
  * rewrite removes top-level `tools`, a forced hosted-tool choice (e.g.
  * `{ type: "web_search" }`) would leave the backend unable to validate the
  * choice against a tools collection and it rejects the request with HTTP 400
- * (#5771). Such choices must fall back to `"auto"`; explicit string constraints
- * such as `"none"` and `"required"` remain valid. Shared by normal turns and
- * both remote-compaction paths — codex-rs routes `/responses/compact` through
- * the same builder.
+ * (#5771). Native computer and named-function choices preserve exact forcing
+ * by isolating the selected declaration and using `"required"`; other hosted
+ * choices fall back to `"auto"`. Explicit string constraints such as `"none"`
+ * and `"required"` remain valid. Shared by normal turns and both remote-compaction
+ * paths — codex-rs routes `/responses/compact` through the same builder.
  */
 export declare function applyCodexResponsesLiteShape(body: CodexLiteShapedBody): void;
 export declare function transformRequestBody(body: RequestBody, model: Model<"openai-codex-responses">, options?: CodexRequestOptions, prompt?: {

package/dist/types/providers/openai-codex-responses.d.ts

@@ -182,6 +182,9 @@ declare function convertMessages(model: Model<"openai-codex-responses">, context
 /** @internal Exported for tests. */
 export { convertMessages as convertCodexResponsesMessages };
 type CodexToolPayload = {
+    type: "computer";
+    name?: never;
+} | {
     type: "function";
     name: string;
     description: string;

package/dist/types/registry/alibaba-token-plan.d.ts

@@ -1,4 +1,15 @@
 import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+/**
+ * Log in to the QwenCloud Token Plan provider.
+ *
+ * The Token Plan ships as two regionally separate products with
+ * non-interchangeable keys — International (Singapore) and China (Beijing) —
+ * so login first selects the region (or a custom base URL) before pasting the
+ * key, mirroring {@link loginAlibabaCodingPlan}. The chosen region is validated
+ * against its own `/models` endpoint and, when it diverges from the default
+ * international endpoint, stored in the credential so inference and discovery
+ * both target it (#6682).
+ */
 export declare function loginAlibabaTokenPlan(options: OAuthController): Promise<string>;
 export declare const alibabaTokenPlanProvider: {
     readonly id: "alibaba-token-plan";

package/dist/types/registry/oauth/anthropic-constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Absolute lifetime of an Anthropic OAuth grant family, anchored at the
+ * interactive login. Refresh-token rotation does NOT extend it: ~30 days
+ * after authorization the token endpoint returns
+ * `invalid_grant: "Refresh token expired"` for the latest rotated token and
+ * only a fresh interactive login recovers the account. Observed against
+ * production (grants authorized 2026-06-20/06-25 died 30d later to the hour
+ * despite healthy 8h rotations); matches Claude Code's documented monthly
+ * re-login. Consumers use this to warn before the deadline — it is a display
+ * heuristic, not a wire contract.
+ */
+export declare const ANTHROPIC_OAUTH_GRANT_TTL_MS: number;

package/dist/types/registry/oauth/anthropic.d.ts

@@ -4,6 +4,7 @@
 import type { FetchImpl } from "../../types.js";
 import { OAuthCallbackFlow } from "./callback-server.js";
 import type { OAuthController, OAuthCredentials } from "./types.js";
+export { ANTHROPIC_OAUTH_GRANT_TTL_MS } from "./anthropic-constants.js";
 export declare class AnthropicOAuthFlow extends OAuthCallbackFlow {
     #private;
     constructor(ctrl: OAuthController);

package/dist/types/registry/oauth/index.d.ts

@@ -1,4 +1,5 @@
 import type { OAuthCredentials, OAuthProvider, OAuthProviderId, OAuthProviderInfo, OAuthProviderInterface } from "./types.js";
+export * from "./anthropic.js";
 export * from "./device-code.js";
 export type * from "./types.js";
 /**

package/dist/types/registry/oauth/types.d.ts

@@ -18,6 +18,14 @@ export type OAuthCredentials = {
     orgId?: string;
     /** Human-readable organization name for display (may embed the email). */
     orgName?: string;
+    /**
+     * Epoch ms of the interactive login that minted this grant. Set by
+     * `AuthStorage.login`; token refreshes preserve it. Providers with an
+     * absolute grant lifetime (Anthropic expires the whole refresh-token
+     * family ~30 days after authorization regardless of rotation) use it to
+     * surface re-login deadlines before the grant dies.
+     */
+    authorizedAt?: number;
 };
 export type OAuthProvider = OAuthProviderUnion;
 export type OAuthProviderId = OAuthProvider | (string & {});