@platless/axom-cli 0.3.13 → 0.6.36

package/README.md

@@ -1,6 +1,6 @@
 # @platless/axom-cli
 
-One npm package, one bin: `axom`. An authenticated MCP client for Axomwork (`struct`/`record`/`execute`/`guide`), plus the personal Workstation daemon — registration, encrypted tunnels, self-update, and OS service lifecycle — merged into the same package.
+One npm package, one bin: `axom`. An authenticated MCP client for Axomwork (`struct`/`record`/`execute`/`knowledge`), plus the personal Workstation daemon — registration, encrypted tunnels, self-update, and OS service lifecycle — merged into the same package.
 
 ## Install
 
@@ -18,8 +18,9 @@ curl -s http://<your-axom-server>/download/client/manifest.json
 ```
 
 A plain `-g` install on purpose: it puts `axom` on your `PATH` the way npm puts every other global
-binary there. Do **not** add `--prefix` — the CLI's own self-update runs the same `npm install
---global`, and a private prefix leaves the binary somewhere no shell looks.
+binary there. For a manual installation, keep the existing global prefix. Desktop-managed macOS
+installations use `~/.axom/cli` with an explicit Node runtime, installation receipt, terminal wrapper,
+service environment and update/rollback context; do not imitate that by adding a standalone `--prefix` flag.
 
 Verify before going further — this is the step that catches a broken install:
 
@@ -51,9 +52,19 @@ axom execute healthCheck '{}'
 
 `axom workstation start` registers this machine (reusing the `axom auth` login) and installs/starts the daemon as an OS service; `stop`/`restart`/`status` control or query it; `install`/`uninstall` manage just the service definition (launchd/systemd) for manual repair.
 
+On Debian 13 amd64, `axom workstation start --enable-rd` installs native remote desktop support and reuses the user's X11 desktop, or starts a managed Xfce desktop when none exists. `workstation rd status` reports its state; `workstation rd disable` revokes it without removing registration. See [Linux workstation RD](../docs/handbook/linux-workstation-rd.md) for session selection and package delivery.
+
+Disk heartbeats discover mounted local data storage independently of configured workspaces.
+Linux partitions and bind mounts are deduplicated by filesystem identity; macOS APFS volumes
+share one entry per physical capacity container. Boot/recovery partitions, memory filesystems,
+network shares and macOS disk images are excluded. Container overlay storage is shown only
+when no persistent local data mount is available. Discovery refreshes every ten minutes;
+capacity is sampled on each heartbeat. Space usage is `1 - available / total`, including
+filesystem reserved space. Other platforms retain workspace-based discovery.
+
 ## Updating
 
-`axom update [--version x.y.z]` upgrades `axom` itself to the release the connected server currently publishes. It only installs the new package and prints a hint — it does not restart the workstation daemon (that would kill every active agent session on the machine), so run `axom workstation restart` afterward to apply it.
+`axom update [--version x.y.z]` upgrades `axom` itself to the release the connected server currently publishes. When a verified daemon is running, the command requests its existing update coordinator, which drains work and preserves keepers during service handoff. When stopped, it only installs the package. A busy or unverifiable daemon is not bypassed by a fresh empty task registry.
 
 ## Config
 
@@ -61,4 +72,6 @@ Non-secret CLI auth state is stored in `~/.axom/config.json` with mode `0600`. T
 
 ## Learn more
 
-This README is a front page, not the manual. For the full command reference (arguments, exit codes, examples) and architecture notes, see `docs/guide/modules/cli.md` and `guide/en/agent-integration/axom-cli/` in the Axomwork monorepo this package is built from.
+This README is a front page, not the manual. For the full command reference (arguments, exit codes, examples) and architecture notes, see `docs/guide/modules/cli.md` and `knowledge/manual/en/agent-integration/axom-cli/` in the Axomwork monorepo this package is built from.
+
+Desktop on macOS can install and manage this same CLI from personal Workstations. See [Desktop local workstation management](../docs/handbook/desktop-local-workstation.md). The local-management JSON protocol uses stdin for temporary authorization and never persists Desktop refresh tokens.

package/dist/axom-patch/cli/README.md

@@ -16,11 +16,20 @@ Workstation Docker 同样携带这份策略；普通 CLI 安装/Server 下发更
 | 都不写 | 一直生效，直到删除 | 不允许 |
 
 when 用于「这个版本有问题、已有修复版」，registry 一换版本就不再生效；until 用于「等上游发某个版本」，
-钉住的版本必须排在界限之前。两种都不需要为让位再发 CLI。
+钉住的版本不得高于界限：低于界限可用于等待正式修复版，等于界限可用于等待 registry 收录已发布版本。
+两种都不需要为让位再发 CLI。
 
 用户按正常界面安装/更新适配器即可：补充条目（Kimi Code、Command Code、ZCode）、分发源覆盖和启动环境变量通过 catalog 应用，
 roster、Install、Update、启动统一读取同一来源。
-发布包代码补丁由 `managedPatches.ts` 在 Install/Update 和首次真实启动时应用。
+
+**有补丁的条目必须钉版本**（2026-10-14 起的硬规则，`catalog.test.ts` 的 `patched agents stay pinned`
+机械守卫）：配方只核验过列出的版本，不钉的话 registry/npm 一发新版，Install/Update 就装上一个配方
+不生效的包——账号配额、steering、子代理归一静默消失。钉住后 roster 上报的 `version`/`registryVersion`
+就是生效（钉住）版本，设置页的 Update 比对（`installedVersion != registryVersion`）因此永远对着
+catalog 的钉版本，**不对着官方 registry 比**；上游新版本要等
+[`../DAILY_UPGRADE_CHECK.md`](../DAILY_UPGRADE_CHECK.md) 的周期任务核验移植配方后再 bump，届时
+`reconcileCertifiedBuilds` 把已安装的工作站自动前移。
+发布包补丁由 `managedPatches.ts` 在 Install/Update 和首次真实启动时应用。
 历史安装也会补齐，配置显式 command 的用户自有启动程序按其配置执行。
 
 发布包补丁步骤：
@@ -53,17 +62,27 @@ catalog 是 Axom 对官方 ACP registry 的本地扩展层，随 CLI 发布：
 
 | 台账 ID | 状态/应用入口 | AI 核验与下线重点 |
 |---|---|---|
-| kimi-code-distribution | active；catalog.ts 补充条目 `kimi-code`（Kimi Code 2.1.1 官方二进制，六平台 tar.gz + sha256），隐藏已归档的 `kimi` | registry#458 合入后补充条目自动让位、版本由 registry 跟进；验证 Install/Update、复用登录后删除 supplement |
-| command-code-distribution | active；catalog.ts 补充条目 `command-code`（npx `command-code@1.74.3 acp`） | registry 收录后自动让位；确认 registry 版本带 `acp` 子命令后删除 supplement |
-| zcode-acp-distribution | active；catalog.ts 补充条目 `zcode-acp`（npx `zcode-acp-server@0.63.0`），前置依赖 ZCode 本体 | registry#566/#650 合入后自动让位；删除 supplement 时保留 prerequisite |
+| qoder-native-acp | active；Catalog 固定官方 `@qoder-ai/qodercli@1.1.75 --acp`，由 `qoder-native-acp.json` 提供精确版本、资产和原/补丁哈希 | 与其他发布包补丁相同，Install/Update 只按 Catalog 钉版本和配方哈希应用；不读取认证表，也不要求用户提供 Qoder 登录态 |
+| kimi-code-distribution | active；catalog.ts 补充条目 `kimi-code`（Kimi Code 2.3.3 官方二进制，六平台 tar.gz + sha256，2026-10-27 nightly），隐藏已归档的 `kimi` | registry#458 合入后补充条目自动让位、版本由 registry 跟进；验证 Install/Update、复用登录后删除 supplement |
+| command-code-distribution | active；catalog.ts 补充条目 `command-code`（npx `command-code@1.88.0 acp`） | registry 收录后自动让位；确认 registry 版本带 `acp` 子命令后删除 supplement |
+| zcode-acp-distribution | active；catalog.ts 补充条目 `zcode-acp`（npx `zcode-acp-server@0.76.3`），前置依赖 ZCode 本体 | registry#566/#650 合入后自动让位；删除 supplement 时保留 prerequisite |
+| zcode-models | active；fresh-install 模型兑底并入账号目录（`loadAllModels` 兜底读 entitled builtin 表，GLM-5.3-Flash 等不再丢） | 上游 `loadAllModels` 并入账号快照目录后删除 |
+| zcode-subagent-subwork | active；zcode-acp-server 0.76.3 四文件九编辑：`AxomZcodeSubagents` 监听器把后端 `session.updated`（agentId/childSessionId/taskId）转发为 `subagent_spawned`/`subagent_state_update`（RFD #1992）与 `async_task_*`；dispatch 把 `tool_subagent_*` 内部调用重定址到 `sess_subagent_*` 子会话，协商到原生能力时抑制 `_meta.subagent` 标记（防双投影），声明 AIR asyncTasks 时抑制上游 `[后台]` 合成卡（防与 async_task 双重呈现，workflow 折叠不受影响）；`adoptStoredTitle` 在 (重)挂载时补发 `session_info_update` 同步后端已生成的标题（titleUpdated 推送会丢在 backend 重启断点上） | 上游 zcode-acp 原生发出 T2/T3 变体并路由子会话、且 load 时同步存量标题后删除配方；验收含并发、失败/取消、后台迟到、重启重放 |
 | claude-plan-tools | active；启动任务清单工具变量 | 无变量真实 ACP 会话能发布 plan 后下线 |
 | codex-plan-tools | active；CODEX_CONFIG 的 update_plan 开关 | 无覆盖真实 ACP 会话能发布 plan；保留显式用户配置优先级 |
-| claude-async-task-preview | active；registry 为 0.86.0 时钉 0.86.1-preview.2（`when_registry_version`） | 上游 #1249：不再从前台 Bash 文本猜后台任务、已结束 child 的 async 终态照常送达。registry 换成其他版本即不生效，确认正式版含修复后删除本条 |
+| claude-account-limits | active；配方 0.97.0，catalog 钉 0.97.0 | 上游 adapter 暴露标准化账号配额能力且不自动查询后删除；版本升级走 ../DAILY_UPGRADE_CHECK.md |
+| codex-account-limits | active；配方 2.3.0，catalog 钉 2.3.0 | 同上 |
+| codex-terminal-output | active；2.3.0，链在 codex-account-limits 后；终态保留完整 stdout 与退出码，避免流式输出遗漏首段 | 上游 AIR 命令终态无补丁即可保留完整输出后删除；探针 `probes/codex-terminal-output.mjs` 覆盖流式/非流式与成功/失败 |
+| commandcode-account-limits | active；配方 1.88.0（supplement 同钉） | 同上 |
+| antigravity-account-limits | active；native extension 1.3.0…1.4.3，catalog 钉 1.4.3（真实 .par 经 proxy 实测：透传无损、能力注入成功，最近 2026-10-25） | 官方 adapter 暴露配额读取与通知；上游发新版按 ../DAILY_UPGRADE_CHECK.md 核验后同升 |
+| claude-async-task-preview | retired；0.86.0 钉 0.86.1-preview.2 的 override 已删除 | 修复 #1249 自 0.87.0 起入正式版；2026-10-13 无补丁原版 0.90.0 探针 6/6 通过（探针构造器参数改 `"air"`，0.90.0 将 enabled 改名为 form） |
 | claude-late-async-terminal | retired；0.84.0/0.85.0 配方已删除 | 修复由上游 #1249 带入预览版并被采用；探针在无补丁预览版 6/6 通过 |
-| acp-sdk-draft-variants | active；draftInterceptor / draftSubagents | 发布 SDK 接收 subagent/async 变体后，验证真实通知流，再替换对应边界 |
-| acp-sdk-foreign-session | active；draftInterceptor | SDK 能路由不是当前客户端主动打开的子会话；仅支持 draft 类型不足以下线 |
+| acp-sdk-draft-variants | active；processor/updates（取代已删除的 draftInterceptor）/ draftSubagents | 发布 SDK 接收 subagent/async 变体后，验证真实通知流，再替换对应边界 |
+| acp-sdk-foreign-session | active；processor/updates（取代已删除的 draftInterceptor） | processor 对子会话 session/update 原样直通（不经 SDK schema）；正式 SDK schema 能校验子会话更新且改为先校验不丢通知后才下线；仅支持 draft 类型不足以下线 |
 | acp-sdk-capability-fields | active；acpClient / draftSubagents | 无兼容桥 initialize 能保留 subagents，且 AIR vendor 能力协商仍有效 |
-| qoder-subagent-origin / qoder-subagent-subwork | active；原生 Qoder 1.1.61 包补丁保留 `_meta.qoder`，适配器归一到 subwork | 无补丁版本的并发过程、终态、load/resume/重连全部通过后，删除包配方与边界；core/App 不加 Qoder 分支 |
+| pi-subagent-subwork | active；pi-acp 0.0.34 包补丁（链在 pi-steering 之后，catalog 钉 0.0.34）把 pi-subagents 派发/完成归一为 `subagent_spawned`/`subagent_state_update` | 无补丁 pi-acp 能发 T2 变体并透传 custom message 后移除；axom-cli/服务端零改动，processor 原生消费 |
+| kimi-subagent-subwork | active；Kimi native shim 将 Agent / AgentSwarm 转为同一套 T2 子会话事件，子结果进入只读子会话；后台启动回执不算完成，读取该 ACP 会话的原生 task 状态及 output.log 补发迟到终态；load 重放使用确定性 ID，resume 复用已知子会话。不产生原始 Agent 工具卡，不伪造上游没有发送的中间推理/工具流 | 上游原生协商 subagents 时自动让位；无补丁前台/后台/失败/取消/load/resume 实测通过后删除 shim 模块 |
+| qoder-native-acp | active；官方 Qoder 1.1.75 `--acp` 在同一进程内加载兼容 asset，沿用普通 package patch 安装路径 | 上游版本升级时重新核对原文件锚点和行为回归；通过后更新 recipe 的 `versions` 与 Catalog 钉版本 |
 | acp-registry-etarget | active；版本不存在时单次回退 | 上游版本可安装时自然不触发；删除整个策略要检查 registry 契约 |
 | claude-steering | draft；steering/ 的两份旧版 diff | 0.76/0.77 草案未经完整运行时验证，不自动应用；重新测 E1–E3 |
 | codex-steering | draft；steering/ 的旧版 diff | 1.10/1.11 草案不适用于当前新版，不自动应用；重新测 E1–E3 |
@@ -71,6 +90,9 @@ catalog 是 Axom 对官方 ACP registry 的本地扩展层，随 CLI 发布：
 每条完整路径、版本哈希、上游链接、删除条件与验证项见 [台账](../manifest.json)。
 steering diff 原样来自历史 notes；维护本目录文件及台账哈希，历史归档保留实验上下文。
 
+catalog 各 agent 的上游版本核查、补丁必要性判定与钉版本升级，按
+[`../DAILY_UPGRADE_CHECK.md`](../DAILY_UPGRADE_CHECK.md) 的周期任务执行（AI 可直接照步骤运行）.
+
 ## 验证
 
 ```bash
