@platless/axom-cli 0.3.13 → 0.5.9

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 比**；上游新版本要等
+[`nightly-task.md`](nightly-task.md) 的周期任务核验移植配方后再 bump，届时
+`reconcileCertifiedBuilds` 把已安装的工作站自动前移。
+发布包补丁由 `managedPatches.ts` 在 Install/Update 和首次真实启动时应用。
 历史安装也会补齐，配置显式 command 的用户自有启动程序按其配置执行。
 
 发布包补丁步骤：
@@ -53,17 +62,25 @@ catalog 是 Axom 对官方 ACP registry 的本地扩展层，随 CLI 发布：
 
 | 台账 ID | 状态/应用入口 | AI 核验与下线重点 |
 |---|---|---|
+| qoder-registry-catch-up | active；registry 低于 1.1.71（或版本不可解析）时安装已验证的 `@qoder-ai/qodercli@1.1.71 --acp` | registry 达到 1.1.71 或更高时自动让位；核实上游条目可安装后移除本 override。仅移除安装来源覆盖，不同时删除 subagent/插话的版本限定补丁 |
 | 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 |
+| command-code-distribution | active；catalog.ts 补充条目 `command-code`（npx `command-code@1.82.1 acp`） | registry 收录后自动让位；确认 registry 版本带 `acp` 子命令后删除 supplement |
+| zcode-acp-distribution | active；catalog.ts 补充条目 `zcode-acp`（npx `zcode-acp-server@0.69.4`），前置依赖 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.69.3/0.69.4（目标文件字节一致）三文件九编辑：`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.90.0，catalog 钉 0.90.0 | 上游 adapter 暴露标准化账号配额能力且不自动查询后删除；版本升级走 nightly-task.md |
+| codex-account-limits | active；配方 2.2.2，catalog 钉 2.2.2 | 同上 |
+| commandcode-account-limits | active；配方 1.82.1（supplement 同钉） | 同上 |
+| antigravity-account-limits | active；native extension 1.3.0/1.4.0，catalog 钉 1.4.0（真实 .par 经 proxy 实测：透传无损、能力注入成功，2026-10-14） | 官方 adapter 暴露配额读取与通知；上游发新版按 nightly-task.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 原生消费 |
+| qoder-subagent-origin / qoder-subagent-subwork | active；原生 Qoder 1.1.71 包补丁保留 `_meta.qoder`，适配器归一到 subwork | 无补丁版本的并发过程、终态、load/resume/重连全部通过后，删除包配方与边界；core/App 不加 Qoder 分支 |
 | 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 +88,9 @@ catalog 是 Axom 对官方 ACP registry 的本地扩展层，随 CLI 发布：
 每条完整路径、版本哈希、上游链接、删除条件与验证项见 [台账](../manifest.json)。
 steering diff 原样来自历史 notes；维护本目录文件及台账哈希，历史归档保留实验上下文。
 
+catalog 各 agent 的上游版本核查、补丁必要性判定与钉版本升级，按
+[`nightly-task.md`](nightly-task.md) 的周期任务执行（AI 可直接照步骤运行）。
+
 ## 验证
 
 ```bash
