@bitkyc08/opencodex 2.80.0 → 2.81.0

package/src/adapters/zed.ts

@@ -4,6 +4,7 @@ import { createAnthropicAdapter } from "./anthropic";
 import { createGoogleAdapter } from "./google";
 import { createOpenAIChatAdapter } from "./openai-chat";
 import { createResponsesPassthroughAdapter } from "./openai-responses";
+import { createAdapterPhysicalSend } from "./physical-send";
 import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../types";
 import { createTranslatorBudget, releaseTranslatedEvent, retainTranslatedEvent, type TranslatorBudget } from "../lib/translator-budget";
 import { releaseCompactionCiphertextLease } from "../responses/compaction";
@@ -13,6 +14,7 @@ import {
   resolveZedModels,
   scrubZedCredentials,
   zedLlmFetch,
+  ZED_CLOUD_BASE_URL,
   ZED_HEADERS,
   type ZedCredentials,
 } from "../providers/zed";
@@ -340,8 +342,21 @@ export function createZedAdapter(provider: OcxProviderConfig): ProviderAdapter {
     async fetchResponse(request, ctx) {
       if (!credentials) throw new Error("Zed request credentials were not initialized");
       const fetchFn = ctx?.executor ?? globalThis.fetch;
+      const send = createAdapterPhysicalSend(ctx);
+      let completionAttempts = 0;
       return zedLlmFetch(credentials, "/completions", {
-        fetchFn,
+        fetchFn: (async (input, init) => {
+          const url = input instanceof Request ? input.url : new URL(String(input)).href;
+          // Token exchange/account lookup are support traffic; both completion attempts
+          // share admission and physical ordinals, including the provider's 401 replay.
+          if (url === `${ZED_CLOUD_BASE_URL}/client/users/me`
+            || url === `${ZED_CLOUD_BASE_URL}/client/llm_tokens`) return fetchFn(input, init);
+          const recovery = completionAttempts++ > 0;
+          return send({ url, sendClass: recovery ? "auth-recovery" : "initial",
+            ...(recovery ? { recovery: "oauth-401" } : {}),
+            dispatch: executor => executor(input, init),
+          });
+        }) as typeof globalThis.fetch,
         signal: ctx?.abortSignal,
         baseUrl: provider.baseUrl,
         fetchInit: {

package/src/claude/inbound-cache-stabilize.ts

@@ -3,10 +3,10 @@
  * occasional TaskCreate nudges) into system text that becomes Responses
  * `instructions`. That churn breaks Muse/Go prefix cache on the instructions
  * prefix even when tools stay stable. Strip dynamics from instructions;
- * surface the latest notice on `input` instead.
+ * drop token footers and surface the latest TaskCreate notice on `input` instead.
  *
- * Relocation is identified by harness shape: only a trailing, unfenced,
- * canonical notice at the end of instructions is moved. An unmatched fence
+ * Peeling is identified by harness shape: only a trailing, unfenced,
+ * canonical notice at the end of instructions is removed. An unmatched fence
  * opener covers through EOF. No match → the original string is returned
  * byte-for-byte. The matcher is content identity only; `translateAnthropicRequest`
  * requires `claudeCode.stabilizePromptCache: true` before this helper runs. Claude Code
@@ -86,7 +86,6 @@ export function stabilizeClaudeInstructionsForPromptCache(
   const ranges = fencedRanges(instructions);
   let fenceIndex = ranges.length - 1;
   let end = instructions.length;
-  let latestTotal: string | null = null;
   let latestNudge: string | null = null;
   let peeled = false;
 
@@ -110,7 +109,6 @@ export function stabilizeClaudeInstructionsForPromptCache(
 
     while (fenceIndex >= 0 && ranges[fenceIndex]!.start > contentStart) fenceIndex--;
     if (fenceIndex >= 0 && contentStart < ranges[fenceIndex]!.end) break;
-    if (total && latestTotal === null) latestTotal = notice;
     if (nudge && latestNudge === null) latestNudge = notice;
     peeled = true;
 
@@ -123,8 +121,5 @@ export function stabilizeClaudeInstructionsForPromptCache(
   }
 
   if (!peeled) return { instructions, dynamicNotice: null };
-  const noticeParts: string[] = [];
-  if (latestTotal) noticeParts.push(latestTotal);
-  if (latestNudge) noticeParts.push(latestNudge);
-  return { instructions: instructions.slice(0, end), dynamicNotice: noticeParts.join("\n\n") };
+  return { instructions: instructions.slice(0, end), dynamicNotice: latestNudge };
 }

package/src/claude/inbound.ts

@@ -445,6 +445,7 @@ function translateAnthropicRequest(
       // a matching suffix or metadata.user_id.
       const stabilized = stabilizeClaudeInstructionsForPromptCache(joinedSystem);
       if (stabilized.instructions) body.instructions = stabilized.instructions;
+      // Token footers are dropped; append nothing if no other notice remains.
       if (stabilized.dynamicNotice) {
         input.push({
           type: "message",

package/src/claude/intercept/model-bindings.ts

@@ -35,6 +35,7 @@ export const DESKTOP_PICKER_ID_SUGGESTIONS: readonly string[] = [
   "claude-sonnet-5-5",
   "claude-sonnet-5",
   "claude-fable-5-1",
+  "claude-haiku-5-5", // 261008 preemptive suggestion; Desktop owns the live picker.
   "claude-haiku-4-5",
   "claude-opus-5",
   "claude-fable-5",

package/src/claude/intercept/picker-listener.ts

@@ -11,7 +11,7 @@
  * HTTP/1.1 server, unchanged. Upstream is one HTTP/1.1 request per client request on both paths.
  * Only the bounded bootstrap response is held; other bodies and upgraded sockets relay as streams.
  */
-import { createSecureServer } from "node:http2";
+import { constants as h2Constants, createSecureServer } from "node:http2";
 import type { Http2ServerRequest, Http2ServerResponse, ServerHttp2Session } from "node:http2";
 import { createServer, request as httpsRequest } from "node:https";
 import type { IncomingMessage, ServerResponse } from "node:http";
@@ -184,9 +184,35 @@ export async function startPickerListener(options: PickerListenerOptions): Promi
     // reason phrase differs, and sendHead branches on it.
     const res = relayRes as ServerResponse;
     const h2 = req.httpVersionMajor === 2;
+    // Bun's h2 compat response emits finish only after both stream halves close.
+    const responseWritable = h2 ? (req as Http2ServerRequest).stream : res;
+    // Framing, not method, determines whether a peer can keep sending a body. A bodyless h2
+    // request carries END_STREAM on its headers; HTTP/1.1 needs length or chunked framing.
+    const uploading = h2 ? !(req as Http2ServerRequest).stream.endAfterHeaders
+      : req.headers["transfer-encoding"] !== undefined || Number(req.headers["content-length"] ?? 0) > 0;
+    const closeInput = (completeReply = false) => {
+      if (h2) {
+        const stream = (req as Http2ServerRequest).stream;
+        if (!stream.closed && !stream.destroyed) {
+          stream.close(completeReply ? h2Constants.NGHTTP2_NO_ERROR : h2Constants.NGHTTP2_CANCEL);
+        }
+      } else if (!req.destroyed) {
+        if (completeReply) {
+          // finish is not peer receipt: destroy can truncate bytes still queued in TLS/TCP.
+          // Discard further input and flush a graceful FIN without waiting for body completion.
+          req.resume();
+          req.socket.end();
+        } else req.destroy();
+      }
+    };
     // Refusals answer with an empty response and a fixed log line that carries no request data.
     const refuse = (status: 400 | 503) => {
-      res.writeHead(status, { "Content-Length": "0" });
+      // Do not leave a refused, still-uploading stream behind after delivering its empty reply.
+      if (uploading && !req.complete) {
+        req.once("error", () => res.destroy());
+        responseWritable.once("finish", () => closeInput(true));
+      }
+      res.writeHead(status, { "Content-Length": "0", ...(!h2 && uploading && !req.complete ? { Connection: "close" } : {}) });
       res.end();
       options.log?.(`picker request refused ${status}`);
     };
@@ -209,12 +235,16 @@ export async function startPickerListener(options: PickerListenerOptions): Promi
     const fail = () => {
       if (clientGone) return;
       if (res.headersSent) res.destroy();
-      else { res.writeHead(502, { "Content-Length": "0" }); res.end(); log(502); }
+      else {
+        res.writeHead(502, { "Content-Length": "0", ...(!h2 && uploading && !req.complete ? { Connection: "close" } : {}) });
+        res.end(); log(502);
+      }
     };
     const omit = bootstrap ? new Set(["accept-encoding"]) : new Set<string>();
     const headers = upstreamRequestHeaders(req, omit);
     if (bootstrap) headers.push("Accept-Encoding", narrowBootstrapAcceptEncoding());
     let upReq: ReturnType<typeof httpsRequest>;
+    let upstreamResponded = false;
     try {
       // The HTTP/1.1 client validates the method, path and header values synchronously.
       upReq = httpsRequest({
@@ -222,13 +252,17 @@ export async function startPickerListener(options: PickerListenerOptions): Promi
         ca: upstream.ca, rejectUnauthorized: true, agent: false,
         method, path: req.url, headers, maxHeaderSize: PICKER_MAX_HEADER_BYTES,
         }, upRes => {
+        upstreamResponded = true;
         const status = upRes.statusCode ?? 502;
         const originalHeaders = filteredHeaders(upRes.rawHeaders);
         const sendHead = (raw: string[]) => {
           if (res.headersSent) return;
           // HTTP/2 has no reason phrase; its compat writeHead takes the same flat raw header array.
           if (h2) (relayRes as Http2ServerResponse).writeHead(status, raw as unknown as Record<string, string>);
-          else res.writeHead(status, upRes.statusMessage, raw);
+          else {
+            if (uploading && !req.complete) raw.push("Connection", "close");
+            res.writeHead(status, upRes.statusMessage, raw);
+          }
           log(status);
         };
         upRes.on("error", fail);
@@ -293,6 +327,39 @@ export async function startPickerListener(options: PickerListenerOptions): Promi
     // Bun's compat response skips its close event for a HEAD reset before end(); the stream's own
     // close always fires. Destroying an upstream request that already completed is a no-op.
     if (h2) (req as Http2ServerRequest).stream.once("close", onClientClose);
+    if (uploading) {
+      let uploadFinished = false;
+      const finishUpload = () => {
+        if (uploadFinished) return;
+        uploadFinished = true;
+        req.off("end", finishUpload);
+        req.off("close", finishUpload);
+        upReq.off("close", onUpstreamClose);
+        responseWritable.off("finish", onResponseFinish);
+        res.off("close", stopUnfinishedUpload);
+        if (h2) (req as Http2ServerRequest).stream.off("close", finishUpload);
+      };
+      // Upstream close can precede draining a successful reply to a slow downstream.
+      // Stop relaying input only once that reply's writable finishes or closes.
+      const stopUnfinishedUpload = (completeReply = false) => {
+        if (!uploadFinished) {
+          req.unpipe(upReq);
+          closeInput(completeReply);
+          finishUpload();
+          upReq.destroy();
+        }
+      };
+      const onResponseFinish = () => stopUnfinishedUpload(true);
+      const onUpstreamClose = () => {
+        if (!upstreamResponded && !res.writableEnded) stopUnfinishedUpload();
+      };
+      req.once("end", finishUpload);
+      req.once("close", finishUpload);
+      upReq.once("close", onUpstreamClose);
+      responseWritable.once("finish", onResponseFinish);
+      res.once("close", stopUnfinishedUpload);
+      if (h2) (req as Http2ServerRequest).stream.once("close", finishUpload);
+    }
     req.pipe(upReq);
   };
   server.on("request", relay);

package/src/cli/account-anthropic-threshold.ts

@@ -1,7 +1,13 @@
+import type { AnthropicInstanceId } from "../providers/anthropic-instance-id";
 import { apiError, apiJson, proxyUnreachable, resolveBaseUrl, type AccountDeps } from "./account-api";
 
+/** A 200 that names another pool is refused locally; there is no upstream status to forward. */
+export function anthropicProviderIdentityError(json: Record<string, unknown>, provider: AnthropicInstanceId, label: string): number | undefined {
+  return json.provider === provider ? undefined : apiError({}, `invalid ${label} identity`, 400);
+}
+
 /** A separate account selector prevents accidentally changing the whole Anthropic pool. */
-export async function cmdAnthropicAccountThreshold(args: string[], action: string, wantsJson: boolean, deps: AccountDeps): Promise<number> {
+export async function cmdAnthropicAccountThreshold(args: string[], action: string, wantsJson: boolean, deps: AccountDeps, provider: AnthropicInstanceId = "anthropic"): Promise<number> {
   const selector = args.indexOf("--account");
   const accountId = selector >= 0 ? args[selector + 1] : undefined;
   if (selector >= 0) args.splice(selector, 2);
@@ -15,8 +21,8 @@ export async function cmdAnthropicAccountThreshold(args: string[], action: strin
   const base = await resolveBaseUrl(deps);
   if (!base) return proxyUnreachable();
   const response = action === "status"
-    ? await apiJson(deps, base, "GET", "/api/oauth/accounts?provider=anthropic")
-    : await apiJson(deps, base, "PUT", "/api/oauth/accounts/auto-switch", { provider: "anthropic", accountId, threshold });
+    ? await apiJson(deps, base, "GET", `/api/oauth/accounts?provider=${provider}`)
+    : await apiJson(deps, base, "PUT", "/api/oauth/accounts/auto-switch", { provider, accountId, threshold });
   if (response.status === 0) return proxyUnreachable(response.transportError);
   if (response.status !== 200) return apiError(response.json, "failed to update account threshold", response.status);
   if (!response.json || typeof response.json !== "object" || Array.isArray(response.json)) return apiError({}, "invalid account threshold response", 400);
@@ -28,7 +34,10 @@ export async function cmdAnthropicAccountThreshold(args: string[], action: strin
   const validPercent = (value: unknown) => typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 100;
   if ((result.autoSwitchThresholdOverride !== null && !validPercent(result.autoSwitchThresholdOverride))
     || !validPercent(result.effectiveAutoSwitchThreshold)) return apiError({}, "invalid account threshold response", 400);
-  const payload = { provider: "anthropic", accountId, autoSwitchThresholdOverride: result.autoSwitchThresholdOverride,
+  const responseProvider = action === "status" ? response.json.provider : result.provider;
+  if ((provider === "anthropic2" || responseProvider !== undefined) && responseProvider !== provider) return apiError({}, "invalid account threshold identity", 400);
+  if (action !== "status" && (provider === "anthropic2" || result.accountId !== undefined) && result.accountId !== accountId) return apiError({}, "invalid account threshold identity", 400);
+  const payload = { provider, accountId, autoSwitchThresholdOverride: result.autoSwitchThresholdOverride,
     effectiveAutoSwitchThreshold: result.effectiveAutoSwitchThreshold };
   if (wantsJson) console.log(JSON.stringify(payload, null, 2));
   else console.log(`auto-switch: ${payload.autoSwitchThresholdOverride === null ? "inherited" : "custom"} (${payload.effectiveAutoSwitchThreshold === 0 ? "usage-based switching disabled" : `${payload.effectiveAutoSwitchThreshold}%`})`);
@@ -36,6 +45,6 @@ export async function cmdAnthropicAccountThreshold(args: string[], action: strin
 }
 
 function invalid(): number {
-  console.error("Usage: ocx account auto-switch anthropic <status|inherit|on|off|threshold <0-100>> --account <id> [--json]");
+  console.error("Usage: ocx account auto-switch <anthropic|anthropic2> <status|inherit|on|off|threshold <0-100>> --account <id> [--json]");
   return 2;
 }

package/src/cli/account-api.ts

@@ -1,3 +1,4 @@
+import { configuredAnthropicInstance, isAnthropicOAuthInstance } from "../providers/anthropic-instance";
 import { parseQuotaFailureCode, type QuotaFailureCode, type ProviderQuota, type AccountQuotaMode } from "../providers/quota-types";
 /**
  * Data-access layer for `ocx account` (issue #180) — live-proxy HTTP client and
@@ -110,6 +111,7 @@ export function classifyAccount(config: OcxConfig, name: string): ClassifyResult
   if (provider && !provider.authMode && (provider.apiKey || (provider.apiKeyPool?.length ?? 0) > 0)) {
     return { type: "api-key" };
   }
+  if (name === "anthropic2" && !configuredAnthropicInstance(config, name)) return { error: "Anthropic pool instance is not configured" };
   if (isPublicOAuthProvider(name)) return { type: "oauth" };
   if (provider) return { type: "api-key" };
   return { error: `unknown provider "${name}"` };
@@ -408,7 +410,7 @@ async function fetchOAuthRows(
     needsReauth: a.needsReauth,
     ...projectAccountHealth(a, name, a.id),
     ...(a.paused === true ? { paused: true } : {}),
-    ...(name === "anthropic" && Object.hasOwn(a, "autoSwitchThresholdOverride") ? { autoSwitchThresholdOverride: a.autoSwitchThresholdOverride } : {}),
+    ...(isAnthropicOAuthInstance(name) && Object.hasOwn(a, "autoSwitchThresholdOverride") ? { autoSwitchThresholdOverride: a.autoSwitchThresholdOverride } : {}),
     ...(a.needsReauthReason === "verify_account" ? { needsReauthReason: a.needsReauthReason } : {}),
     ...(name === "kiro" && typeof a.autoSelectable === "boolean"
       ? { autoSelectable: a.autoSelectable } : {}),

package/src/cli/account-extended.ts

@@ -1,5 +1,6 @@
+import { isAnthropicOAuthInstance } from "../providers/anthropic-instance";
 import { loadConfig } from "../config";
-import { cmdAnthropicAccountThreshold } from "./account-anthropic-threshold";
+import { anthropicProviderIdentityError, cmdAnthropicAccountThreshold } from "./account-anthropic-threshold";
 import { isReservedCodexAccountWord, reportCodexAccountTargetError, resolveCodexAccountTarget } from "./account-target";
 import { hasPassiveAccountQuota } from "../providers/quota";
 import { closeSync, openSync, readSync, readFileSync, statSync } from "node:fs";
@@ -41,7 +42,7 @@ const AUTO_NOTE = "auto (no pin — lowest-usage account is selected per request
 const EXTENDED_USAGE = `Usage:
   ocx account refresh <provider> [--json]
   ocx account auto-switch <provider> <on|off|status|threshold <0-100>> [--json]
-  ocx account auto-switch anthropic <on|off|status|inherit|threshold <0-100>> --account <id> [--json]
+  ocx account auto-switch <anthropic|anthropic2> <on|off|status|inherit|threshold <0-100>> --account <id> [--json]
   ocx account alias <provider> <id|alias|main> <display-name|-> [--json]
   ocx account priority <provider> <id|alias|main> [<-100..100|first|earlier|normal|later|last|reset>] [--json]
   ocx account pause <provider> <id|alias|main> [--json]
@@ -49,7 +50,7 @@ const EXTENDED_USAGE = `Usage:
   ocx account pause-exhausted <provider> [--json]
   ocx account strategy <provider> [<quota|round-robin|fill-first|least-loaded|reset-first>] [--json]
   ocx account sticky <provider> [<1-100>] [--json]
-  ocx account routes anthropic [--file <json-file>|--clear] [--json]
+  ocx account routes <anthropic|anthropic2> [--file <json-file>|--clear] [--json]
   ocx account remove <provider> <id|alias|main> --yes [--json]
   ocx account clear-cooldown <provider> <id|alias|main> [--json]
   ocx account add-key <provider> [--label <label>] [--json]
@@ -360,8 +361,8 @@ export async function cmdAutoSwitch(args: string[], deps: AccountDeps): Promise<
   const classified = configAndType(deps, name);
   // Anthropic keeps its threshold on its own pool contract; generic OAuth providers (#695)
   // and the Codex pool are accepted here.
-  if (!("error" in classified) && classified.type === "oauth" && name === "anthropic") return cmdAnthropicAccountThreshold(args, action, wantsJson, deps);
-  if ("error" in classified || classified.type === "api-key" || name === "anthropic") {
+  if (!("error" in classified) && classified.type === "oauth" && isAnthropicOAuthInstance(name)) return cmdAnthropicAccountThreshold(args, action, wantsJson, deps, name);
+  if ("error" in classified || classified.type === "api-key" || isAnthropicOAuthInstance(name)) {
     return usage("Error: auto-switch only applies to the openai Codex account pool or a generic OAuth provider pool");
   }
   const genericPool = classified.type === "oauth";
@@ -638,7 +639,7 @@ export async function cmdClearCooldown(args: string[], deps: AccountDeps): Promi
   if (!name || !requestedId || args.length) return usage();
   const classified = configAndType(deps, name);
   if ("error" in classified) return usage(`Error: ${classified.error}`);
-  if (classified.type !== "codex" && !(classified.type === "oauth" && name === "anthropic")) {
+  if (classified.type !== "codex" && !(classified.type === "oauth" && isAnthropicOAuthInstance(name))) {
     return usage(`Error: ${name} has no operator-clearable account cooldown`);
   }
   const baseUrl = await resolveBaseUrl(deps);
@@ -1108,7 +1109,8 @@ export async function cmdRoutes(args: string[], deps: AccountDeps): Promise<numb
   const wantsJson = flag(args, "--json");
   const file = flagValue(args, "--file");
   const clear = flag(args, "--clear");
-  if (args.shift() !== "anthropic" || args.length || (file.found && (!file.value || clear))) return usage();
+  const provider = args.shift();
+  if (!isAnthropicOAuthInstance(provider) || args.length || (file.found && (!file.value || clear))) return usage();
   const baseUrl = await resolveBaseUrl(deps);
   if (!baseUrl) return proxyUnreachable();
   let routes: unknown;
@@ -1123,10 +1125,12 @@ export async function cmdRoutes(args: string[], deps: AccountDeps): Promise<numb
   }
   const writing = file.found || clear;
   const response = await apiJson(deps, baseUrl, writing ? "PUT" : "GET",
-    writing ? "/api/pool/settings" : "/api/pool/settings?provider=anthropic",
-    writing ? { provider: "anthropic", routes: clear ? null : routes } : undefined);
+    writing ? "/api/pool/settings" : `/api/pool/settings?provider=${provider}`,
+    writing ? { provider, routes: clear ? null : routes } : undefined);
   if (response.status === 0) return proxyUnreachable(response.transportError);
   if (response.status !== 200) return apiError(response.json, "failed to manage Anthropic routes", response.status);
+  const identityError = anthropicProviderIdentityError(response.json, provider, "Anthropic routes");
+  if (identityError !== undefined) return identityError;
   if (wantsJson) console.log(JSON.stringify(response.json, null, 2));
   else console.log(JSON.stringify(response.json.routes ?? [], null, 2));
   return 0;

package/src/cli/account-policy-dto.ts

@@ -51,7 +51,7 @@ const grant = z.object({ id: grantId, label: text, resetsTotal: z.number().int()
   percentUsed: z.object({ five_hour: threshold.optional(), seven_day: threshold.optional(),
     seven_day_overage_included: threshold.optional() }),
 }).refine(value => value.resetsLeft <= value.resetsTotal);
-export const grantsSchema = z.object({ accountId: text.min(1), eligible: z.boolean(),
+export const grantsSchema = z.object({ provider: z.enum(["anthropic", "anthropic2"]).optional(), accountId: text.min(1), eligible: z.boolean(),
   ineligibleReason: z.enum(["config_off", "tier", "seat", "mobile", "surface", "cli_version", "no_grant", "tenure", "other_experiment", "unavailable", "unknown"]).nullable(),
   atLimit: z.boolean(), grants: z.array(grant).refine(values => new Set(values.map(value => value.id)).size === values.length), nextGrantId: grantId.nullable(), weeklyResetsAt: date, cooldownUntil: date,
   pendingOperation: z.object({ operationId: z.string().uuid(), grantId, createdAt: z.number().finite(),

package/src/cli/account-policy.ts

@@ -1,3 +1,4 @@
+import { isAnthropicInstanceId } from "../providers/anthropic-instance-id";
 import { MAIN_CODEX_ACCOUNT_ID } from "../codex/account-id";
 import { isValidProviderName } from "../config/provider-name";
 import { resolveCodexAccountTargetFromRows } from "./account-target";
@@ -13,7 +14,7 @@ const USAGE = "Usage: ocx account pool <provider> [--enabled on|off] [--threshol
   + "       ocx account auto-switch openai <status|on|off|inherit|threshold N> --account ID [--json]\n"
   + "       ocx account credits openai <ID on|off|--all on|off> [--json]\n"
   + "       ocx account quota-activation openai ID --window <fiveHour|weekly> <on|off> [--json]\n"
-  + "       ocx account anthropic-reset-grants [ID] [--json]";
+  + "       ocx account anthropic-reset-grants [ID] [--provider anthropic|anthropic2] [--json]";
 const READ_ERRORS = { no_account: "No matching Anthropic OAuth account.", auth_failed: "Sign in to this Anthropic account again.",
   upstream_unavailable: "Anthropic did not return the reset-grant status.", ledger_unavailable: "The reset journal is unavailable.",
   ledger_busy: "The reset journal is busy. No grant was consumed." };
@@ -67,14 +68,14 @@ async function pool(args: string[], json: boolean, deps: RuntimeApiDeps): Promis
     patch.strategy = strategy;
   }
   if (window !== undefined) {
-    if (provider !== "anthropic" || !["five-hour", "weekly", "max-utilization"].includes(window)) usage();
+    if (!isAnthropicInstanceId(provider) || !["five-hour", "weekly", "max-utilization"].includes(window)) usage();
     patch.quotaWindow = window;
   }
   done(args);
   const pinned = { ...deps, baseUrl: await runtimeBaseUrl(deps) };
   const before = parseDto(poolSchema, await request(`/api/pool/settings?provider=${encodeURIComponent(provider)}`, pinned));
   requireEqual(before.provider, provider);
-  requireEqual(before.kind, provider === "openai" ? "codex" : provider === "anthropic" ? "anthropic" : "generic");
+  requireEqual(before.kind, provider === "openai" ? "codex" : isAnthropicInstanceId(provider) ? "anthropic" : "generic");
   if (Object.keys(patch).some(key => !(before.supported as string[]).includes(key))
     || (before.kind === "codex" && enabled !== undefined)) throw new CliUsageError("The selected pool does not support a requested field.");
   if (!Object.keys(patch).length) return output(before, json);
@@ -157,10 +158,18 @@ export async function handleAccountPolicyCommand(sub: Subcommand, args: string[]
     if (rest.includes("--json")) usage();
     if (sub === "pool") return pool(rest, json, deps);
     if (sub !== "anthropic-reset-grants") return codex(sub, rest, json, deps);
+    const selectedProvider = option(rest, "--provider");
+    const provider = selectedProvider ?? "anthropic";
+    if (!isAnthropicInstanceId(provider)) usage();
     const id = rest.length ? selector(rest.shift()) : undefined;
     done(rest);
     const pinned = { ...deps, baseUrl: await runtimeBaseUrl(deps) };
-    const result = parseDto(grantsSchema, await request(`/api/anthropic/reset-grants${id ? `?accountId=${encodeURIComponent(id)}` : ""}`, pinned));
+    // Omission preserves legacy A request syntax; explicit calls verify the echoed instance.
+    const query = new URLSearchParams();
+    if (id) query.set("accountId", id);
+    if (selectedProvider !== undefined) query.set("provider", provider);
+    const result = parseDto(grantsSchema, await request(`/api/anthropic/reset-grants${query.size ? `?${query}` : ""}`, pinned));
+    if (selectedProvider !== undefined || result.provider !== undefined) requireEqual(result.provider, provider);
     if (id) requireEqual(result.accountId, id);
     return output(result, json, "Reset-grant status read; no grant was consumed.");
   }, READ_ERRORS);

package/src/cli/account.ts

@@ -52,7 +52,7 @@ const ACCOUNT_USAGE = `Usage:
   ocx account clear <provider> [--json]
   ocx account refresh <provider> [--json]
   ocx account auto-switch <provider> <on|off|status|threshold <0-100>> [--json]
-  ocx account auto-switch anthropic <on|off|status|inherit|threshold <0-100>> --account <id> [--json]
+  ocx account auto-switch <anthropic|anthropic2> <on|off|status|inherit|threshold <0-100>> --account <id> [--json]
   ocx account alias <provider> <account-or-key-id|alias> <display-name|-> [--json]
   ocx account priority <provider> <account-id|alias|main> [<-100..100|first|earlier|normal|later|last|reset>] [--json]
   ocx account pause <provider> <account-id|alias|main> [--json]
@@ -60,7 +60,7 @@ const ACCOUNT_USAGE = `Usage:
   ocx account pause-exhausted <provider> [--json]
   ocx account strategy <provider> [<quota|round-robin|fill-first|least-loaded|reset-first>] [--json]
   ocx account sticky <provider> [<1-100>] [--json]
-  ocx account routes anthropic [--file <json-file>|--clear] [--json]
+  ocx account routes <anthropic|anthropic2> [--file <json-file>|--clear] [--json]
   ocx account remove <provider> <account-or-key-id|alias|main> --yes [--json]
   ocx account clear-cooldown <provider> <account-id|alias|main> [--json]
   ocx account add-key <provider> [--label <label>] [--json]
@@ -70,7 +70,7 @@ const ACCOUNT_USAGE = `Usage:
   ocx account pool <provider> [--enabled on|off] [--threshold N] [--strategy NAME] [--sticky N] [--quota-window W] [--json]
   ocx account credits openai <ID on|off|--all on|off> [--json]
   ocx account quota-activation openai ID --window fiveHour|weekly <on|off> [--json]
-  ocx account anthropic-reset-grants [ID] [--json]
+  ocx account anthropic-reset-grants [ID] [--provider anthropic|anthropic2] [--json]
   ocx account code <provider> [--flow <flow-id>] [--json]   (reads the code from stdin)
   ocx account cancel <provider> [--flow <flow-id>] [--json] (--flow required for codex)
   ocx account reset-credits <account-id|main> [--consume --yes] [--json]

package/src/cli/capabilities-accounts.ts

@@ -184,10 +184,10 @@ export const ACCOUNT_CAPABILITIES: readonly Capability[] = [
   },
   {
     command: ["account","anthropic-reset-grants"],
-    usage: "ocx account anthropic-reset-grants [account-id] [--json]",
+    usage: "ocx account anthropic-reset-grants [account-id] [--provider anthropic|anthropic2] [--json]",
     summary: "Read Anthropic reset-grant eligibility and pending status without consuming a grant.",
     routes: [{"method":"GET","path":"/api/anthropic/reset-grants"}],
-    flags: [{"name":"--json","value":"boolean","summary":"Emit the validated task result as one JSON document."}],
+    flags: [{ name: "--provider", value: "string", summary: "Anthropic OAuth instance: anthropic or anthropic2; omission keeps the legacy Anthropic pool." }, {"name":"--json","value":"boolean","summary":"Emit the validated task result as one JSON document."}],
     mutates: false,
     json: "envelope",
     details: ["Optional identity is the exact Anthropic account ID. Omission delegates active/fallback account choice to the server, not the Codex alias resolver.","This GET can refresh access/status information upstream. Empty grants, unavailable status, pending operation and unavailable journal remain distinct. Consume remains a GUI-session-only human handoff; no session acquisition or retry is performed."],

package/src/cli/capabilities-agents-routing.ts

@@ -1,6 +1,30 @@
 import type { Capability } from "./capability-types";
 
 export const AGENT_ROUTING_CAPABILITIES: readonly Capability[] = [
+  {
+    command: ["message", "sessions"],
+    summary: "Discover already-loaded local Codex sessions without reading conversation history.",
+    routes: [], flags: [{ name: "--json", value: "boolean", summary: "Emit a versioned local session directory." }],
+    mutates: false, json: "envelope",
+    bannerLines: ["ocx message <sub>           Loaded local Codex sessions and queued peer messages (sessions|send)"],
+    details: ["Linux/macOS Unix socket only. Uses effective CODEX_HOME; starts no daemon and returns no partial directory."],
+  },
+  {
+    command: ["message", "send"],
+    summary: "Submit one correlated peer message to an exact loaded local Codex destination.",
+    routes: [], mutates: true, json: "envelope",
+    flags: [
+      { name: "--thread", value: "string", summary: "Exact loaded UUID; choose this or --name." },
+      { name: "--name", value: "string", summary: "Unique exact loaded name; choose this or --thread." },
+      { name: "--stdin", value: "boolean", required: true, summary: "Read at most 16 KiB of UTF-8 message text." },
+      { name: "--kind", value: "string", summary: "request (default), response or notification." },
+      { name: "--in-reply-to", value: "string", summary: "Request message UUID; required only for a response." },
+      { name: "--json", value: "boolean", summary: "Emit a receipt with not_sent, queued or unknown status." },
+    ],
+    details: ["Requires daemon support for experimental thread/queue/add. Sender context comes from CODEX_THREAD_ID, not an authentication claim.",
+      "queued means submitted, not processed. unknown must not be replayed; no automatic retry, daemon start or thread resume.",
+      "Exit 0: queued; 1: not sent; 3: unknown; 64: invalid usage. No remote/Claude transport or skill installation."],
+  },
   {
     command: ["agent", "status"],
     usage: "ocx agent status [--json]",

package/src/cli/capabilities-integrations.ts

@@ -111,6 +111,22 @@ export const INTEGRATION_CAPABILITIES: readonly Capability[] = [
     json: "payload",
     details: ["With --client, restore requires --profile; only Aside profiles accept that selector. No automatic drift confirmation or retry.","Preview preserves exact opId/profile/confirm-drift intent. Generic restore derives the client on the server; the returned plan does not embed opId or complete command input.","A refused or no-op preview is completed inspection, not applied work. A stale bound mutation exits5 with a fixed re-preview hint; no replacement token is automatically adopted."],
   },
+  {
+    command: ["commandcode", "restore"],
+    usage: "ocx commandcode restore --op <opId> [--confirm-drift] [--preview | --plan-fingerprint <token>] [--json]",
+    summary: "Restore a Command Code rollback operation, retaining client ownership and drift checks.",
+    routes: [{ method: "POST", path: "/api/client-integrations/commandcode/restore" }, { method: "POST", path: "/api/client-integrations/commandcode/restore/preview" }],
+    flags: [
+      { name: "--op", value: "string", summary: "Command Code operation ID; --op-id is an alias.", required: true },
+      { name: "--confirm-drift", value: "boolean", summary: "Explicitly allow replacing edits made after the snapshot." },
+      { name: "--preview", value: "boolean", summary: "Inspect restoration without mutating; exclusive with a commit fingerprint." },
+      { name: "--plan-fingerprint", value: "string", summary: "Optional versioned token from a matching preview; stale intent is refused without retry." },
+      { name: "--json", value: "boolean", summary: "Emit the result as JSON." },
+    ],
+    mutates: true,
+    json: "payload",
+    details: ["cmd restore is an alias. --client and --profile are rejected; the dedicated route binds the operation to Command Code.", "Older proxies without the dedicated route fail without a generic restore fallback. Redirects are refused.", "Preview preserves the operation and drift intent. A stale bound mutation requires a new explicit preview."],
+  },
   {
     command: ["claude", "config", "status"],
     usage: "ocx claude config status [--json]",

package/src/cli/codex-shim-autorestore.ts

@@ -15,11 +15,14 @@ const DEFAULT_DEPS: CodexShimAutoRestoreCliDeps = {
   readConfig: readConfigDiagnostics,
 };
 
+/** Identify command namespaces whose execution must not trigger automatic shim repair. */
 export function skipsCodexShimAutoRestore(command: string | undefined, args: string[]): boolean {
   if (command === "uninstall" || command === "remove") return true;
   if (command === "status" || command === "doctor") return true;
   // `lab` is read-only inspection; it must not trigger shim side effects.
   if (command === "lab") return true;
+  // Local messaging owns its helpers; even malformed usage must not repair/start anything.
+  if (command === "message") return true;
   // `resolve` is read-only inspection for embedding shells: a lookup made to populate
   // a consent surface must not trigger a shim repair side effect first.
   if (command === "resolve") return true;

package/src/cli/dispatch.ts

@@ -145,6 +145,7 @@ const commandRunners: Record<string, CommandRunner> = {
     if (!deps.head.resolveArgs) return 64;
     return await deps.handleResolve(deps.head.resolveArgs);
   },
+  message: async deps => (await import("./message-command")).runMessageCommand(deps.args.slice(1)),
   restore: async deps => {
     const restoreArgs = deps.args.slice(1);
     const restoreJson = takeFlag(restoreArgs, "--json");
@@ -465,7 +466,7 @@ const commandRunners: Record<string, CommandRunner> = {
             },
             config,
             port: live.port,
-          }, ["mcode", "pi", "raycast", "omo", "cline", "droid", "opencode", "kilo"]));
+          }, ["mcode", "pi", "raycast", "omo", "cline", "commandcode", "droid", "opencode", "kilo"]));
         } catch (error) {
           console.warn(`Client integrations were not refreshed: ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -961,6 +962,14 @@ const commandRunners: Record<string, CommandRunner> = {
     const { handleZcodeCommand } = await import("./integrations");
     return await handleZcodeCommand(deps.args.slice(1));
   },
+  commandcode: async deps => {
+    const { handleCommandcodeCommand } = await import("./integrations");
+    return await handleCommandcodeCommand(deps.args.slice(1));
+  },
+  cmd: async deps => {
+    const { handleCommandcodeCommand } = await import("./integrations");
+    return await handleCommandcodeCommand(deps.args.slice(1));
+  },
   help: async () => {
     printUsage();
     return 0;

package/src/cli/help.ts

@@ -79,6 +79,7 @@ Usage:
   ocx alias <sub>             Short names for providers and models (list, set, rm, defaults)
   ocx combo <sub>             Combo routing strategies and failover
   ocx agent <sub>             Subagents, injection, effort caps, and sidecars
+  ocx message <sub>           Loaded local Codex sessions and queued peer messages (sessions|send)
   ocx effort [sub]            Inspect and configure reasoning effort caps and defaults
   ocx observe <sub>           Logs, usage, storage, memory, and debug data
   ocx inspect <sub>           Effective config, catalog, analytics, pacing, client-config
@@ -91,7 +92,7 @@ Usage:
   ocx api-key <sub>           Alias of ocx access key
   ocx access <sub>            External API keys and endpoint information
   ocx api <sub>               Protocol paths: vocabulary, request-path preview, and policy
-  ocx export --client <id>    Print a client config wired to the running proxy (17 clients)
+  ocx export --client <id>    Print a client config wired to the running proxy (18 clients)
   ocx integration client <sub> Enable, disable, inspect or roll back a client integration
   ocx grok <sub>              Grok Build model selection and apply
   ocx system <sub>            Runtime settings, startup, sync, OpenCodex updates, and Codex CLI inspection
@@ -105,6 +106,8 @@ Usage:
   ocx mcode [args...]         Launch MiniMax Code through its managed provider
   ocx mmx text <sub> [args]   Launch MiniMax CLI text through the proxy
   ocx zcode [sub]             Connect ZCode to the proxy (managed provider)
+  ocx commandcode [sub]       Connect Command Code CLI to the proxy (managed provider)
+  ocx cmd [sub]               Alias of ocx commandcode
   ocx help [command]          Show help
   ocx --version | -v          Print version
 

package/src/cli/index.ts

@@ -210,11 +210,17 @@ initializeNodeLauncherContext();
 // The compiled executable is also the capture-only MCP server's launcher.
 // Handle this private entrypoint before CLI preflight or command dispatch.
 if (process.argv[2] === "__keyring-load-check") { console.log(JSON.stringify((await import("../lib/keyring-native")).inspectKeyringBinding())); process.exit(0); }
-if (process.argv[2] === "__codebuddy-mcp") {
-  const { runCodeBuddyMcpServer } = await import("../adapters/codebuddy/mcp-server");
-  await runCodeBuddyMcpServer(process.argv[3] ?? "");
-  // The MCP stdio loop owns this process until stdin closes; do not fall through
-  // to ordinary CLI dispatch or exit after the handshake completes.
+
+// The compiled executable also launches the isolated MCP servers.
+// Handle these private entrypoints before CLI preflight or command dispatch.
+if (process.argv[2] === "__codebuddy-mcp" || process.argv[2] === "__qoder-mcp") {
+  if (process.argv[2] === "__codebuddy-mcp") {
+    const { runCodeBuddyMcpServer } = await import("../adapters/codebuddy/mcp-server");
+    await runCodeBuddyMcpServer(process.argv[3] ?? "");
+  } else {
+    const { runCodingAgentMcpServer } = await import("../adapters/coding-agent/mcp-server");
+    await runCodingAgentMcpServer(process.argv[3] ?? "");
+  }
   await new Promise<never>(() => {});
 }