@@ -94,6 +116,9 @@ Pi 的发布包运行时探针（使用真实 adapter 类，不启动模型、
 ```bash
 node axom-patch/cli/probes/pi-steering.mjs /path/to/pristine/pi-acp --expect-unsupported
 node axom-patch/cli/probes/pi-steering.mjs /path/to/patched/pi-acp
+node axom-patch/cli/probes/pi-subagent-subwork.mjs /path/to/pristine/pi-acp --expect-no-subagents
+node axom-patch/cli/probes/pi-subagent-subwork.mjs /path/to/patched/pi-acp
+node axom-patch/cli/probes/kimi-subagent-subwork.mjs /path/to/managed/kimi
 ```
 
 仅已核验的原生 Pi 0.87.1 声明 `supported: true, timings: ["next"]`。其他原生版本不声明能力。
@@ -108,3 +133,88 @@ node axom-patch/cli/probes/pi-steering.mjs /path/to/patched/pi-acp
 - 新增来源/环境覆盖：修改 runtime.overrides、台账和 catalog 回归，保留 registry/用户显式 env 优先级。
 - 下线：先按统一证据门槛核验，从 runtime 移除策略或替换 SDK 边界，保留回归；台账标 retired 并记录证据。
 - CLI 补丁变化必须 bump CLI npm version。相同版本不会触发 Server 自动升级，不能只改 Server 镜像 tag。