@@ -94,6 +114,8 @@ 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
 ```
 
 仅已核验的原生 Pi 0.87.1 声明 `supported: true, timings: ["next"]`。其他原生版本不声明能力。

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,120 @@
+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.2.2','@agentclientprotocol/codex-acp',[
+ ('[AUTH_STATUS_META_KEY]: authStatusCapability()','[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"}}'),
+ ('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.90.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.82.1','command-code',[
+ # 1.82.1 renamed the handler map (u/dn -> m/hn) and gave INITIALIZE an explicit arrow body; the
+ # read method still goes first in the same map.
+ ('const m={[hn.INITIALIZE]:e=>handleInitialize(e),[hn.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;},[hn.INITIALIZE]:e=>handleInitialize(e),[hn.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.69.4','zcode-acp-server',[
+ ('        .onRequest("account/usage_stats", z.object({}).passthrough(), () => accountUsageStats())',
+  '        .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(), () => accountUsageStats())'),
+ ('        .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.69.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 ''))

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

@@ -0,0 +1,64 @@
+/** Verified Kimi 2.1.1 ACP extension shim. The web usage route is invoked ONLY for an explicit read. */
+import {spawn} from 'node:child_process';
+import {createInterface} from 'node:readline';
+import {readFile} from 'node:fs/promises';
+import {createServer} from 'node:net';
+import {homedir} from 'node:os';
+import {join} from 'node:path';
+import {READ, UPDATED, CAPABILITY, kimi} from './normalize.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; let reading=false; let selectedModel;
+async function usage() {
+  if(reading) throw new Error('A usage refresh is already in progress'); reading=true;
+  let web;
+  try {
+    const port=await new Promise((resolve,reject)=>{const server=createServer();server.on('error',reject);server.listen(0,'127.0.0.1',()=>{const port=server.address().port;server.close(()=>resolve(port));});});
+    web=spawn(binary,['web','--port',String(port),'--no-open'],{stdio:'ignore',env:process.env});
+    let spawnError;web.on('error',error=>{spawnError=error;});
+    const controller=new AbortController();const timeout=setTimeout(()=>controller.abort(),20000);
+    try {
+      for(let attempt=0;attempt<60;attempt++) {
+        if(spawnError)throw spawnError;
+        if(web.exitCode!==null) throw new Error('The Kimi usage service exited');
+        try {
+          const token=(await readFile(join(process.env.KIMI_CODE_HOME??join(homedir(),'.kimi-code'),'server.token'),'utf8')).trim();
+          const request=async path=>{const response=await fetch(`http://127.0.0.1:${port}/api/v1/${path}`,{headers:{Authorization:`Bearer ${token}`},signal:controller.signal});if(!response.ok)throw new Error('Failed to fetch usage');return response.json();};
+          // Native catalog resolves credentials, including environment overrides, without exposing keys.
+          const config=(await request('config')).data;
+          const providers=(await request('providers')).data?.items??[];
+          const model=config?.models?.[selectedModel??config?.default_model];
+          const provider=providers.find(p=>p.id===(model?.providerId??model?.provider_id??model?.provider??config?.default_provider));
+          if(provider?.has_api_key===true || (provider && provider.id!=='managed:kimi-code'))return {schemaVersion:1,provider:'kimi',billingMode:'non_subscription',availability:'not_applicable',observedAt:new Date().toISOString(),plan:null,limits:[],balances:[],_meta:{_kimi:{credential:'api'}}};
+          if(!provider || provider.status!=='connected')throw new Error('Failed to fetch usage');
+          const response=await fetch(`http://127.0.0.1:${port}/api/v1/oauth/usage`,{headers:{Authorization:`Bearer ${token}`},signal:controller.signal});
+          if(!response.ok) throw new Error('Failed to fetch usage');
+          const body=await response.json();
+          if(body.data?.kind!=='ok') throw new Error(body.data?.message??'Failed to fetch usage');
+          return kimi(body.data.quota);
+        } catch(error) {
+          if(controller.signal.aborted || (error.message && !['fetch failed'].includes(error.message) && error.code!=='ENOENT')) throw error;
+        }
+        await new Promise(resolve=>setTimeout(resolve,150));
+      }
+      throw new Error('The Kimi usage service did not start');
+    } finally {clearTimeout(timeout);}
+  } finally { reading=false; if(web){web.kill('SIGTERM');setTimeout(()=>{if(web.exitCode===null)web.kill('SIGKILL');},2000).unref();} }
+}
+createInterface({input:child.stdout}).on('line',line=>{
+  try {const message=JSON.parse(line);if(message.id===initializeId&&message.result){message.result.agentCapabilities??={};message.result.agentCapabilities._meta??={};message.result.agentCapabilities._meta['axom/accountRateLimits']={...CAPABILITY,provider:'kimi'};write(message);return;}}catch{}
+  process.stdout.write(line+'\n');
+});
+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==='session/set_config_option' && message.params?.configId==='model')selectedModel=message.params.value;
+  if(message.method==='session/set_model')selectedModel=message.params.modelId;
+  if(message.method===READ&&message.id!==undefined){void usage().then(result=>{write({jsonrpc:'2.0',id:message.id,result});write({jsonrpc:'2.0',method:UPDATED,params:result});},()=>write({jsonrpc:'2.0',id:message.id,error:{code:-32603,message:'Failed to fetch usage'}}));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));