@platless/axom-cli 0.1.0 → 0.5.9

package/dist/axom-patch/cli/runtime.json

@@ -0,0 +1,63 @@
+{
+  "schema_version": 1,
+  "overrides": [
+    {
+      "id": "qoder-registry-catch-up",
+      "agent": "qoder",
+      "distribution": {
+        "version": "1.1.71",
+        "npx": {
+          "package": "@qoder-ai/qodercli@1.1.71",
+          "args": [
+            "--acp"
+          ]
+        }
+      },
+      "until_registry_version": "1.1.71"
+    },
+    {
+      "id": "claude-plan-tools",
+      "agent": "claude-acp",
+      "env": {
+        "CLAUDE_CODE_ENABLE_TODO_TOOLS": "1"
+      }
+    },
+    {
+      "id": "codex-plan-tools",
+      "agent": "codex-acp",
+      "env": {
+        "CODEX_CONFIG": "{\"tools\":{\"update_plan\":{\"enabled\":true}}}"
+      }
+    }
+  ],
+  "package_patches": [
+    "pi-steering.json",
+    "pi-subagent-subwork.json",
+    "qoder-subagent-origin.json",
+    "qoder-steering.json",
+    "codex-account-limits.json",
+    "claude-account-limits.json",
+    "commandcode-account-limits.json",
+    "zcode-account-limits.json",
+    "zcode-models.json",
+    "zcode-subagent-subwork.json"
+  ],
+  "native_extensions": [
+    {
+      "agent": "kimi-code",
+      "versions": [
+        "2.1.1"
+      ],
+      "entry": "account-limits/kimi-proxy.mjs"
+    },
+    {
+      "agent": "antigravity-acp",
+      "versions": [
+        "1.3.0",
+        "1.4.0"
+      ],
+      "entry": "account-limits/antigravity-proxy.mjs",
+      "accountLimitsVersion": 5
+    }
+  ]
+}

package/dist/axom-patch/cli/steering/claude-steering-js.patch