+
+
+## Qoder native candidate certification (optional authoring evidence)
+
+这套认证脚本只服务于维护者做版本升级和补丁退休判断，不参与 CLI 的安装、启动或版本选择。
+Qoder 的当前运行路径和其他普通发布包补丁一致：Catalog 固定 `1.1.75`，`qoder-native-acp.json`
+按包版本和文件哈希应用。用户不需要认证表，也不需要先把 Qoder 登录态复制给 Axom；Qoder 自己在真正调用模型时的登录仍由 Qoder 管理。
+因此缺少某个平台的认证记录不会阻止普通补丁在该平台安装。
+`runtime.json` 的 `install_policies` 为 `@qoder-ai/qodercli` 声明 `ignore_scripts: true`：它的 postinstall 会执行
+`configure-path` 改写用户的 `~/.qoder/entry` 与 PATH，托管安装不能有这种副作用。这条策略与认证无关，只控制 npm lifecycle scripts。
+
+`qoder/scripts/certify.mjs --candidate <dir> --evidence <dir> --platform <platform> --arch <arch>`
+consumes the exact generated package plus sibling `.release.json` and `.recipe.json`.
+The command runs a bounded real initialize in a new isolated HOME/cwd. Explicit
+`--auth-home <source>` copies only the auth allowlist and enables the native model/tool
+cases in `src/test/certificationCases.ts`; credentials and isolated HOME contents are
+excluded from evidence artifact manifests. No SDK, relay or extra runtime
+agent is introduced. stderr (including upstream DEP0169) is retained separately from
+unmodified JSON-RPC traffic. Request IDs, native root/child IDs and tool IDs are retained.
+`--collect-only` verifies records in `<evidence>/records/*.json` without model execution.
+The command is directly executable with supported Node 24 from this authoring checkout.
+
+Required checks are `initialize`, `ordinary-input`, `permissions`, `images-settings`,
+`parallel-subagents`, `background-reconnect`, `next-append`, `next-button`, `stop`,
+`cached-resume`, `legacy-migration`, `explicit-load`, `replay`, `install-gates`, `platform`.
+Missing, duplicate, unknown, failed, mismatched or synthetic records produce NOT_PASS
+and a nonzero exit. Native tests cannot replace real UI insert-button evidence. The
+background case currently covers completion after the root response followed by process
+reconnect; it does not establish arbitrary mid-flight crash recovery. Migration, replay,
+installer and actual platform/UI evidence remain separate required producers.
+
+Digest schema v1 uses canonical JSON: recursively lexicographically sorted plain-object
+keys, array order preserved, JSON scalar encoding, finite numbers only; non-JSON values
+are rejected. `candidateDigest` is SHA256 of canonical
+`{domain:"axom-qoder-candidate-v1",release:<all release fields except certification>,
+suite:{id:<certification.suite>,files:<trusted source manifest>},actualFiles:<map>}`.
+The source manifest is the fixed `suiteFiles` list in `scripts/release.mjs`, read from
+this checkout; `suiteDigest` is SHA256 of canonical suite. `actualFiles` is the complete
+regular main-package map, excluding external `node_modules`, and must exactly equal
+`release.files`. Symlinks and unsafe paths refuse. New runtime fields are automatically
+bound; this includes `historyVersions`, `bin.args`, `runtimeTools`, and `patchDigest`.
+The latter is exactly SHA256(JSON.stringify(orderedRecipeObjects)), matching
+`managedPatches.patchDigest`, including asset records. No alternate recipe hash is used.
+
+Each evidence record is `{schema:1,name,status,kind,releaseId,candidateDigest,suiteDigest,
+platform,arch,node:{version,sha256},runtime:{dependencies,tools},artifacts:[{path,sha256}],
+detail?:<JSON>}`. `kind` is `real` or `test`. Artifact paths are relative to the evidence
+root. Node identity is the actual executing binary, not a supplied label. Dependencies
+record resolved direct/optional package versions and package.json hashes; tools record
+exact package/name/version, path, platform/arch, SHA256 and executability. Required
+native tool declarations must be authored before certification. This does not claim a
+complete third-party byte closure: npm integrity installation remains the dependency
+trust boundary. The verifier recomputes candidate, suite, Node, platform, dependencies,
+tools and artifact bytes before and after native work. A changed source manifest or any
+runtime-relevant release field invalidates old evidence. The synthetic reducer fixtures
+may report `schemaValid:true`, but always remain NOT_PASS for release authorization.
+
+Every invocation creates a fresh directory and writes result files exclusively.
+`result.sha256` hashes the exact UTF-8 `result.json` bytes (canonical JSON plus newline).
+The result contains records and bindings but no digest of itself. Final release
+`certification.checks/platforms` may therefore be assembled after verified real PASS
+without self-reference: only certification is excluded from the candidate projection,
+and its suite identity remains separately bound. Promotion must rerun `--collect-only`
+on the final bytes, use the verified result digest for its platform and exact record
+bytes/digests for checks, and preserve each platform/Node evidence relationship. Never
+reuse another platform's PASS by editing a label or copy PASS across regenerated bytes.
+
+Next evidence observes the original tool's real start artifact and in-progress stream,
+then appends next input and checks original completion plus appended-input files on the
+same root and single ACP prompt. A test-only native root engine wrapper counts actual
+`submitMessage`/`abort` calls; its transformed entry hash and original hash are recorded.
+An uninstrumented final-byte rerun is mandatory. Stop is tested separately, including
+queued-next removal and cancellation while a permission request is pending. Runtime
+instrumentation is never added to the generated release package.
+
+
+Ordinary-tool acceptance requires distinct original Bash, Read and Grep tool IDs, an
+exact-ID successful terminal update for each, and the unique artifact marker in actual
+Read/Grep result text. A successful Bash file alone cannot hide a missing/failed helper.
+Stop uses a unique queued nonce and a neutral followup. After native writer/process
+closure, the harness copies the full root transcript bytes, verifies root/cwd/version,
+requires the followup's original userMessageId, and rejects any consumed queued nonce.
+Both next runs provide a positive native `queued_command`/`source_uuid` history control.
+These transcript snapshots are hashed artifacts; failed/partial/forced-kill snapshots
+cannot establish removal. Known upstream DEP0169 remains visible in stderr.

