@bitkyc08/opencodex 2.79.0 → 2.81.0

package/src/adapters/qoder/adapter.ts

@@ -1,20 +1,25 @@
 import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../../types";
+import { fileURLToPath } from "node:url";
 import type { AdapterRequest, ProviderAdapter } from "../base";
 import { mapReasoningEffort } from "../../reasoning-effort";
-import { buildSystemPrompt } from "../coding-agent/protocol";
-import { baseScopedEnv, runCodingAgentTurn, type CodingAgentDeps } from "../coding-agent/turn";
+import { buildSystemPrompt, MAX_TOOL_BLOCK_STARTS } from "../coding-agent/protocol";
+import { buildCodingAgentToolCatalog, CodingAgentToolCatalogError } from "../coding-agent/tool-catalog";
+import { baseScopedEnv, runCodingAgentTurn, type CodingAgentDeps, type CodingAgentToolBridgeInput } from "../coding-agent/turn";
 import { QODER_PROFILES, type QoderProfile } from "./profiles";
 import { QoderScaffoldFilter, QODER_SCAFFOLD_ERROR_CODE, qoderScaffoldErrorMessage } from "./scaffold-guard";
 
 export type QoderAdapterDeps = CodingAgentDeps;
 
+const QODER_MCP_SERVER_NAME = "opencodex";
+const QODER_MCP_SERVER_PATH = fileURLToPath(new URL("../coding-agent/mcp-server.ts", import.meta.url));
+
 export function buildQoderChildEnv(profile: QoderProfile, apiKey: string, systemPrompt?: string): Record<string, string> {
   const promptEnv = profile.region === "cn" ? "QODERCN_APPEND_SYSTEM_PROMPT" : "QODER_APPEND_SYSTEM_PROMPT";
   return { ...baseScopedEnv(), NO_COLOR: "1", [profile.tokenEnv]: apiKey,
     ...(systemPrompt ? { [promptEnv]: systemPrompt } : {}) };
 }
 
-/** Single-shot, tools-disabled Qoder CLI invocation; Codex remains the tool owner. */
+/** Disable Qoder's built-in tools; only a request-scoped MCP catalog can be exposed. */
 export function buildQoderArgs(parsed: OcxParsedRequest, provider: OcxProviderConfig): string[] {
   const args = [
     "-p",
@@ -35,8 +40,8 @@ export function buildQoderArgs(parsed: OcxParsedRequest, provider: OcxProviderCo
 /**
  * Wrap the turn's outbound channel with the scaffolding guard (#4190).
  *
- * The vendor CLI can put its own agent layer into the text channel despite being launched
- * with tools and MCP disabled, and the shared stream-json parser forwards a text delta
+ * The vendor CLI can put its own agent layer into the text channel despite built-in tools
+ * being disabled, and the shared stream-json parser forwards a text delta
  * without inspecting it. This is the last point that is still qoder-specific, so the guard
  * sits here rather than in the parser every coding-agent CLI shares.
  *
@@ -123,7 +128,36 @@ export function createQoderAdapter(provider: OcxProviderConfig, deps: QoderAdapt
         });
         return;
       }
-      // Qoder documents QODER_APPEND_SYSTEM_PROMPT for scoped child configuration.
+      let catalog: ReturnType<typeof buildCodingAgentToolCatalog>;
+      try {
+        catalog = buildCodingAgentToolCatalog(parsed, QODER_MCP_SERVER_NAME);
+      } catch (error) {
+        if (!(error instanceof CodingAgentToolCatalogError)) throw error;
+        emit({
+          type: "error",
+          message: "Invalid Qoder tool catalog.",
+          status: 400,
+          errorType: "invalid_request_error",
+          code: "tool_catalog_invalid",
+          retryable: false,
+        });
+        return;
+      }
+      const toolBridge: CodingAgentToolBridgeInput | undefined = catalog.tools.length > 0 || catalog.requireToolCall
+        ? {
+            serverName: QODER_MCP_SERVER_NAME,
+            serverModulePath: QODER_MCP_SERVER_PATH,
+            tools: catalog.tools,
+            emittedNameMap: catalog.emittedNameMap,
+            maxTurnToolCalls: MAX_TOOL_BLOCK_STARTS,
+            projectHistoryToolNames: true,
+            completeAssistantToolUse: true,
+            toolTurnCompletionSignal: "assistant_tool_use_stop",
+            allowedToolsFlag: "--allowed-tools",
+            standaloneEntrypoint: "__qoder-mcp",
+            requireToolCall: catalog.requireToolCall,
+          }
+        : undefined;
       // Keep the folded prompt out of argv and never inherit an ambient vendor prompt.
       const system = buildSystemPrompt(parsed);
       await runCodingAgentTurn({
@@ -135,6 +169,7 @@ export function createQoderAdapter(provider: OcxProviderConfig, deps: QoderAdapt
           buildArgs: (_profile, req, prov) => buildQoderArgs(req, prov),
           buildEnv: (profile, apiKey) => buildQoderChildEnv(profile as QoderProfile, apiKey, system),
           deps,
+          ...(toolBridge ? { toolBridge } : {}),
       });
     },
   };

package/src/adapters/qoder/scaffold-guard.ts

@@ -1,9 +1,8 @@
 /**
  * Vendor-scaffolding guard for the qoder route (#4190).
  *
- * The qoder route is contractually a text and reasoning surface: the CLI is spawned with
- * `--tools "" --strict-mcp-config --setting-sources ""`, and Codex keeps tool ownership.
- * The vendor CLI does not always honour that. It has been observed emitting its own agent
+ * Even with built-in tools disabled and strict MCP isolation, Codex keeps tool execution
+ * ownership. The vendor CLI does not always honour that. It has been observed emitting its own agent
  * layer into the assistant text channel — an MCP lazy-loading `<system-reminder>` block
  * listing the local machine's configured MCP servers, and framework tool-call markup with a
  * mismatched closer. Both reached the client verbatim, because the shared stream-json parser

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

@@ -72,6 +72,15 @@ function toolResultOutput(block: Rec): string | Rec[] {
       if (!isRec(item)) continue;
       if (item.type === "text" && typeof item.text === "string") {
         out.push({ type: "input_text", text: item.text });
+      } else if (item.type === "tool_reference" && typeof item.tool_name === "string" && item.tool_name.length > 0) {
+        // Responses has no tool_reference result carrier. Preserve ToolSearch's loaded-name
+        // evidence as result text so a reference-only reply does not become empty (#6647).
+        // This describes client output; it must not create tools or widen authorization.
+        // Text-only tool output is later joined without separators, so the marker carries its
+        // own line breaks to keep each loaded name distinct from its neighbours.
+        const prev = out[out.length - 1];
+        const lead = prev?.type === "input_text" && typeof prev.text === "string" && !prev.text.endsWith("\n") ? "\n" : "";
+        out.push({ type: "input_text", text: `${lead}Tool loaded: ${item.tool_name}\n` });
       } else if (item.type === "image") {
         const img = imageBlockToInputImage(item);
         if (img) out.push(img);
@@ -436,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]",