@@ -0,0 +1,89 @@
+--- a/dist/acp-agent.js
++++ b/dist/acp-agent.js
+@@ -180,12 +180,29 @@
+     return { sessionId, asyncTaskId };
+ }
+ /** How urgently the SDK delivers a steered message relative to the running
+- *  turn — an internal Claude implementation detail, not part of the wire
+- *  contract. `now` pre-empts the current generation, while `later` waits for a
+- *  pending permission/elicitation callback to settle instead of cancelling its
+- *  ACP request and hiding the client's user-input card (IJAI-1191). */
++ *  turn. `now` pre-empts the current generation, `next` waits for the next
++ *  natural boundary without aborting, and `later` waits for a pending
++ *  permission/elicitation callback to settle instead of cancelling its ACP
++ *  request and hiding the client's user-input card (IJAI-1191).
++ *
++ *  This is both the agent's own default choice and — since the
++ *  `_session/steering` response is identical whichever timing was used, so a
++ *  Host cannot discover the difference by trying — the vocabulary a Host may
++ *  name explicitly through `_meta.steering.priority`. The set is advertised on
++ *  `InitializeResponse._meta.steering.timings` so the capability is declared
++ *  rather than probed. */
+ const STEER_PRIORITY_NOW = "now";
++const STEER_PRIORITY_NEXT = "next";
+ const STEER_PRIORITY_LATER = "later";
++/** The delivery timings this agent accepts on `_meta.steering.priority`, and the
++ *  value advertised as `InitializeResponse._meta.steering.timings`. Both reads
++ *  come from this one array so the accepted set and the advertised set cannot
++ *  drift apart. */
++const STEER_TIMINGS = [
++    STEER_PRIORITY_NOW,
++    STEER_PRIORITY_NEXT,
++    STEER_PRIORITY_LATER,
++];
+ /** Validate raw JSON-RPC params into a {@link SteerRequest}. Kept minimal — the
+  *  content blocks are handed to `promptToClaude`, which tolerates unknown block
+  *  types — but `sessionId` and a non-empty `prompt` array are required. */
+@@ -206,6 +223,16 @@
+         : undefined;
+     if (idleBehavior !== undefined && idleBehavior !== "promptRequired") {
+         throw RequestError.invalidParams(undefined, "unsupported steering idleBehavior");
++    }
++    const priority = steering && typeof steering === "object"
++        ? steering.priority
++        : undefined;
++    // Rejected rather than ignored: a silently dropped priority is
++    // indistinguishable from an honoured one on the response, so a Host that
++    // asked for `next` and got `now` would only find out by losing the running
++    // turn's remaining work.
++    if (priority !== undefined && !STEER_TIMINGS.includes(priority)) {
++        throw RequestError.invalidParams(undefined, "unsupported steering priority");
+     }
+     return {
+         sessionId,
+@@ -947,6 +974,10 @@
+                 ...airSessionFailureCapabilityMeta(AGENT_FILE_CHANGE_REPORT_CAPABILITY, AIR_NATIVE_SUBAGENT_SESSIONS_CAPABILITY, AIR_ASYNC_TASKS_CAPABILITY, AIR_RECOMMENDED_CONFIG_VALUE_CAPABILITY),
+                 steering: {
+                     supported: true,
++                    // The timings a Host may name on `_meta.steering.priority`
++                    // (see STEER_TIMINGS). Declared, not probed: the response to
++                    // `_session/steering` is the same whichever timing was used.
++                    timings: [...STEER_TIMINGS],
+                 },
+                 goal: {
+                     version: GOAL_EXTENSION_VERSION,
+@@ -1758,9 +1789,22 @@
+         const steeredUuid = randomUUID();
+         userMessage.uuid = steeredUuid;
+         // Deliver into the running turn rather than queuing behind it as a fresh
+-        // prompt would.
++        // prompt would. With no priority in `_meta` this is byte-for-byte the
++        // established behavior: `now`, held back to `later` only while a
++        // permission/elicitation callback is awaiting input.
++        const defaultPriority = (session.pendingUserInputCount ?? 0) > 0
++            ? STEER_PRIORITY_LATER
++            : STEER_PRIORITY_NOW;
++        // A Host that named a timing gets it, with one exception: an explicit
++        // `now` is still held back while a callback is awaiting input, because
++        // pre-empting ABORTS the cycle, which cancels that ACP request and can
++        // strand the prompt (IJAI-1191). `next` and `later` never pre-empt, so
++        // they carry no such hazard and are honoured verbatim.
++        const requestedPriority = params._meta?.steering?.priority;
+         userMessage.priority =
+-            (session.pendingUserInputCount ?? 0) > 0 ? STEER_PRIORITY_LATER : STEER_PRIORITY_NOW;
++            requestedPriority === undefined || requestedPriority === STEER_PRIORITY_NOW
++                ? defaultPriority
++                : requestedPriority;
+         // Mark before the push and in the same synchronous section as the in-flight
+         // check: the interrupt can have the CLI finalizing the aborted cycle by the
+         // time the consumer next runs, and an unmarked result would settle the turn

package/dist/axom-patch/cli/steering/claude-steering-types.patch

@@ -0,0 +1,28 @@
+--- a/dist/acp-agent.d.ts
++++ b/dist/acp-agent.d.ts
+@@ -47,17 +47,22 @@
+     stopped: boolean;
+ };
+ /** Request-level steering options. `promptRequired` is opt-in so existing Hosts
+- *  keep the established idle fallback behavior. */
++ *  keep the established idle fallback behavior, and `priority` is optional so a
++ *  Host that names none keeps the agent's established default. */
+ type SteerMeta = {
+     [key: string]: unknown;
+     steering?: {
+         idleBehavior?: "promptRequired";
++        priority?: SteerTiming;
+     };
+ };
++/** A delivery timing a Host may name on {@link SteerMeta}, and a member of the
++ *  set advertised as `InitializeResponse._meta.steering.timings`. */
++export type SteerTiming = "now" | "next" | "later";
+ /** Params of a {@link STEER_METHOD} request. Shaped like the relevant subset of
+  *  a `PromptRequest` so the same `promptToClaude` conversion applies. Delivery
+- *  priority is deliberately NOT exposed here — it's an internal detail the agent
+- *  chooses (see {@link STEER_PRIORITY}). */
++ *  priority is the agent's own choice (see {@link STEER_TIMINGS}) unless the
++ *  Host names one it advertised. */
+ export type SteerRequest = {
+     sessionId: string;
+     prompt: PromptRequest["prompt"];

package/dist/axom-patch/cli/steering/codex-steering.patch

@@ -0,0 +1,57 @@
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -31723,6 +31723,20 @@
+ // src/AcpExtensions.ts
+ var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
+ var SESSION_STEERING_METHOD = "_session/steering";
++/**
++ * The delivery timings this agent accepts on a `_session/steering` request's
++ * `_meta.steering.priority`, and the value advertised as
++ * `InitializeResponse._meta.steering.timings`. Both reads come from this one
++ * array so the accepted set and the advertised set cannot drift apart.
++ *
++ * `now` is the only entry because injecting into the live turn is the only
++ * thing this adapter can ask the app-server for: `turn/steer` carries no timing
++ * field. A Host that needs `next` (deliver at a boundary without discarding the
++ * running turn's remaining work) must hold the message itself; declaring the
++ * set is what lets it know that without having to try and lose work finding
++ * out.
++ */
++var SESSION_STEERING_TIMINGS = ["now"];
+ function isExtMethodRequest(request) {
+   return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD || request.method === ASYNC_TASK_STOP_METHOD;
+ }
+@@ -32334,7 +32348,11 @@
+       authMethods: getCodexAuthMethods(_params.clientCapabilities),
+       _meta: {
+         steering: {
+-          supported: true
++          supported: true,
++          // Declared, not probed: `_session/steering` answers the same
++          // `{outcome}` whichever timing was used, so a Host cannot discover
++          // this by trying. See SESSION_STEERING_TIMINGS.
++          timings: [...SESSION_STEERING_TIMINGS]
+         },
+         goal: {
+           version: GOAL_EXTENSION_VERSION,
+@@ -33502,6 +33520,20 @@
+     const prompt = params["prompt"];
+     if (typeof sessionId !== "string" || !Array.isArray(prompt)) {
+       throw RequestError.invalidParams();
++    }
++    // `_meta` reaches us because sessionSteerParamsParser passes unknown keys
++    // through. A priority outside the advertised set is REJECTED rather than
++    // ignored: the `{outcome}` this method answers is identical either way, so
++    // a Host that asked for a timing we cannot honour would otherwise learn it
++    // only by losing the running turn's remaining work.
++    const meta = params["_meta"];
++    const steering = meta && typeof meta === "object" ? meta["steering"] : void 0;
++    const priority = steering && typeof steering === "object" ? steering["priority"] : void 0;
++    if (priority !== void 0 && !SESSION_STEERING_TIMINGS.includes(priority)) {
++      throw RequestError.invalidParams(
++        void 0,
++        `Unsupported steering priority; this agent accepts ${SESSION_STEERING_TIMINGS.join(", ")}`
++      );
+     }
+     return {
+       sessionId,

package/dist/axom-patch/cli/steering/pi-steering.js

@@ -0,0 +1,79 @@
+// Injected into pi-acp 0.0.34. Uses its existing RPC process and ACP prompt ownership.
+// Pi 0.87.1 accepts prompt(streamingBehavior=steer) before streaming events finish.
+// Holding the ACP prompt open also tracks a native continuation admitted at the idle boundary.
+class AxomPiSteering {
+  constructor(session) {
+    this.session = session;
+    this.tail = Promise.resolve();
+    this.pending = 0;
+    this.requested = false;
+    this.finishing = false;
+    this.settling = null;
+    this.revision = 0;
+  }
+  steer(message, images) {
+    const session = this.session;
+    if (!session.pendingTurn || session.cancelRequested || this.finishing) {
+      return Promise.resolve({ outcome: "promptRequired" });
+    }
+    const turn = session.pendingTurn;
+    this.pending++;
+    const operation = this.tail.then(async () => {
+      if (session.pendingTurn !== turn || session.cancelRequested) return { outcome: "promptRequired" };
+      const state = await session.proc.getState();
+      if (state?.isStreaming !== true || state?.isCompacting === true) return { outcome: "promptRequired" };
+      // No await between checking ACP ownership and starting the native request.
+      if (session.pendingTurn !== turn || session.cancelRequested) return { outcome: "promptRequired" };
+      const result = await session.proc.request({ type: "prompt", message, images, streamingBehavior: "steer" });
+      if (!result.success) return { outcome: "promptRequired" };
+      return { outcome: "injected" };
+    });
+    this.tail = operation.catch(() => {});
+    return operation.finally(() => {
+      this.pending--;
+      if (!this.pending && this.requested) this.settle();
+    });
+  }
+  settle() {
+    this.requested = true;
+    this.revision++;
+    if (this.pending || this.settling || this.finishing) return this.settling;
+    const session = this.session;
+    const turn = session.pendingTurn;
+    if (!turn) return;
+    const revision = this.revision;
+    this.settling = (async () => {
+      const state = await session.proc.getState();
+      // An old agent_settled notification may arrive during admission of a new native loop.
+      if (this.pending || session.pendingTurn !== turn || state?.isStreaming === true || state?.isCompacting === true) return;
+      this.finishing = true;
+      this.requested = false;
+      try { await session.axomFinishTurn(); }
+      finally { this.finishing = false; }
+    })().catch(error => {
+      if (session.pendingTurn === turn) {
+        session.pendingTurn = null;
+        turn.reject(error);
+      }
+    }).finally(() => {
+      this.settling = null;
+      if (!this.pending && this.requested && this.revision !== revision) this.settle();
+    });
+    return this.settling;
+  }
+}
+
+async function axomPiSupportsSteering() {
+  const command = getPiCommand(process.env.PI_ACP_PI_COMMAND);
+  const launch = shouldUseShellForPiCommand(command) ? crossSpawn : spawn;
+  return new Promise(resolve => {
+    let output = "";
+    let child;
+    try { child = launch(command, ["--version"], { stdio: ["ignore", "pipe", "ignore"], env: process.env }); }
+    catch { resolve(false); return; }
+    const timeout = setTimeout(() => { child.kill(); resolve(false); }, 5000);
+    child.stdout.on("data", data => { output += data; });
+    child.on("error", () => { clearTimeout(timeout); resolve(false); });
+    child.on("close", code => { clearTimeout(timeout); resolve(code === 0 && output.trim() === "0.87.1"); });
+  });
+}

package/dist/axom-patch/cli/zcode-account-limits.json

@@ -0,0 +1,31 @@
+{
+  "id": "zcode-account-limits",
+  "package": "zcode-acp-server",
+  "versions": [
+    "0.69.3",
+    "0.69.4"
+  ],
+  "edits": [
+    {
+      "file": "dist/index.js",
+      "before_sha256": "3f7286e9380681ca22bce5ed5d4faaaad595edee745589337babe4d3f2e0113d",
+      "after_sha256": "8ae15d912cd451fa155fadf8fa7707553a51477d2f3974a1deb0ebf9bed55a00",
+      "before": "        .onRequest(\"account/usage_stats\", z.object({}).passthrough(), () => accountUsageStats())",
+      "after": "        .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())"
+    },
+    {
+      "file": "dist/index.js",
+      "before_sha256": "8ae15d912cd451fa155fadf8fa7707553a51477d2f3974a1deb0ebf9bed55a00",
+      "after_sha256": "a3047f20115eb8bcad7dfee1eac6689a73127f589dce6131138b22e9ca2712d1",
+      "before": "        .onRequest(\"initialize\", (ctx) => server.initialize(ctx.params, ctx.client))",
+      "after": "        .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; })"
+    },
+    {
+      "file": "dist/index.js",
+      "before_sha256": "a3047f20115eb8bcad7dfee1eac6689a73127f589dce6131138b22e9ca2712d1",
+      "after_sha256": "1dcc36538826c874d851254d56f91b9f9f12a93652668688f5ed53baa803823f",
+      "before": "#!/usr/bin/env node\n/**\n * Entry point: wire the ZcodeAcpServer to a stdio ACP stream.\n *\n * The ACP",
+      "after": "#!/usr/bin/env node\n\nconst axomQuota = (() => {\n/** Account quota normalization. No I/O: passive events must never trigger a query. */\nconst READ = '_axom/account/rateLimits/read';\nconst UPDATED = '_axom/account/rateLimits/updated';\nconst CAPABILITY = { version: 2, read: true, updated: true };\nconst percent = v => typeof v === 'number' && Number.isFinite(v) ? Math.max(0, Math.min(100, v)) : null;\nconst finite = v => { if (v == null || typeof v === 'boolean') return null; const n = typeof v === 'number' ? v : Number(v); return Number.isFinite(n) ? n : null; };\nconst time = (v, milliseconds = false) => {\n  if (v == null || v === 0) return null;\n  const d = new Date(typeof v === 'number' ? v * (milliseconds ? 1 : 1000) : v);\n  return Number.isFinite(d.getTime()) ? d.toISOString() : null;\n};\nconst status = v => ({ allowed: 'allowed', allowed_warning: 'warning', rejected: 'blocked', normal: 'allowed' }[v] ?? 'unknown');\n/** Canonical window key rides the snapshot; the UI owns the key → display-label translation.\n *  Windows without a canonical key keep their vendor content untouched. */\nconst windowKey = (seconds, period) => period === 'month' ? 'monthly' : seconds === 18000 ? 'five_hour' : seconds === 604800 ? 'weekly' : null;\nconst base = (provider, mode, raw, observedAt) => ({ schemaVersion: 1, updateMode: 'snapshot', provider, billingMode: mode, availability: mode === 'subscription' ? 'available' : mode === 'unknown' ? 'unknown' : 'not_applicable', observedAt: observedAt ?? new Date().toISOString(), plan: null, limits: [], balances: [], _meta: { ['_' + provider]: structuredClone(raw) } });\nfunction codex(raw, authType = 'chatgpt', observedAt) {\n  const out = base('codex', ['chatgpt', 'chatgptAuthTokens'].includes(authType) ? 'subscription' : ['apiKey','apikey','amazonBedrock'].includes(authType) ? 'non_subscription' : 'unknown', raw, observedAt);\n  if (out.billingMode !== 'subscription') return out;\n  const buckets = Object.entries(raw.rateLimitsByLimitId ?? {});\n  if (!buckets.length && raw.rateLimits) buckets.push([raw.rateLimits.limitId ?? 'codex', raw.rateLimits]);\n  for (const [id, bucket] of buckets) {\n    if (!bucket) continue;\n    if (bucket.planType) out.plan = { id: bucket.planType, label: bucket.planType };\n    for (const name of ['primary', 'secondary']) {\n      const w = bucket[name]; if (!w) continue;\n      const seconds = w.windowDurationMins == null ? null : w.windowDurationMins * 60;\n      out.limits.push({ id: `${id}.${name}`, label: bucket.limitName ?? id, kind: 'subscription', windowSeconds: seconds, key: windowKey(seconds), usedPercent: percent(w.usedPercent), resetsAt: time(w.resetsAt), status: bucket.rateLimitReachedType ? 'blocked' : 'unknown', scope: { bucket: id } });\n    }\n    if (bucket.credits) out.balances.push({ id: `${id}.credits`, label: 'Credits', remaining: bucket.credits.balance ?? null, unit: 'credits', unlimited: bucket.credits.unlimited === true });\n  }\n  // Account IDs must not escape via provider extensions.\n  delete out._meta._codex.accountId;\n  return out;\n}\nfunction claude(raw, observedAt) {\n  const mode = raw.billing_mode ?? (raw.subscription_type || raw.rate_limits_available === true ? 'subscription' : 'unknown');\n  const out = base('claude', mode, raw, observedAt);\n  out.plan = raw.subscription_type ? { id: raw.subscription_type, label: raw.subscription_type } : null;\n  if (mode === 'subscription' && !raw.rate_limits_available) out.availability = 'unavailable';\n  const limits = raw.rate_limits ?? {};\n  const rows = Array.isArray(limits.limits) ? limits.limits : [];\n  if (rows.length) {\n    rows.forEach((w, i) => {\n      const seconds = w.group === 'session' ? 18000 : w.group === 'weekly' ? 604800 : null;\n      out.limits.push({ id: `claude.${w.kind}.${i}`, label: w.scope?.model?.display_name ?? w.kind, kind: 'subscription', windowSeconds: seconds, key: windowKey(seconds), usedPercent: percent(w.percent), resetsAt: time(w.resets_at), status: status(w.severity), active: w.is_active ?? null, scope: w.scope ?? null });\n    });\n  } else for (const [id, seconds] of [['five_hour', 18000], ['seven_day', 604800], ['seven_day_opus',604800], ['seven_day_sonnet',604800]]) {\n    const w = limits[id]; if (!w) continue;\n    out.limits.push({ id: `claude.${id}`, label: id, kind: 'subscription', windowSeconds: seconds, key: windowKey(seconds), usedPercent: percent(w.utilization), resetsAt: time(w.resets_at), status: 'unknown', scope: id.endsWith('opus') || id.endsWith('sonnet') ? { model: id.split('_').at(-1) } : null });\n  }\n  const spend=limits.spend;\n  if(spend?.enabled && spend.used && spend.limit) out.limits.push({id:'claude.extra_spend',label:'Extra usage',kind:'spend',windowSeconds:null,usedPercent:percent(spend.percent),resetsAt:null,status:status(spend.severity),used:String(spend.used.amount_minor),limit:String(spend.limit.amount_minor),unit:'money',currency:spend.used.currency,exponent:spend.used.exponent});\n  if(spend?.balance?.amount_minor != null) out.balances.push({id:'claude.extra_balance',label:'Extra usage balance',remaining:String(spend.balance.amount_minor),unit:'money',currency:spend.balance.currency,exponent:spend.balance.exponent});\n  return out;\n}\nfunction claudeEvent(raw, previous = null, observedAt) {\n  const out = previous ? structuredClone(previous) : base('claude',raw.rateLimitType?'subscription':'unknown',{},observedAt);\n  out.updateMode = 'delta';\n  out.balances = [];\n  out.observedAt = observedAt ?? new Date().toISOString();\n  out._meta._claude = { ...out._meta._claude, rateLimitEvent: raw };\n  const seconds = raw.rateLimitType === 'five_hour' ? 18000 : raw.rateLimitType?.startsWith('seven_day') ? 604800 : null;\n  if (seconds !== null) {\n    const id = `claude.${raw.rateLimitType}`;\n    const scoped = !['five_hour','seven_day'].includes(raw.rateLimitType);\n    const prior=out.limits.find(w => w.windowSeconds===seconds && JSON.stringify(w.scope??null)===JSON.stringify(scoped ? {model:raw.rateLimitType.split('_').at(-1)}:null));\n    const nextReset=time(raw.resetsAt);\n    const rolled=prior?.resetsAt && nextReset && Math.abs(Date.parse(nextReset)-Date.parse(prior.resetsAt))>1000;\n    const row = { id, label: raw.rateLimitType, kind: 'subscription', windowSeconds: seconds, key: windowKey(seconds), usedPercent: raw.utilization == null ? (rolled ? null : prior?.usedPercent ?? null) : percent(raw.utilization * 100), resetsAt: raw.resetsAt == null ? prior?.resetsAt ?? null : time(raw.resetsAt), status: status(raw.status), scope: scoped ? { model: raw.rateLimitType.split('_').at(-1) } : null };\n    // Event utilization is a ratio, unlike get_usage's percentage. Match the existing window without duplicating it.\n    const i = out.limits.findIndex(w => w.windowSeconds === seconds && JSON.stringify(w.scope ?? null) === JSON.stringify(row.scope));\n    out.limits = [i >= 0 ? { ...out.limits[i], ...row, id: out.limits[i].id } : row];\n  } else out.limits = [];\n  return out;\n}\nfunction kimi(raw, observedAt) {\n  const quota = raw.quota ?? raw;\n  const out = base('kimi','subscription',quota,observedAt);\n  for (const [id, seconds] of [['limit5h',18000],['limit7d',604800],['monthTotal',null]]) {\n    const w = quota.usages?.[id]; if (!w) continue;\n    out.limits.push({ id: `kimi.${id}`, label: id, kind: 'subscription', windowSeconds: seconds, period: id === 'monthTotal' ? 'month' : null, key: windowKey(seconds, id === 'monthTotal' ? 'month' : null), usedPercent: percent(w.usedRatio * 100), resetsAt: time(w.resetAt), status: 'unknown' });\n  }\n  const wallet = quota.extraUsage;\n  if (wallet) out.balances.push({ id:'kimi.extra',label:'Extra usage',remaining:String(wallet.balanceCents),unit:'money',currency:wallet.currency,exponent:2 });\n  return out;\n}\n/** GLM quota `percentage` is the USED share (measured: 5% for 58/1000); counters win when present.\n * Counter-derived shares are rounded to 2 decimals — 100-94.2 keeps fp noise otherwise. */\nconst glmPercent = limit => {\n  const used = finite(limit.currentValue), remaining = finite(limit.remaining), total = finite(limit.usage);\n  const cap = remaining !== null && used !== null ? remaining + used : total;\n  const round2 = v => v == null ? null : Math.round(v * 100) / 100;\n  if (cap !== null && cap > 0 && remaining !== null && remaining >= 0 && remaining <= cap) return round2(100 - percent(remaining / cap * 100));\n  if (cap !== null && cap > 0 && used !== null && used >= 0 && used <= cap) return round2(percent(used / cap * 100));\n  return percent(limit.percentage);\n};\nfunction zcode(raw, observedAt) {\n  // Raw: the GLM quota endpoint's data block — { level, limits: [{ type, number, usage,\n  // currentValue, remaining, percentage, nextResetTime(epoch ms), usageDetails }] }. Which windows\n  // exist is plan-dependent (measured pro plan: 5h prompts + a tool/MCP allowance; no weekly row —\n  // a `number: 7` window maps when a plan returns one, and nothing is invented when it doesn't).\n  const limits = Array.isArray(raw?.limits) ? raw.limits : [];\n  const level = typeof raw?.level === 'string' && raw.level ? raw.level : null;\n  const out = base('zcode', limits.length ? 'subscription' : 'unknown', raw, observedAt);\n  out.plan = level ? { id: level, label: level } : null;\n  let tools = 0;\n  limits.forEach((limit, i) => {\n    if (!limit || typeof limit !== 'object') return;\n    const resetsAt = time(limit.nextResetTime, true);\n    if (limit.type === 'TOKENS_LIMIT') {\n      // GLM window convention: number 5 → the 5-hour prompt window, 7 → weekly.\n      // Ids mirror the adapter's own /quota keys (token_5h / token_week).\n      const seconds = limit.number === 5 ? 18000 : limit.number === 7 ? 604800 : null;\n      const label = limit.number === 5 ? '5h' : limit.number === 7 ? 'Week' : `token ${limit.number ?? i}`;\n      const id = limit.number === 5 ? 'zcode.token_5h' : limit.number === 7 ? 'zcode.token_week' : `zcode.token_${limit.number ?? i}`;\n      out.limits.push({ id, label, kind: 'subscription', windowSeconds: seconds, key: windowKey(seconds), usedPercent: glmPercent(limit), resetsAt, status: 'unknown' });\n    } else if (limit.type === 'TIME_LIMIT' || limit.type === 'MCP_LIMIT') {\n      // Built-in tool/MCP allowance: absolute counters (unit 'calls'); per-model detail stays in _meta.\n      const used = finite(limit.currentValue), total = finite(limit.usage), remaining = finite(limit.remaining);\n      out.limits.push({ id: tools ? `zcode.mcp.${i}` : 'zcode.mcp', label: 'MCP', kind: 'subscription', windowSeconds: null, usedPercent: glmPercent(limit), ...(used !== null && total !== null ? { used: String(used), limit: String(total), unit: 'calls' } : {}), resetsAt, status: remaining === 0 ? 'blocked' : used !== null || limit.percentage != null ? 'allowed' : 'unknown' });\n      tools++;\n    }\n  });\n  return out;\n}\nfunction commandcode(raw, observedAt) {\n  const subscription = raw.subscription?.data ?? raw.subscription;\n  const windows = raw.credits?.windowLimits ?? raw.windowLimits;\n  const subscribed = ['active','trialing','past_due'].includes(subscription?.status) || windows?.limited === true;\n  const mode = subscribed ? 'subscription' : subscription || windows ? 'non_subscription' : 'unknown';\n  const out = base('commandcode',mode,raw,observedAt);\n  out.plan = subscription?.planId ? { id:subscription.planId,label:subscription.planId } : null;\n  for (const [id, seconds] of [['fiveHour',18000],['weekly',604800]]) {\n    const w=windows?.[id]; if (!w) continue;\n    out.limits.push({ id:`commandcode.${id}`,label:id,kind:'subscription',windowSeconds:seconds,key:windowKey(seconds),usedPercent:w.cap > 0 ? percent(w.used / w.cap * 100) : null,used:String(w.used),limit:String(w.cap),unit:'credits',resetsAt:time(w.resetAt,true),status:w.exceeded === true ? 'blocked' : 'allowed' });\n  }\n  const credits=raw.credits?.credits ?? raw.credits;\n  if (subscribed && credits?.monthlyCredits != null) {\n    const cap=raw.monthly?.limit;\n    const known=typeof cap==='number' && Number.isFinite(cap) && cap>0;\n    const used=known ? Math.max(0,cap-credits.monthlyCredits) : null;\n    out.limits.push({id:'commandcode.monthly',label:'Monthly',kind:'subscription',windowSeconds:null,period:'month',key:windowKey(null,'month'),usedPercent:known?percent(used/cap*100):null,resetsAt:time(subscription?.currentPeriodEnd,true),status:'unknown',...(known?{used:String(used),limit:String(cap),unit:'credits'}:{})});\n  }\n  for (const [id,label] of [['monthlyCredits','Monthly credits'],['purchasedCredits','Purchased credits'],['freeCredits','Free credits']]) if (credits?.[id] != null) out.balances.push({ id:`commandcode.${id}`,label,remaining:String(credits[id]),unit:'credits' });\n  return out;\n}\n\nreturn {READ,UPDATED,CAPABILITY,codex,claude,claudeEvent,kimi,commandcode,zcode};\n})();\nconst axomQuotaNotify = snapshot => process.stdout.write(JSON.stringify({jsonrpc:\"2.0\",method:axomQuota.UPDATED,params:snapshot})+\"\\n\");\n/**\n * Entry point: wire the ZcodeAcpServer to a stdio ACP stream.\n *\n * The ACP"
+    }
+  ]
+}

package/dist/axom-patch/cli/zcode-models.json

@@ -0,0 +1,38 @@
+{
+  "id": "zcode-models",
+  "package": "zcode-acp-server",
+  "versions": [
+    "0.69.3",
+    "0.69.4"
+  ],
+  "edits": [
+    {
+      "file": "dist/config/options.js",
+      "before_sha256": "7f30e0dbf281280b7043cc686990eff3785bc62206a4b369313b27333cf9c330",
+      "after_sha256": "4641e5097c667e9b351ee7f0dee89a5a517332f452b1fc878e0396775b9870f8",
+      "before": "import { configProviderIdFor } from \"./account-provider.js\";",
+      "after": "import { buildAccountProviderConfig as axomAccountProviders, codingPlanRequestAuthFor as axomPlanAuth, configProviderIdFor } from \"./account-provider.js\";"
+    },
+    {
+      "file": "dist/config/options.js",
+      "before_sha256": "4641e5097c667e9b351ee7f0dee89a5a517332f452b1fc878e0396775b9870f8",
+      "after_sha256": "286ad8d2b6f734ae1168cbe2095c25660016db10eee6ccc4d285a64fe8cc2cd4",
+      "before": "/** Read the config.json contents (UTF-8). Throws on read/parse failure. */",
+      "after": "function axomFreshInstallModels() {\n    const fallback = { providerId: DEFAULT_PROVIDER_ID, providerName: DEFAULT_PROVIDER_NAME, modelId: DEFAULT_MODEL_ID };\n    try {\n        const out = [];\n        for (const [pid, p] of Object.entries(axomAccountProviders()?.providers ?? {})) {\n            if (!p?.access?.entitled || !axomPlanAuth(pid)?.apiKey) continue;\n            const providerId = configProviderIdFor(pid);\n            for (const modelId of p.builtinModelIds ?? []) {\n                if (out.some((m) => m.providerId === providerId && m.modelId === modelId)) continue;\n                out.push({ providerId, providerName: providerId, modelId });\n            }\n        }\n        if (out.length === 0) return [fallback];\n        return out.some((m) => m.providerId === fallback.providerId && m.modelId === fallback.modelId)\n            ? [fallback, ...out.filter((m) => !(m.providerId === fallback.providerId && m.modelId === fallback.modelId))]\n            : [fallback, ...out];\n    }\n    catch {\n        return [fallback];\n    }\n}\n\n/** Read the config.json contents (UTF-8). Throws on read/parse failure. */"
+    },
+    {
+      "file": "dist/config/options.js",
+      "before_sha256": "286ad8d2b6f734ae1168cbe2095c25660016db10eee6ccc4d285a64fe8cc2cd4",
+      "after_sha256": "c6fae88f596ee0cbb633317c0f83c2c883a2b2a5d8978bfc4fd6a6d152f77ccb",
+      "before": "        if (out.length === 0 && Object.keys(cfg.provider ?? {}).length === 0) {\n            return [\n                {\n                    providerId: DEFAULT_PROVIDER_ID,\n                    providerName: DEFAULT_PROVIDER_NAME,\n                    modelId: DEFAULT_MODEL_ID,\n                },\n            ];\n        }",
+      "after": "        if (out.length === 0 && Object.keys(cfg.provider ?? {}).length === 0) {\n            return axomFreshInstallModels();\n        }"
+    },
+    {
+      "file": "dist/config/options.js",
+      "before_sha256": "c6fae88f596ee0cbb633317c0f83c2c883a2b2a5d8978bfc4fd6a6d152f77ccb",
+      "after_sha256": "d12eded70f22d8d9010de9949c0809b1f56f2c33635899764ca9f893fec0d256",
+      "before": "        if (out.length > 0)\n            return out;\n        return [\n            {\n                providerId: DEFAULT_PROVIDER_ID,\n                providerName: DEFAULT_PROVIDER_NAME,\n                modelId: DEFAULT_MODEL_ID,\n            },\n        ];\n    }\n}",
+      "after": "        if (out.length > 0)\n            return out;\n        return axomFreshInstallModels();\n    }\n}"
+    }
+  ]
+}

package/dist/axom-patch/cli/zcode-subagent-subwork.json

@@ -0,0 +1,73 @@
+{
+  "id": "zcode-subagent-subwork",
+  "package": "zcode-acp-server",
+  "versions": [
+    "0.69.3",
+    "0.69.4"
+  ],
+  "edits": [
+    {
+      "file": "dist/handlers/dispatch.js",
+      "before_sha256": "7d095dc00eb9b8a55a8452ac390cbf56f71056da7ae0f575541602de23222483",
+      "after_sha256": "b82e262b6ffcd4d74262515f3d1465912b9508b22597cef5cf8db702bec52225",
+      "before": "import { isBroadcastSource, sendSessionUpdate, sendSessionUpdateToOthers } from \"./io.js\";\n/** True once the EPERM hint fired for this process — throttled to one shot. */",
+      "after": "import { isBroadcastSource, sendSessionUpdate, sendSessionUpdateToOthers } from \"./io.js\";\n/** Axom patch `zcode-subagent-subwork`: the backend addresses a foreground sub-agent's\n * internal tool calls as `tool_subagent_<child-suffix>_call_<id>`; the child ACP session\n * id is `sess_` + that middle segment (measured: tool id\n * `tool_subagent_agent_<uuid>_call_<x>` ↔ child session `sess_subagent_agent_<uuid>`).\n * Deterministic from the id alone — no state. */\nfunction axomSubagentChildScope(callId) {\n    if (typeof callId !== \"string\" || !callId.startsWith(\"tool_subagent_\"))\n        return null;\n    const middle = callId.slice(\"tool_\".length);\n    const cut = middle.indexOf(\"_call_\");\n    if (cut <= 0)\n        return null;\n    return `sess_${middle.slice(0, cut)}`;\n}\n/** Draft RFD #1992 subagents negotiated by the client (the axom daemon always does). */\nfunction axomNativeSubagents(server) {\n    return !!(server && server.clientCapabilities && server.clientCapabilities.subagents);\n}\n/** True once the EPERM hint fired for this process — throttled to one shot. */"
+    },
+    {
+      "file": "dist/handlers/dispatch.js",
+      "before_sha256": "b82e262b6ffcd4d74262515f3d1465912b9508b22597cef5cf8db702bec52225",
+      "after_sha256": "ecfb04258456577d61f3d20b2f1b8f0a950c58d8efefbdf58221b0b8c9a34c4e",
+      "before": "function dispatchToolCallNew(server, cx, acpSid, ev) {\n    const termSupported = server.supportsTerminalOutput() && (ev.tool === \"Bash\" || ev.tool === \"bash\");\n    const meta = { claudeCode: { toolName: ev.tool } };\n    if (termSupported)\n        meta[\"terminal_info\"] = { terminal_id: ev.callId };\n    // Mark sub-agent dispatch cards so editors can badge them from creation.\n    if (ev.tool === \"Agent\" || ev.tool === \"Task\")\n        meta[\"subagent\"] = true;",
+      "after": "function dispatchToolCallNew(server, cx, acpSid, ev) {\n    acpSid = axomSubagentChildScope(ev.callId) ?? acpSid;\n    const termSupported = server.supportsTerminalOutput() && (ev.tool === \"Bash\" || ev.tool === \"bash\");\n    const meta = { claudeCode: { toolName: ev.tool } };\n    if (termSupported)\n        meta[\"terminal_info\"] = { terminal_id: ev.callId };\n    // Mark sub-agent dispatch cards so editors can badge them from creation.\n    // Axom: with draft subagents (RFD #1992) negotiated, the native events own the\n    // projection and this mark would double-project the child on such clients.\n    if ((ev.tool === \"Agent\" || ev.tool === \"Task\") && !axomNativeSubagents(server))\n        meta[\"subagent\"] = true;"
+    },
+    {
+      "file": "dist/handlers/dispatch.js",
+      "before_sha256": "ecfb04258456577d61f3d20b2f1b8f0a950c58d8efefbdf58221b0b8c9a34c4e",
+      "after_sha256": "a4ece2260d22b8791a9230afc4652aede39d7c10252ce47692f8208a668388c5",
+      "before": "function dispatchToolCallUpdate(server, cx, acpSid, ev) {\n    const toolName = ev.tool ?? \"\";",
+      "after": "function dispatchToolCallUpdate(server, cx, acpSid, ev) {\n    acpSid = axomSubagentChildScope(ev.callId) ?? acpSid;\n    const toolName = ev.tool ?? \"\";"
+    },
+    {
+      "file": "dist/server.js",
+      "before_sha256": "547d640a68ad56a97bd587348ea38ee3eca57d1fad9ea1d14e04c486e1efc85a",
+      "after_sha256": "df37fa0b7e5873d13a2cdd71a5fbc931a7ea9ffca521b0218d60a7a9b11e1d3c",
+      "before": "export class ZcodeAcpServer {",
+      "after": "/** Axom patch `zcode-subagent-subwork`: normalize ZCode sub-agents and background\n * tasks into the draft ACP subagent variants (RFD #1992) and the AIR async-task\n * extension — the same contracts claude-agent-acp ships. The backend already emits\n * first-class lifecycle events on `session.updated` (agentId/childSessionId for\n * sub-agents, taskId for background tasks); this listener forwards them so hosts\n * can project subworks, and dispatch.js re-scopes a foreground sub-agent's internal\n * `tool_subagent_*` tool calls onto its child session. */\nclass AxomZcodeSubagents {\n    constructor(server, zcodeSid) {\n        this.server = server;\n        this.sid = zcodeSid;\n        /** agentId → { agentId, child, background, terminal, pendingState, pendingP, resultSeen, preview } */\n        this.agents = new Map();\n        /** parentToolCallId → agent record (foreground result flush). */\n        this.parents = new Map();\n        /** taskId → { terminal } (bash/exec background tasks only). */\n        this.tasks = new Map();\n    }\n    /** Draft RFD #1992 negotiated — the axom daemon always declares this. */\n    nativeOk() {\n        const caps = this.server.clientCapabilities;\n        return !!(caps && caps.subagents);\n    }\n    /** AIR async-task capability declared (`_meta.jetbrains.air.capabilities`). */\n    asyncOk() {\n        const air = this.server.clientCapabilities?._meta?.jetbrains?.air;\n        return !!(air && Array.isArray(air.capabilities) && air.capabilities.includes(\"asyncTasks\"));\n    }\n    handleEvent(ev) {\n        try {\n            void this.onEvent(ev);\n        }\n        catch {\n            // Never crash the bridge from a normalization observer.\n        }\n    }\n    async onEvent(ev) {\n        if (!ev || ev.type !== \"session.updated\") {\n            this.onToolEvent(ev);\n            return;\n        }\n        const p = ev.payload ?? {};\n        if (typeof p.agentId === \"string\" && p.agentId && typeof p.childSessionId === \"string\" && p.childSessionId) {\n            this.onAgent(p);\n            return;\n        }\n        // Sub-agent background tasks also carry taskId with taskKind \"subagent\" —\n        // the agentId path above owns those. Workflow runs have their own poller.\n        if (typeof p.taskId === \"string\" && p.taskId && p.taskKind !== \"subagent\" && p.taskKind !== \"workflow\") {\n            this.onTask(p);\n        }\n    }\n    onAgent(p) {\n        if (!this.nativeOk())\n            return;\n        const agentId = p.agentId;\n        const child = p.childSessionId;\n        const status = typeof p.status === \"string\" ? p.status : \"running\";\n        let rec = this.agents.get(agentId);\n        if (!rec) {\n            rec = { agentId, child, background: p.background === true, terminal: false, pendingState: null, pendingP: null, resultSeen: false, preview: null };\n            this.agents.set(agentId, rec);\n            if (typeof p.parentToolCallId === \"string\" && p.parentToolCallId)\n                this.parents.set(p.parentToolCallId, rec);\n            // First sighting already terminal (adapter restart): adopt — emit the\n            // spawn so the host can still link the child, then the state below.\n            if (status !== \"running\")\n                rec.resultSeen = true;\n            this.emit({\n                sessionUpdate: \"subagent_spawned\",\n                subagentSessionId: child,\n                name: (typeof p.description === \"string\" && p.description) || (typeof p.agentType === \"string\" && p.agentType) || \"Subagent\",\n                task: typeof p.prompt === \"string\" ? p.prompt : (p.description ?? \"\"),\n                capabilities: {},\n                _meta: { zcode: { agentId, parentToolCallId: p.parentToolCallId, background: rec.background, adopted: status !== \"running\" } },\n            });\n        }\n        if (rec.child !== child)\n            return;\n        const mapped = status === \"completed\" ? \"completed\"\n            : status === \"failed\" || status === \"error\" ? \"failed\"\n                : status === \"cancelled\" || status === \"stopped\" ? \"cancelled\"\n                    : status === \"disconnected\" ? \"disconnected\" : null;\n        if (!mapped || rec.terminal)\n            return;\n        if (rec.background || rec.resultSeen || mapped !== \"completed\") {\n            this.finishAgent(rec, mapped, p);\n            return;\n        }\n        // Foreground completion: hold the state until the parent Agent tool's own\n        // result event arrives (one event later, measured) so the child-scoped\n        // preview precedes the terminal state on the wire.\n        rec.pendingState = mapped;\n        rec.pendingP = p;\n    }\n    finishAgent(rec, state, p) {\n        rec.terminal = true;\n        if (rec.preview) {\n            this.emitChild(rec.child, { sessionUpdate: \"agent_message_chunk\", content: { type: \"text\", text: rec.preview } });\n            rec.preview = null;\n        }\n        const meta = { zcode: { agentId: rec.agentId } };\n        if (p) {\n            for (const key of [\"parentToolCallId\", \"outputFile\"])\n                if (typeof p[key] === \"string\")\n                    meta.zcode[key] = p[key];\n            if (typeof p.totalTokens === \"number\")\n                meta.zcode.totalTokens = p.totalTokens;\n            if (typeof p.totalDurationMs === \"number\")\n                meta.zcode.totalDurationMs = p.totalDurationMs;\n        }\n        this.emit({ sessionUpdate: \"subagent_state_update\", subagentSessionId: rec.child, state, _meta: meta });\n    }\n    onToolEvent(ev) {\n        if (!ev || ev.type !== \"tool.updated\")\n            return;\n        const p = ev.payload ?? {};\n        if (p.kind !== \"result\" || typeof p.toolCallId !== \"string\")\n            return;\n        const rec = this.parents.get(p.toolCallId);\n        if (!rec || rec.terminal || rec.background)\n            return;\n        rec.resultSeen = true;\n        const text = axomSubagentResultPreview(p.result);\n        if (text)\n            rec.preview = text;\n        if (rec.pendingState)\n            this.finishAgent(rec, rec.pendingState, rec.pendingP);\n    }\n    onTask(p) {\n        if (!this.asyncOk())\n            return;\n        const taskId = p.taskId;\n        let task = this.tasks.get(taskId);\n        const status = typeof p.status === \"string\" ? p.status : \"running\";\n        if (!task) {\n            task = { terminal: false };\n            this.tasks.set(taskId, task);\n            this.emit({\n                sessionUpdate: \"async_task_spawned\",\n                asyncTaskId: taskId,\n                name: (typeof p.description === \"string\" && p.description) || (typeof p.command === \"string\" && p.command) || \"background task\",\n                taskType: typeof p.taskKind === \"string\" ? p.taskKind : \"shell\",\n                description: typeof p.description === \"string\" ? p.description : \"\",\n                showInTranscript: false,\n                canStop: p.cancellable === true,\n                ...(typeof p.outputPath === \"string\" ? { outputFilePath: p.outputPath } : {}),\n                ...(typeof p.toolCallId === \"string\" ? { toolCallId: p.toolCallId } : {}),\n                _meta: { zcode: { taskKind: p.taskKind, command: p.command } },\n            });\n        }\n        const mapped = status === \"completed\" ? \"completed\"\n            : status === \"failed\" || status === \"error\" ? \"failed\"\n                : status === \"cancelled\" ? \"stopped\" : null;\n        if (!mapped || task.terminal)\n            return;\n        task.terminal = true;\n        this.emit({\n            sessionUpdate: \"async_task_state_update\",\n            asyncTaskId: taskId,\n            state: mapped,\n            ...(typeof p.toolCallId === \"string\" ? { toolCallId: p.toolCallId } : {}),\n        });\n    }\n    emit(update) {\n        void this.server.notifyByZcodeSid(this.sid, update);\n    }\n    emitChild(childId, update) {\n        const server = this.server;\n        if (!server.clients || server.clients.size === 0)\n            return;\n        void enqueueSessionSend(childId, () => server.clients.broadcast().notify(\"session/update\", { sessionId: childId, update }));\n    }\n}\n/** The parent Agent tool's result carries the sub-agent's final message plus an\n * `agentId:` line and a `<usage>` block that belong to the envelope, not the\n * answer. The backend delivers the payload as a JSON string or as an already\n * parsed object (both measured) — accept either. */\nfunction axomSubagentResultPreview(result) {\n    let content = null;\n    if (typeof result === \"string\") {\n        try {\n            const parsed = JSON.parse(result);\n            if (parsed && typeof parsed.content === \"string\")\n                content = parsed.content;\n        }\n        catch {\n            content = result;\n        }\n    }\n    else if (result && typeof result === \"object\" && typeof result.content === \"string\") {\n        content = result.content;\n    }\n    if (typeof content !== \"string\" || !content.trim())\n        return null;\n    const stripped = content\n        .replace(/<usage>[\\s\\S]*?<\\/usage>/g, \"\")\n        .split(\"\\n\")\n        .filter((line) => !/^agentId:\\s*\\S+/.test(line))\n        .join(\"\\n\")\n        .trim();\n    return stripped ? stripped.slice(0, 2000) : null;\n}\nexport { AxomZcodeSubagents };\nexport class ZcodeAcpServer {"
+    },
+    {
+      "file": "dist/server.js",
+      "before_sha256": "df37fa0b7e5873d13a2cdd71a5fbc931a7ea9ffca521b0218d60a7a9b11e1d3c",
+      "after_sha256": "55d776521298e0a59d7512be34aeb2b86bc10a4cce9b038a9387ab860ab1aa2c",
+      "before": "        backend.registerEventListener(zcodeSid, new SessionTitleListener(this, zcodeSid));\n        this.backgroundListenerBackend.set(zcodeSid, backend);",
+      "after": "        backend.registerEventListener(zcodeSid, new SessionTitleListener(this, zcodeSid));\n        backend.registerEventListener(zcodeSid, new AxomZcodeSubagents(this, zcodeSid));\n        this.backgroundListenerBackend.set(zcodeSid, backend);"
+    },
+    {
+      "file": "dist/handlers/background-tasks.js",
+      "before_sha256": "c0e1eb4ca1585ab419fc1bb6e8878a8b9c9ab680ef664ec3c0a9c542d3b561ca",
+      "after_sha256": "4dead20a31589b1ac79d526160272ac84cb8d12626a80d6085fb5c3e131d80a4",
+      "before": "/** Map a zcode background task status string to an ACP ToolCallStatus. */\nfunction toAcpStatus(status) {\n    if (status === \"completed\")\n        return \"completed\";\n    if (status === \"failed\" || status === \"error\" || status === \"cancelled\")\n        return \"failed\";\n    return \"in_progress\"; // running / pending / unknown\n}",
+      "after": "/** Map a zcode background task status string to an ACP ToolCallStatus. */\nfunction toAcpStatus(status) {\n    if (status === \"completed\")\n        return \"completed\";\n    if (status === \"failed\" || status === \"error\" || status === \"cancelled\")\n        return \"failed\";\n    return \"in_progress\"; // running / pending / unknown\n}\n/** Axom patch `zcode-subagent-subwork`: when the client declared the AIR async-task\n * capability, the AxomZcodeSubagents listener forwards these same events as\n * `async_task_*` session updates bound to the launch card (and sub-agent tasks as\n * subagent variants) — minting this listener's own [background] card on top would\n * render one task twice on such clients. */\nfunction axomAsyncTasksOwned(server) {\n    const air = server?.clientCapabilities?._meta?.jetbrains?.air;\n    return !!(air && Array.isArray(air.capabilities) && air.capabilities.includes(\"asyncTasks\"));\n}"
+    },
+    {
+      "file": "dist/handlers/background-tasks.js",
+      "before_sha256": "4dead20a31589b1ac79d526160272ac84cb8d12626a80d6085fb5c3e131d80a4",
+      "after_sha256": "c01f1d9f7dfae968d06afa142150ec9f6770f0d1f5a2c64b9e6475325882b223",
+      "before": "    async onTaskStatus(p) {\n        const taskId = p.taskId;",
+      "after": "    async onTaskStatus(p) {\n        // Axom patch `zcode-subagent-subwork`: with the AIR async-task capability declared,\n        // AxomZcodeSubagents forwards these events as async_task variants bound to the\n        // launch card (sub-agent tasks as subagent variants) — skip this listener's own\n        // [background] card so one task does not render twice on such clients.\n        if (p.taskKind !== \"workflow\" && axomAsyncTasksOwned(this.server))\n            return;\n        const taskId = p.taskId;"
+    },
+    {
+      "file": "dist/handlers/session.js",
+      "before_sha256": "e36756aa50f823d97df4861566fafc2ea6b36d7baf6d1f9aa9f918930e1c40a6",
+      "after_sha256": "799343ea4036b518ad7d411d192c696ebe821a4eb2b32e87c0b8b5f288cf509f",
+      "before": "async function adoptStoredTitle(server, acpSid, zcodeSid) {\n    if (server.sessionTitles.has(acpSid))\n        return;",
+      "after": "async function adoptStoredTitle(server, acpSid, zcodeSid) {\n    // Axom patch `zcode-subagent-subwork`: the in-memory title is usually the first\n    // prompt's echo; the backend's stored generated title is the real answer, and the\n    // live titleUpdated push is routinely lost at a backend respawn boundary — this\n    // load-time read is then the only surviving copy. A user-pinned rename still wins.\n    if (server.sessionTitles.has(acpSid) && server.titleUserSetBy.has(acpSid))\n        return;"
+    },
+    {
+      "file": "dist/handlers/session.js",
+      "before_sha256": "799343ea4036b518ad7d411d192c696ebe821a4eb2b32e87c0b8b5f288cf509f",
+      "after_sha256": "e28f651c842a85e308e12f3e97d742bcb49a2f470530f7fe3babe4c04fdca4c9",
+      "before": "        if (hit?.title) {\n            server.sessionTitles.set(acpSid, hit.title);\n            server.touchSessionSummary(acpSid, hit.title);\n            refreshTerminalTabTitle(server, acpSid);\n            log(`adopted stored title for ${acpSid.slice(0, 8)}: ${hit.title}`);\n        }",
+      "after": "        if (hit?.title && server.sessionTitles.get(acpSid) !== hit.title) {\n            server.sessionTitles.set(acpSid, hit.title);\n            server.touchSessionSummary(acpSid, hit.title);\n            refreshTerminalTabTitle(server, acpSid);\n            // Axom patch `zcode-subagent-subwork`: broadcast so hosts sync the stored\n            // generated title on (re-)attach — the live push was lost at a respawn.\n            void sendSessionUpdate(server.clients.broadcast(), acpSid, {\n                sessionUpdate: \"session_info_update\",\n                title: hit.title,\n                updatedAt: new Date().toISOString(),\n            }).catch(() => { });\n            log(`adopted stored title for ${acpSid.slice(0, 8)}: ${hit.title}`);\n        }"
+    }
+  ]
+}

package/dist/cli.js

@@ -25,7 +25,8 @@ export function buildProgram() {
         .command('auth')
         .description('Authorize axom-cli with an Axomwork server')
         .option('--server <url>', 'Axomwork server URL')
-        .action((options) => runCommand(() => authAction({ server: options.server ?? serverOption() })));
+        .option('--cowork', 'Request delegated cowork session access')
+        .action((options) => runCommand(() => authAction({ server: options.server ?? serverOption(), cowork: options.cowork })));
     program
         .command('whoami')
         .description('Print the authenticated Axomwork user')
@@ -38,6 +39,40 @@ export function buildProgram() {
     program
         .command('__credential-broker', { hidden: true })
         .action(() => runCredentialBroker());
+    const qoderCommand = program.command('qoder-acp')
+        .description('Prepare or run the Qoder SDK ACP adapter')
+        .option('--qodercli <path>', 'Explicit Qoder CLI executable')
+        .option('--prepare-sdk', 'Install the separate SDK runtime, then exit');
+    qoderCommand.action(async (options) => {
+        if (Boolean(options.qodercli) === Boolean(options.prepareSdk))
+            qoderCommand.error('Choose exactly one of --prepare-sdk or --qodercli <path>');
+        try {
+            if (options.prepareSdk) {
+                const { prepareSdkRuntime } = await import('./workstation/qoderAdapter/sdkRuntimeInstall.js');
+                const controller = new AbortController();
+                const cancel = () => controller.abort();
+                process.once('SIGINT', cancel);
+                process.once('SIGTERM', cancel);
+                try {
+                    console.error('Preparing Qoder SDK…');
+                    const result = await prepareSdkRuntime({ signal: controller.signal });
+                    console.error(`Qoder SDK ready${result.alreadyInstalled ? ' (already prepared)' : ''}: ${result.instance}`);
+                }
+                finally {
+                    process.removeListener('SIGINT', cancel);
+                    process.removeListener('SIGTERM', cancel);
+                }
+            }
+            else {
+                const { runQoderAdapter } = await import('./workstation/qoderAdapter/main.js');
+                await runQoderAdapter(options.qodercli);
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    });
     registerStructCommands(program);
     registerRecordCommands(program);
     registerExecuteCommand(program);

package/dist/commands/auth.js

@@ -2,13 +2,14 @@ import { hostname } from 'node:os';
 import { loadConfig, resolveServer, saveConfig } from '../config.js';
 import { callAxomTool } from '../mcp.js';
 import { authorizeDevice } from '../workstation/oauth/deviceAuthorization.js';
-import { revokeAndClearTokens, saveTokens } from '../credentials.js';
+import { revokeAndClearTokens, revokeRefreshToken, saveTokens } from '../credentials.js';
+import { cliRequestedScopes } from '../authScopes.js';
 export const DEFAULT_SERVER_URL = 'http://localhost:8080';
 export async function authAction(options, deps = {}) {
     const config = await loadConfig();
     const server = resolveServer(config, options.server ?? config.defaultServer ?? DEFAULT_SERVER_URL);
     const host = hostname();
-    const { accessToken, refreshToken, expiresInSeconds } = await authorizeDevice(server, `Axomwork CLI (${host})`, host, deps);
+    const { accessToken, refreshToken, expiresInSeconds, scopes } = await authorizeDevice(server, `Axomwork CLI (${host})`, host, deps, cliRequestedScopes(options.cowork));
     const updated = await loadConfig();
     try {
         await saveTokens(server, { accessToken, refreshToken, expiresAt: new Date(Date.now() + expiresInSeconds * 1000).toISOString() });
@@ -22,6 +23,7 @@ export async function authAction(options, deps = {}) {
         updated.defaultServer = server;
     }
     await saveConfig(updated);
+    console.log(`Authorized scopes: ${scopes.join(', ')}`);
     const outcome = await callAxomTool(server, 'axom__system__whoami', {});
     if (outcome.isError) {
         throw new Error(outcome.text);
@@ -39,14 +41,3 @@ export async function logoutAction(options) {
     await saveConfig(config);
     console.log(`Logged out from ${server}`);
 }
-async function revokeRefreshToken(server, refreshToken) {
-    await fetch(`${server}/oauth/revoke`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded' },
-        body: new URLSearchParams({
-            token: refreshToken,
-            token_type_hint: 'refresh_token',
-            client_id: 'axom-cli',
-        }),
-    }).catch(() => undefined);
-}