package/dist/axom-patch/cli/account-limits/README.md

@@ -0,0 +1,27 @@
+# Account quota extension
+
+Axom extension, not an upstream ACP standard. ACP extension methods use `_axom/account/rateLimits/read` and `_axom/account/rateLimits/updated`. Capability: `agentCapabilities._meta["axom/accountRateLimits"] = {version: 2, read: true, updated: true}`. A read's result and an update's params have the same snapshot schema.
+
+Only the popover footer sends a read. Initialization, authentication, reconnects, session changes, turns, opening UI and reset deadlines do not query quota. Native Codex and Claude quota events are normalized without fetching. Command, Kimi and Antigravity publish updates from explicit reads; they do not synthesize a polling loop. UI SSE streams only database state.
+
+Initialization publishes an identity-only unknown observation of adapter support. It does not establish quota display eligibility. Reconnects replay each live session's cached observation with its original timestamp; they never fetch usage. A pre-upgrade hello roster cannot hide a stored capability observation. Version-gated installed native extensions also advertise support in the roster without spawning or querying the provider.
+
+Snapshots contain `schemaVersion`, `provider`, `billingMode`, `availability`, `observedAt`, nullable `plan`, independent `limits`, `balances` and bounded `_meta`. Optional `accountKey` must be opaque, never a credential. Modes are `subscription`, `non_subscription`, `unknown`; missing authentication or temporarily unavailable quota is unknown, not proof of API billing. `ExternalAgentAccountDto.supportsQuotaDisplay` is the shared eligibility rule for UI and server refresh: adapter support plus confirmed subscription billing, or an independent quota checker with unknown billing. The server identifies the existing Command Code, ZCode, Kimi and Antigravity readers through `quotaCheckerAvailable`, preserving their first manual discovery action. Non-subscription accounts expose no quota entry, and rejected refreshes do not claim a cooldown or contact the adapter. Codex/Claude authentication notifications establish billing without fetching quota; their unknown accounts remain hidden. Switching authentication publishes a complete identity snapshot to clear previous windows. Their processor also refuses quota reads until subscription authentication is confirmed. Future server-configured quota checkers should use this shared capability rather than add provider-specific UI branches.
+
+Windows use integer seconds (monthly calendar periods use `period: "month"`), percentage consumed in 0..100, ISO UTC timestamps and nullable unknown values. Absolute credits or monetary values are decimal strings; money uses currency and exponent. Scoped model quotas remain detailed rows, not duplicated general rings. When only model quotas exist, one ring represents the most used model, with an explicit popover explanation. Vendor fields remain under `_meta._codex`, `_claude`, `_kimi`, `_commandcode`, `_antigravity`. Latest snapshots persist per workstation/configured entry; delayed older updates are ignored. A server transaction admits one refresh per 60 seconds, including failures. Errors preserve the prior snapshot.
+
+Verified managed versions: Codex ACP 2.2.2; Claude ACP 0.89.1 (SDK experimental usage control); Command Code 1.74.3; native Kimi Code 2.1.1; ZCode ACP 0.69.3. New versions do not inherit unverified patches. Regenerate the npm recipes with `generate.py --codex <pristine-package-dir> --claude <pristine-package-dir> --commandcode <pristine-package-dir> [--zcode <pristine-package-dir>]`; update inventory artifact hashes after changes. Never patch a user's global installation.
+
+Kimi's native shim starts a temporary loopback web process only during an explicit read and calls the SDK-backed local usage route; process cleanup is bounded. Its native provider catalog identifies actual API credentials before querying managed quota. The common launcher selects this shim from `runtime.json.native_extensions`. Claude uses an existing session's query when possible, otherwise a nonpersistent SDK control session. Neither submits a model inference request for quota. Native payload availability can vary with login/provider/version; failed reads are surfaced without overwriting previous observations.
+
+`updateMode: "snapshot"` means a complete read or observation; `"delta"` updates only its supplied windows/balances. The server merges deltas transactionally by id (or equivalent window/scope for legacy Claude ids). Null partial measurements retain known values in the same reset period, with one-second timestamp rounding tolerance; a changed period becomes unknown rather than borrowing old utilization. Complete reads remove windows that are absent. Legacy update notifications without an explicit mode are treated as deltas by the CLI. Capability v2 lets explicit reads avoid old v1 session processes. No automatic query was added.
+
+Command's month window uses its native `getPlanInfo` allowance and remaining monthly credits; billing `currentPeriodEnd` supplies reset time. Unknown plans have unknown percentage rather than an inferred cap. Purchased/free credits stay separate balances. Claude emits only the affected event window; the weekly snapshot is first acquired through the footer's manual refresh and survives subsequent 5-hour events.
+
+ZCode's read resolves the individual coding-plan key through the adapter's own credential chain (`codingPlanRequestAuthFor`: legacy config.json first, then the encrypted `~/.zcode/v2/credentials.json` store #320 — the adapter's own `/quota` and `account/usage_stats` still read config.json only and stay broken on fresh 3.14.x installs; fixed upstream when they adopt the store path). The GLM quota endpoint returns plan `level` plus `limits[]` rows: `TOKENS_LIMIT number=5` is the 5h prompt window (percentage-only, no counters), `number=7` a weekly window when a plan has one, `TIME_LIMIT`/`MCP_LIMIT` the built-in tool allowance with absolute call counts and per-model detail (kept in `_meta._zcode`). The endpoint offers no monthly window on any measured plan; nothing is inferred. The read throws when no entitled individual plan is servable (team keys are deliberately not served by the adapter), which surfaces as a standard refresh failure.
+
+Antigravity's native extension is limited to official ACP **1.3.0**. Its bundled discovery document defines `ModelDetails.quotaInfo.remainingFraction` (remaining, not consumed), `resetTime`, and `UserTier.availableCredits`. The sidecar reproduces the native consumer `loadCodeAssist` endpoint selection and reads `fetchAvailableModels` only on an explicit read. It does not perform onboarding, inference, alter settings, or write refreshed OAuth credentials. It uses the same `GEMINI_HOME/antigravity-acp` settings and consumer token store (`gemini` / `antigravity-acp` Keychain on macOS, secure-file fallback; `AGY_ACP_FORCE_FILE_STORAGE` respected). Explicit successful ACP authentication overrides the file's auth type. API key, Agent Platform, enterprise OAuth and gateway are outside this consumer subscription integration.
+
+The quota schema supplies no window duration or monthly allowance: keep `windowSeconds: null`, list each model and its reset, and keep AI credits as a balance. Do not infer shared buckets from identical percentages/reset times. Extensions allowlist quota/tier fields and exclude project, tokens and account identity. Official ACP `usage_update` is context-token usage, not an account quota notification; it is never converted into subscription usage. No spontaneous account quota notification is exposed in 1.3.0. Protocol/normalization tests pass against the bundled native schema; a live read on the development machine could not be measured because its Keychain credential read timed out. A locked/inaccessible store surfaces the standard refresh failure and preserves the last snapshot.
+
+Antigravity quota capability v3 fixes interactive Keychain authorization: the first explicit read permits up to 120 seconds for the OS dialog, within longer quota-specific CLI/server/client deadlines. A successful credential read and refreshed access token stay only in the reader process's memory; subsequent manual reads do not re-open Keychain. Explicit authentication/logout invalidates that cache, and failed credential loads are retryable. This matters because the native ACP credential writer deletes and recreates the Keychain item, potentially invalidating previous per-item “Always Allow” grants. No ACL, partition list or native credential file is modified by Axom. Older v2 model sessions are bypassed for quota reads without interruption. When necessary, a separate control connection is retained across manual reads, closed on authentication changes and CLI shutdown; it performs no background quota queries. Tests simulate delayed authorization and repeated reads without invoking the real password dialog; live OS authorization remains a user-side verification step.

package/dist/axom-patch/cli/account-limits/antigravity-proxy.mjs

@@ -0,0 +1,47 @@
+/** Version-gated native ACP sidecar. Never queries on initialize, auth, turns or timers. */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { READ, UPDATED, CAPABILITY } from './normalize.mjs';
+import { readAntigravity, clearAntigravityCredentials } from './antigravity-read.mjs';
+const [binary, ...args] = process.argv.slice(2);
+const child = spawn(binary, args, { stdio: ['pipe', 'pipe', 'inherit'], env: process.env });
+const write = value => process.stdout.write(JSON.stringify(value) + '\n');
+let initializeId, authType, reading = false;
+const authRequests = new Map();
+createInterface({ input: child.stdout }).on('line', line => {
+  let message; try { message = JSON.parse(line); } catch { process.stdout.write(line + '\n'); return; }
+  if (message.id === initializeId && message.result) {
+    message.result.agentCapabilities ??= {};
+    message.result.agentCapabilities._meta ??= {};
+    message.result.agentCapabilities._meta['axom/accountRateLimits'] = { ...CAPABILITY, version: 5, provider: 'antigravity' };
+  }
+  if (authRequests.has(message.id)) {
+    if (message.result && !message.error) { authType = authRequests.get(message.id); clearAntigravityCredentials(); }
+    authRequests.delete(message.id);
+  }
+  write(message);
+});
+createInterface({ input: process.stdin }).on('line', line => {
+  let message; try { message = JSON.parse(line); } catch { child.stdin.write(line + '\n'); return; }
+  if (message.method === 'initialize') initializeId = message.id;
+  if (message.method === 'authenticate' && message.id !== undefined) authRequests.set(message.id, message.params?.methodId);
+  if (message.method === 'logout') { authType = undefined; clearAntigravityCredentials(); }
+  if (message.method === READ && message.id !== undefined) {
+    if (reading) { write({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'A usage refresh is already in progress' } }); return; }
+    reading = true;
+    void readAntigravity({ authType }).then(result => {
+      write({ jsonrpc: '2.0', id: message.id, result });
+      write({ jsonrpc: '2.0', method: UPDATED, params: result });
+    }, error => {
+      if (/^Antigravity (oauth|account|quota) request failed \(HTTP \d{3}\)$/.test(error?.message ?? '')) process.stderr.write(`${error.message}\n`);
+      write({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'Failed to fetch usage' } });
+    })
+      .finally(() => { reading = false; });
+    return;
+  }
+  child.stdin.write(line + '\n');
+});
+process.stdin.on('end', () => child.stdin.end());
+for (const signal of ['SIGTERM', 'SIGINT']) process.on(signal, () => child.kill(signal));
+child.on('error', () => { process.exitCode = 1; });
+child.on('exit', code => process.exit(code ?? 1));

package/dist/axom-patch/cli/account-limits/antigravity-read.mjs

@@ -0,0 +1,90 @@
+/** All credential access and network I/O occur only inside an explicit quota read. */
+import { readFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { homedir, type, machine } from 'node:os';
+import { join } from 'node:path';
+import { antigravity } from './antigravity.mjs';
+const execute = promisify(execFile);
+const PROD = 'https://cloudcode-pa.googleapis.com';
+const DAILY = 'https://daily-cloudcode-pa.googleapis.com';
+// Official ACP 1.3.0 useragent.py: CCPA uses the antigravity token to resolve
+// client-specific entitlements. A generic fetch User-Agent resolves the wrong tier.
+const USER_AGENT = `antigravity/acp/1.3.0 (aidev_client; os_type=${process.platform === 'win32' ? 'windows' : type().toLowerCase()}; arch=${machine().toLowerCase()}; host_path=axom/unknown; proxy_client=antigravity/sdk)`;
+async function jsonFile(path) {
+  try { return JSON.parse(await readFile(path, 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw new Error('Failed to read Antigravity settings'); }
+}
+export async function loadAntigravityCredentials(root, env, { platform = process.platform, executeKeychain = execute } = {}) {
+  if (platform === 'darwin' && !['1', 'true'].includes(env.AGY_ACP_FORCE_FILE_STORAGE)) {
+    try {
+      // This is an interactive authorization, not a three-second background probe.
+      const { stdout } = await executeKeychain('/usr/bin/security', ['find-generic-password', '-s', 'gemini', '-a', 'antigravity-acp', '-w'], { timeout: 120000, maxBuffer: 65536 });
+      return JSON.parse(stdout);
+    } catch { /* Official store's secure-file fallback; never prompt for login here. */ }
+  }
+  return jsonFile(join(root, 'acp_token.json'));
+}
+/** Process-local only. A native token rewrite must not make every footer refresh reauthorize. */
+export function createCredentialCache(read) {
+  const entries = new Map();
+  return {
+    clear: () => entries.clear(),
+    async load(root, env) {
+      const key = `${root}:${env.AGY_ACP_FORCE_FILE_STORAGE ?? ''}`;
+      if (!entries.has(key)) {
+        const pending = Promise.resolve().then(() => read(root, env));
+        entries.set(key, pending);
+        void pending.then(value => { if (!value && entries.get(key) === pending) entries.delete(key); }, () => { if (entries.get(key) === pending) entries.delete(key); });
+      }
+      return entries.get(key);
+    },
+  };
+}
+const credentialCache = createCredentialCache(loadAntigravityCredentials);
+export const clearAntigravityCredentials = () => credentialCache.clear();
+export async function readAntigravity({ authType, env = process.env, request = fetch, loadCredentials = credentialCache.load } = {}) {
+  const root = join(env.GEMINI_HOME?.trim() || join(homedir(), '.gemini'), 'antigravity-acp');
+  authType ??= (await jsonFile(join(root, 'settings.json')))?.auth?.type;
+  if (authType !== 'oauth-personal') return antigravity({}, authType);
+  const saved = await loadCredentials(root, env);
+  if (!saved) throw new Error('Antigravity credentials unavailable');
+  const signal = AbortSignal.timeout(20000);
+  const call = async (url, body, headers = {}) => {
+    const response = await request(url, { method: 'POST', headers, body, signal });
+    if (!response.ok) {
+      if (url === 'https://oauth2.googleapis.com/token' || response.status === 401) credentialCache.clear();
+      // No response bodies, project identifiers or credentials in diagnostics.
+      const stage = url.endsWith('/token') ? 'oauth' : url.endsWith(':loadCodeAssist') ? 'account' : 'quota';
+      throw new Error(`Antigravity ${stage} request failed (HTTP ${response.status})`);
+    }
+    return response.json();
+  };
+  let token = saved.token;
+  const expiry = Date.parse(saved.expiry ?? '');
+  if (!token || !Number.isFinite(expiry) || expiry <= Date.now() + 60000) {
+    if (!saved.refresh_token || !saved.client_id || !saved.client_secret) throw new Error('Antigravity credentials expired');
+    const refreshed = await call('https://oauth2.googleapis.com/token', new URLSearchParams({
+      grant_type: 'refresh_token', refresh_token: saved.refresh_token, client_id: saved.client_id, client_secret: saved.client_secret,
+    }), { 'Content-Type': 'application/x-www-form-urlencoded' });
+    token = refreshed.access_token;
+    if (typeof token === 'string' && token) {
+      saved.token = token;
+      saved.expiry = typeof refreshed.expires_in === 'number' && Number.isFinite(refreshed.expires_in) && refreshed.expires_in > 0 && refreshed.expires_in <= 86400
+        ? new Date(Date.now() + refreshed.expires_in * 1000).toISOString() : undefined;
+    }
+    // Keep refresh in memory: a quota read must not race the native adapter's credential writes.
+  }
+  if (typeof token !== 'string' || !token) throw new Error('Antigravity credentials unavailable');
+  const headers = { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'User-Agent': USER_AGENT };
+  const load = await call(`${PROD}/v1internal:loadCodeAssist`, JSON.stringify({ metadata: { ideType: 'ANTIGRAVITY' } }), headers);
+  const project = load.cloudaicompanionProject ?? saved.project_id;
+  if (typeof project !== 'string' || !project) throw new Error('Antigravity account is not onboarded');
+  // Match the official consumer ACP endpoint selection; never perform onboarding or change settings.
+  const endpoint = load.paidTier?.usesGcpTos === true ? PROD : DAILY;
+  const summary = await call(`${endpoint}/v1internal:retrieveUserQuotaSummary`, JSON.stringify({ project }), headers);
+  if (!Array.isArray(summary.groups) && !Array.isArray(summary.buckets)) throw new Error('Invalid Antigravity quota response');
+  const result = antigravity({ quotaSummary: summary, currentTier: load.currentTier, paidTier: load.paidTier }, authType);
+  if (result.availability === 'unavailable') throw new Error('Antigravity quota unavailable');
+  return result;
+}

package/dist/axom-patch/cli/account-limits/antigravity.mjs

@@ -0,0 +1,46 @@
+/** Antigravity ACP 1.3.0: schema from its bundled Cloud Code discovery document. */
+import { windowKey } from './normalize.mjs';
+export function antigravity(raw = {}, authType, observedAt = new Date().toISOString()) {
+  const billingMode = authType === 'oauth-personal' ? 'subscription'
+    : ['gemini-api-key', 'vertex-ai', 'agent-platform', 'oauth-business', 'gateway'].includes(authType) ? 'non_subscription' : 'unknown';
+  const tier = raw.paidTier ?? raw.currentTier;
+  // Deliberate allowlist: never persist tokens, account email, project or routing metadata.
+  const models = Object.fromEntries(Object.entries(raw.models ?? {}).map(([id, m]) => [id, {
+    displayName: m?.displayName, quotaInfo: m?.quotaInfo ? { remainingFraction: m.quotaInfo.remainingFraction, resetTime: m.quotaInfo.resetTime } : undefined,
+  }]));
+  const out = { schemaVersion: 1, updateMode: 'snapshot', provider: 'antigravity', billingMode,
+    availability: billingMode === 'subscription' ? 'available' : billingMode === 'unknown' ? 'unknown' : 'not_applicable',
+    observedAt, plan: tier?.id ? { id: tier.id, label: tier.name ?? tier.id } : null,
+    limits: [], balances: [], _meta: { _antigravity: { authType, models } } };
+  if (billingMode !== 'subscription') return out;
+  // Use Google's summary buckets, never infer shared pools or periods from model names.
+  const summary = raw.quotaSummary ?? {};
+  const groups = Array.isArray(summary.groups) ? summary.groups : [];
+  const rows = groups.length ? groups.flatMap(g => (g.buckets ?? []).map(bucket => ({ bucket, group: g.displayName })))
+    : (summary.buckets ?? []).map(bucket => ({ bucket, group: bucket.bucketId?.startsWith('gemini-') ? 'Gemini Models'
+      : bucket.bucketId?.startsWith('3p-') ? 'Claude and GPT models' : bucket.displayName }));
+  out._meta._antigravity.quotaSummary = { groups: [] };
+  const seen = new Set();
+  for (const { bucket: q, group } of rows) {
+    if (typeof q.bucketId !== 'string' || !q.bucketId || seen.has(q.bucketId)) continue;
+    seen.add(q.bucketId);
+    const fraction = q.remainingFraction;
+    const valid = typeof fraction === 'number' && Number.isFinite(fraction) && fraction >= 0 && fraction <= 1;
+    const usedPercent = valid ? Math.round((1 - fraction) * 10000) / 100 : null;
+    const date = typeof q.resetTime === 'string' ? new Date(q.resetTime) : null;
+    const windowSeconds = q.window === 'weekly' ? 604800 : q.window === '5h' ? 18000 : null;
+    out.limits.push({ id: `antigravity.${q.bucketId}`, label: q.displayName ?? q.bucketId, kind: 'subscription',
+      windowSeconds, key: windowKey(windowSeconds), usedPercent, resetsAt: date && Number.isFinite(date.getTime()) ? date.toISOString() : null,
+      active: q.disabled !== true,
+      status: !valid || q.disabled === true ? 'unknown' : fraction === 0 ? 'blocked' : usedPercent >= 80 ? 'warning' : 'allowed',
+      scope: { group: { id: q.bucketId.replace(/-(weekly|5h)$/, ''), display_name: group ?? 'Model quota' } } });
+    out._meta._antigravity.quotaSummary.groups.push({ displayName: group, bucketId: q.bucketId,
+      window: q.window, remainingFraction: valid ? fraction : null, resetTime: out.limits.at(-1).resetsAt, disabled: q.disabled === true });
+  }
+  for (const credit of tier?.availableCredits ?? []) {
+    const remaining = typeof credit.creditAmount === 'string' && /^\d+$/.test(credit.creditAmount) ? credit.creditAmount : null;
+    if (credit.creditType === 'GOOGLE_ONE_AI') out.balances.push({ id: 'antigravity.google-one-ai', label: 'AI credits', remaining, unit: 'credits', unlimited: false });
+  }
+  if (!out.limits.length && !out.balances.length) out.availability = 'unavailable';
+  return out;
+}

package/dist/axom-patch/cli/account-limits/generate.py

@@ -0,0 +1,123 @@
+from pathlib import Path
+import json,hashlib
+import argparse
+parser=argparse.ArgumentParser(description='Regenerate exact-version quota recipes from pristine adapter package directories')
+for name in ('codex','claude','commandcode'): parser.add_argument('--'+name,required=True,type=Path)
+parser.add_argument('--zcode',required=False,type=Path,help='Also regenerate the zcode recipe (zcode-acp-server)')
+options=parser.parse_args()
+root=Path(__file__).resolve().parents[3]
+module=(root/'axom-patch/cli/account-limits/normalize.mjs').read_text().replace('export ','')
+helper='\nconst axomQuota = (() => {\n'+module+'\nreturn {READ,UPDATED,CAPABILITY,codex,codexEvent,claude,claudeEvent,kimi,commandcode,zcode};\n})();\nconst axomQuotaNotify = snapshot => process.stdout.write(JSON.stringify({jsonrpc:"2.0",method:axomQuota.UPDATED,params:snapshot})+"\\n");\n'
+roots={name:getattr(options,name) for name in ('codex','claude','commandcode')}
+if options.zcode: roots['zcode']=options.zcode
+def patch(kind,file,version,pkg,changes,suffix='-account-limits',helper_text=helper,root_dir=None):
+ s=((root_dir or roots[kind])/file).read_text(); edits=[]
+ # The helper follows imports/shebang safely. Appending declarations executes before asynchronous requests.
+ if helper_text is not None:
+  changes.append((s[:100], (s.split('\n',1)[0]+'\n'+helper_text+s.split('\n',1)[1][:100-len(s.split('\n',1)[0])-1]) if s.startswith('#!') else helper_text+s[:100]))
+ for before,after in changes:
+  assert s.count(before)==1,(kind,before[:60],s.count(before))
+  n=s.replace(before,after)
+  edits.append(dict(file=file,before_sha256=hashlib.sha256(s.encode()).hexdigest(),after_sha256=hashlib.sha256(n.encode()).hexdigest(),before=before,after=after))
+  s=n
+ recipe=dict(id=kind+suffix,package=pkg,versions=[version],edits=edits)
+ (root/f'axom-patch/cli/{kind}{suffix}.json').write_text(json.dumps(recipe,ensure_ascii=False,indent=2)+'\n')
+# No initialization queries: only declare the capability, and forward native events.
+patch('codex','dist/index.js','2.3.0','@agentclientprotocol/codex-acp',[
+ # 2.3.0 repeats the authStatus line in a second capabilities block; extend through the
+ # initialize-only follower (authMethods:) to stay unique.
+ ('[AUTH_STATUS_META_KEY]: authStatusCapability()\n        }\n      },\n      authMethods:','[AUTH_STATUS_META_KEY]: authStatusCapability(), "axom/accountRateLimits": {...axomQuota.CAPABILITY,provider:"codex",authBillingModes:{account:"subscription",api_key:"non_subscription",external:"non_subscription",gateway:"non_subscription",none:"unknown"}}\n        }\n      },\n      authMethods:'),
+ ('this.handleRateLimitsUpdated(notification.params);\n        return null;', 'this.handleRateLimitsUpdated(notification.params);\n        axomQuotaNotify(axomQuota.codexEvent(notification.params, this.sessionState.account?.type ?? "unknown"));\n        return null;'),
+ ('.onRequest("authentication/status", emptyExtensionParamsParser,', '.onRequest(axomQuota.READ, emptyExtensionParamsParser, async () => { const agent=getAgent(); const account=(await agent.runWithProcessCheck(()=>agent.codexAcpClient.getAccount())).account; if (!account) throw new Error("Not authenticated"); if (account.type !== "chatgpt") return axomQuota.codex({},account.type); const raw=await agent.runWithProcessCheck(()=>agent.codexAcpClient.getRateLimits()); const snapshot=axomQuota.codex(raw,account.type); axomQuotaNotify(snapshot); return snapshot; }).onRequest("authentication/status", emptyExtensionParamsParser,')])
+patch('claude','dist/acp-agent.js','0.97.0','@agentclientprotocol/claude-agent-acp',[
+ ('authStatus: authStatusCapability(),','authStatus: authStatusCapability(), "axom/accountRateLimits": {...axomQuota.CAPABILITY,provider:"claude",authBillingModes:{account:"subscription",api_key:"non_subscription",external:"non_subscription",gateway:"non_subscription",none:"unknown"}},'),
+ ('case "rate_limit_event": {','case "rate_limit_event": {\n                        this.axomAccountLimits = axomQuota.claudeEvent(message.rate_limit_info, this.axomAccountLimits);\n                        axomQuotaNotify(this.axomAccountLimits);'),
+ ('.onRequest(methods.agent.session.new,', '.onRequest(axomQuota.READ, {parse: value => value ?? {}}, async ctx => { const session=agent.sessions[ctx.params.sessionId] ?? Object.values(agent.sessions)[0]; const owned=!session?.query; const q=session?.query ?? query({prompt:"/usage",options:{cwd:ctx.params.cwd??process.cwd(),persistSession:false}}); let raw;try{const auth=fromAccountInfo(await q.accountInfo()); if(["api_key","external","gateway"].includes(auth?.kind)){raw={billing_mode:"non_subscription",rate_limits_available:false};}else{raw=await q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({skipBehaviors:true});raw.subscription_type??=auth?.account?.plan;raw.billing_mode=auth?.kind==="account"?"subscription":"unknown";}}finally{if(owned)q.close();} agent.axomAccountLimits=axomQuota.claude({subscription_type:raw.subscription_type,rate_limits_available:raw.rate_limits_available,rate_limits:raw.rate_limits,billing_mode:raw.billing_mode}); if(agent.axomAccountLimits.billingMode==="unknown" || agent.axomAccountLimits.availability==="unavailable") throw new Error("Failed to fetch usage"); axomQuotaNotify(agent.axomAccountLimits); return agent.axomAccountLimits; })\n        .onRequest(methods.agent.session.new,')])
+patch('commandcode','dist/cli.mjs','1.88.0','command-code',[
+ # 1.82.1 renamed the handler map (u/dn -> m/hn) and gave INITIALIZE an explicit arrow body; 1.84.0
+ # the enum renames every release (hn->vn->bn). The read method still goes first in the same map.
+ ('const m={[bn.INITIALIZE]:e=>handleInitialize(e),[bn.AUTHENTICATE]','const m={["_axom/account/rateLimits/read"]:async()=>{const raw=await fetchUsageData2(); if(raw.errors.length) throw new Error("Failed to fetch usage"); const snapshot=axomQuota.commandcode({credits:raw.credits,subscription:raw.subscription,orgLimits:raw.whoami?.orgLimits??[],monthly:{limit:raw.subscription?.data?.status==="active"?(getPlanInfo({planId:raw.subscription?.data?.planId??""})?.monthlyCredits??null):null}}); axomQuotaNotify(snapshot); return snapshot;},[bn.INITIALIZE]:e=>handleInitialize(e),[bn.AUTHENTICATE]'),
+ ('agentCapabilities:{loadSession:!0,promptCapabilities:', 'agentCapabilities:{_meta:{"axom/accountRateLimits":{...axomQuota.CAPABILITY,provider:"commandcode"}},loadSession:!0,promptCapabilities:')])
+if options.zcode: patch('zcode','dist/index.js','0.76.3','zcode-acp-server',[
+ # 0.72.0 moved the legacy usage_stats body to handlers/account.js as accountUsageStatsViaHub.
+ ('        .onRequest("account/usage_stats", z.object({}).passthrough(), () => accountUsageStatsViaHub())',
+  '        .onRequest(axomQuota.READ, z.object({}).passthrough(), async () => {\n'
+  '            const { buildAccountProviderConfig, codingPlanRequestAuthFor } = await import("./config/account-provider.js");\n'
+  '            const { resolveQuotaHost } = await import("./quota/client.js");\n'
+  '            let apiKey = null, family = "";\n'
+  '            for (const [providerId, provider] of Object.entries(buildAccountProviderConfig()?.providers ?? {})) {\n'
+  '                if (!provider?.access?.entitled) continue;\n'
+  '                const auth = codingPlanRequestAuthFor(providerId);\n'
+  '                if (auth?.apiKey) { apiKey = auth.apiKey; family = providerId; break; }\n'
+  '            }\n'
+  '            if (!apiKey) throw new Error("No entitled GLM coding plan: sign in once in the ZCode desktop app");\n'
+  '            const resp = await fetch(resolveQuotaHost(family.startsWith("account:zai") ? "https://api.z.ai" : "") + "/api/monitor/usage/quota/limit", { headers: { Accept: "application/json, text/plain, */*", Authorization: "Bearer " + apiKey }, signal: AbortSignal.timeout(8000) });\n'
+  '            const text = await resp.text();\n'
+  '            let json = null; try { json = text ? JSON.parse(text) : null; } catch {}\n'
+  '            if (resp.status === 429 || !json || json.success !== true) throw new Error("GLM quota read failed" + (json?.msg ? ": " + json.msg : " (HTTP " + resp.status + ")"));\n'
+  '            const snapshot = axomQuota.zcode({ provider: family, level: json.data?.level, limits: json.data?.limits });\n'
+  '            axomQuotaNotify(snapshot);\n'
+  '            return snapshot;\n'
+ '        })\n'
+ '        .onRequest("account/usage_stats", z.object({}).passthrough(), () => accountUsageStatsViaHub())'),
+ ('        .onRequest("initialize", (ctx) => server.initialize(ctx.params, ctx.client))',
+  '        .onRequest("initialize", async (ctx) => { const result = await server.initialize(ctx.params, ctx.client); const caps = result.agentCapabilities ?? {}; result.agentCapabilities = { ...caps, _meta: { ...caps._meta, "axom/accountRateLimits": { ...axomQuota.CAPABILITY, provider: "zcode" } } }; return result; })')])
+models_fn='''function axomFreshInstallModels() {
+    const fallback = { providerId: DEFAULT_PROVIDER_ID, providerName: DEFAULT_PROVIDER_NAME, modelId: DEFAULT_MODEL_ID };
+    try {
+        const out = [];
+        for (const [pid, p] of Object.entries(axomAccountProviders()?.providers ?? {})) {
+            if (!p?.access?.entitled || !axomPlanAuth(pid)?.apiKey) continue;
+            const providerId = configProviderIdFor(pid);
+            for (const modelId of p.builtinModelIds ?? []) {
+                if (out.some((m) => m.providerId === providerId && m.modelId === modelId)) continue;
+                out.push({ providerId, providerName: providerId, modelId });
+            }
+        }
+        if (out.length === 0) return [fallback];
+        return out.some((m) => m.providerId === fallback.providerId && m.modelId === fallback.modelId)
+            ? [fallback, ...out.filter((m) => !(m.providerId === fallback.providerId && m.modelId === fallback.modelId))]
+            : [fallback, ...out];
+    }
+    catch {
+        return [fallback];
+    }
+}
+'''
+if options.zcode: patch('zcode-models','dist/config/options.js','0.76.3','zcode-acp-server',[
+ ('import { configProviderIdFor } from "./account-provider.js";',
+  'import { buildAccountProviderConfig as axomAccountProviders, codingPlanRequestAuthFor as axomPlanAuth, configProviderIdFor } from "./account-provider.js";'),
+ ('/** Read the config.json contents (UTF-8). Throws on read/parse failure. */',
+  models_fn+'\n/** Read the config.json contents (UTF-8). Throws on read/parse failure. */'),
+ ('''        if (out.length === 0 && Object.keys(cfg.provider ?? {}).length === 0) {
+            return [
+                {
+                    providerId: DEFAULT_PROVIDER_ID,
+                    providerName: DEFAULT_PROVIDER_NAME,
+                    modelId: DEFAULT_MODEL_ID,
+                },
+            ];
+        }''',
+  '        if (out.length === 0 && Object.keys(cfg.provider ?? {}).length === 0) {\n            return axomFreshInstallModels();\n        }'),
+ ('''        if (out.length > 0)
+            return out;
+        return [
+            {
+                providerId: DEFAULT_PROVIDER_ID,
+                providerName: DEFAULT_PROVIDER_NAME,
+                modelId: DEFAULT_MODEL_ID,
+            },
+        ];
+    }
+}''',
+  '        if (out.length > 0)\n            return out;\n        return axomFreshInstallModels();\n    }\n}'),
+],suffix='',helper_text=None,root_dir=options.zcode)
+runtime=root/'axom-patch/cli/runtime.json'; data=json.loads(runtime.read_text())
+for kind in roots:
+ name=kind+'-account-limits.json'
+ if name not in data['package_patches']:data['package_patches'].append(name)
+if options.zcode:
+ name='zcode-models.json'
+ if name not in data['package_patches']:data['package_patches'].append(name)
+runtime.write_text(json.dumps(data,indent=2)+'\n')
+print('Generated exact-version recipes'+(' including zcode' if options.zcode else ''))