@bitkyc08/opencodex 2.35.0 → 2.36.0-preview.20260830

package/src/adapters/openai-chat.ts

@@ -8,10 +8,12 @@ import { isDebugEnabled } from "../lib/debug-settings";
 import { isCyberPolicyCode } from "../lib/errors";
 import { redactSecretString } from "../lib/redact";
 import { contentPartsToText } from "./image";
+import { EMPTY_TOOL_OUTPUT_ANNOTATION, isWhitespaceOnlyTextPartArray } from "./empty-tool-output-annotation";
 import { identifyRoutedModel } from "./identity";
 import { peekReasoningForCall } from "../responses/reasoning-replay-cache";
 import { buildNonOpenAIToolCatalogNudgeForTools, shouldInjectNonOpenAIToolCatalogNudge } from "./tool-catalog-nudge";
 import { openRouterProviderPayload, resolveOpenRouterRouting } from "../providers/openrouter-routing";
+import { resolveVercelGatewayRouting, vercelGatewayProviderPayload } from "../providers/vercel-gateway-routing";
 import {
   canForwardForeignServiceTierForChatModel,
   fastPolicyForModel,
@@ -26,6 +28,7 @@ import {
 } from "../providers/fastwire";
 import { openaiChatCompletionsUrl } from "./openai-chat-url";
 import { stripResponsesOnlyEncryptedMarker } from "./responses-tool-schema";
+import { agentRouterDefaultHeaders, frameAgentRouterMessages } from "./agentrouter";
 import {
   isXaiSchemaTarget,
   lookupLocalJsonPointer,
@@ -87,7 +90,10 @@ function openAIChatTransport(provider: OcxProviderConfig): {
   if ((provider.authMode === "key" || provider.authMode === "oauth") && !provider.keyOptional && !hasCredential) {
     throw new Error(`${provider.adapter} requires a non-empty credential (authMode: ${provider.authMode})`);
   }
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...agentRouterDefaultHeaders(provider.baseUrl, provider.headers),
+  };
   if (hasCredential) headers.Authorization = `Bearer ${provider.apiKey}`;
   if (provider.headers) Object.assign(headers, provider.headers);
   return { url: openaiChatCompletionsUrl(provider.baseUrl), headers, hasCredential };
@@ -111,7 +117,7 @@ export function buildOpenAIChatPassthroughRequest(
 
   const body: Record<string, unknown> = {
     model: provider.modelSuffixBracketStrip ? stripBracketedModelSuffix(modelId) : modelId,
-    messages: rawBody.messages,
+    messages: frameAgentRouterMessages(provider.baseUrl, rawBody.messages),
     stream,
   };
   for (const field of CHAT_PASSTHROUGH_FIELDS) {
@@ -120,6 +126,8 @@ export function buildOpenAIChatPassthroughRequest(
 
   const openRouterRouting = resolveOpenRouterRouting(provider, modelId);
   if (openRouterRouting) body.provider = openRouterProviderPayload(openRouterRouting);
+  const vercelRouting = resolveVercelGatewayRouting(provider, modelId);
+  if (vercelRouting) body.provider = vercelGatewayProviderPayload(vercelRouting);
 
   if (modelInList(provider.noTemperatureModels, modelId)) delete body.temperature;
   if (modelInList(provider.noTopPModels, modelId)) delete body.top_p;
@@ -588,9 +596,22 @@ function isNativeOpenAIChatTarget(provider: OcxProviderConfig): boolean {
  * being flattened to the "[image]" marker the model can't actually see. Data URLs and remote https
  * URLs are both valid in image_url.url, unlike Gemini inline_data which needs base64.
  */
-function toolResultTextForWire(content: string | OcxContentPart[]): string {
-  if (typeof content === "string") return content;
+function toolResultTextForWire(content: string | OcxContentPart[], annotateEmpty = false): string {
+  // An empty content array is a present-but-empty result; `contentPartsToText` would
+  // otherwise fall back to the "[image]" marker and hide the emptiness from the model.
+  if (annotateEmpty && Array.isArray(content) && content.length === 0) return EMPTY_TOOL_OUTPUT_ANNOTATION;
+  if (typeof content === "string") {
+    if (annotateEmpty && content.trim() === "") return EMPTY_TOOL_OUTPUT_ANNOTATION;
+    return content;
+  }
   const text = content.filter((p) => p.type === "text").map((p) => (p as OcxTextContent).text).join("");
+  // A whitespace-only text-part array is the array twin of a blank string; the
+  // shared emptiness contract (same module as the Responses adapter) annotates it
+  // instead of forwarding whitespace the model silently accepts. Image parts and
+  // any other non-text part keep the array non-empty.
+  if (annotateEmpty && isWhitespaceOnlyTextPartArray(content)) {
+    return EMPTY_TOOL_OUTPUT_ANNOTATION;
+  }
   if (text) {
     const untransportableImages = content.filter((p) => p.type === "image" && !p.imageUrl).length;
     return `${text}${"[image]".repeat(untransportableImages)}`;
@@ -777,7 +798,7 @@ function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderCon
           out.push({
             role: "tool",
             tool_call_id: toolCallId,
-            content: toolResultTextForWire(msg.content),
+            content: toolResultTextForWire(msg.content, provider.annotateEmptyToolOutputs === true),
           });
           pendingToolResultImageParts.push(...toolResultImageChatParts(msg.content));
           pendingToolCalls.splice(matchIdx, 1);
@@ -822,7 +843,7 @@ function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderCon
           out.push({
             role: "tool",
             tool_call_id: toolCallId,
-            content: toolResultTextForWire(msg.content),
+            content: toolResultTextForWire(msg.content, provider.annotateEmptyToolOutputs === true),
           });
           pendingToolResultImageParts.push(...toolResultImageChatParts(msg.content));
           flushToolResultImages();
@@ -1379,7 +1400,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
 
     buildRequest(parsed: OcxParsedRequest) {
       const { url, headers, hasCredential } = openAIChatTransport(provider);
-      const messages = messagesToChatFormat(parsed, provider);
+      const messages = frameAgentRouterMessages(provider.baseUrl, messagesToChatFormat(parsed, provider));
       const tools = toolsToChatFormatForProvider(parsed, provider);
       const toolChoice = toolChoiceToChatFormat(parsed.options.toolChoice, parsed.context.tools, provider);
 
@@ -1406,6 +1427,8 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       const maxTokens = resolveMaxTokens(provider, parsed);
       const openRouterRouting = resolveOpenRouterRouting(provider, parsed.modelId);
       if (openRouterRouting) body.provider = openRouterProviderPayload(openRouterRouting);
+      const vercelRouting = resolveVercelGatewayRouting(provider, parsed.modelId);
+      if (vercelRouting) body.provider = vercelGatewayProviderPayload(vercelRouting);
       if (tools) body.tools = tools;
       if (tools && toolChoice !== undefined) {
         body.tool_choice = modelInList(provider.autoToolChoiceOnlyModels, parsed.modelId)

package/src/adapters/openai-responses.ts

@@ -14,13 +14,14 @@ import {
   isOpenAiOperatedResponsesDestination,
 } from "../providers/openai-tiers";
 import { OCX_REASONING_PREFIX } from "../responses/reasoning-envelope";
-import { modelRecordValue } from "../reasoning-effort";
+import { configuredReasoningEfforts, mapReasoningEffort, modelRecordValue } from "../reasoning-effort";
 import type { TranslatorBudget } from "../lib/translator-budget";
 import { rewriteRoutedCustomToolsForUpstream } from "../responses/custom-tool-compat";
 import { rewriteRoutedToolSearchForUpstream } from "../responses/tool-search-compat";
 import { rewriteRoutedNamespaceToolsForUpstream } from "../responses/namespace-tool-compat";
 import { openaiResponsesUrl } from "./openai-responses-url";
-import { normalizeXaiResponsesWebSearch } from "./xai-web-search";
+import { injectXaiResponsesXSearch, normalizeXaiResponsesWebSearch } from "./xai-web-search";
+import { EMPTY_TOOL_OUTPUT_ANNOTATION, isWhitespaceOnlyTextPartArray } from "./empty-tool-output-annotation";
 import {
   isXaiSchemaTarget,
   normalizeXaiToolParameters,
@@ -549,6 +550,27 @@ function isPlainObject(v: unknown): v is Record<string, unknown> {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 
+/**
+ * Apply the routed provider's real effort ladder to an existing Responses reasoning field.
+ * Native forward requests keep the server-owned native clamp; unknown third-party ladders stay
+ * byte-equivalent instead of acquiring a policy from this adapter.
+ */
+function mapRoutedResponsesReasoningEffort(
+  body: unknown,
+  provider: OcxProviderConfig,
+  modelId: string,
+): unknown {
+  if (provider.authMode === "forward") return body;
+  if (configuredReasoningEfforts(provider, modelId) === undefined) return body;
+  if (!isPlainObject(body) || !isPlainObject(body.reasoning)) return body;
+  const requested = body.reasoning.effort;
+  if (typeof requested !== "string") return body;
+
+  const mapped = mapReasoningEffort(provider, modelId, requested);
+  if (!mapped || mapped === requested) return body;
+  return { ...body, reasoning: { ...body.reasoning, effort: mapped } };
+}
+
 function normalizeFunctionToolSchema(tool: unknown, xaiTarget: boolean): unknown | undefined {
   if (!isPlainObject(tool) || tool.type !== "function") return tool;
   if (xaiTarget) {
@@ -821,6 +843,40 @@ function toolOutputText(output: unknown): string {
   }).filter(Boolean).join("\n");
 }
 
+/** True when a Responses tool output item is present but carries no usable content. */
+function isToolOutputEmpty(output: unknown): boolean {
+  if (typeof output === "string") return output.trim() === "";
+  if (Array.isArray(output)) {
+    // Mirror the Chat wire rule through the shared contract: only a pure
+    // text/refusal part array whose joined content trims empty is annotated.
+    // input_image, encrypted_content, input_file and any other non-text part is
+    // real output and must never be replaced.
+    return isWhitespaceOnlyTextPartArray(output);
+  }
+  // A missing or null `output` is not a present-but-empty result: it is an
+  // incomplete payload. Leave it untouched so the upstream contract fails
+  // closed, and the orphan repair can surface it honestly instead of claiming
+  // the tool ran with no output.
+  return false;
+}
+
+/**
+ * Rewrite present-but-empty tool outputs to an explicit annotation. Synthetic
+ * missing-result placeholders are non-empty and pass through untouched. No-op unless
+ * the provider opts in (`annotateEmptyToolOutputs`).
+ */
+function annotateEmptyResponsesToolOutputs(body: unknown, enabled: boolean): unknown {
+  if (!enabled || !isPlainObject(body) || !Array.isArray(body.input)) return body;
+  let changed = false;
+  const input = body.input.map(item => {
+    if (!isPlainObject(item) || (item.type !== "function_call_output" && item.type !== "custom_tool_call_output")) return item;
+    if (!isToolOutputEmpty(item.output)) return item;
+    changed = true;
+    return { ...item, output: EMPTY_TOOL_OUTPUT_ANNOTATION };
+  });
+  return changed ? { ...body, input } : body;
+}
+
 /**
  * Repair a forward-mode input array whose continuation context was lost. When the replay
  * expansion misses (proxy restart, unrecorded prior turn), previous_response_id is stripped
@@ -1202,6 +1258,13 @@ function canonicalForwardSystemText(item: Record<string, unknown>): string | nul
   return text;
 }
 
+/** Only message items may carry privileged system instructions. */
+function isCanonicalForwardSystemMessage(item: unknown): item is Record<string, unknown> {
+  return isPlainObject(item)
+    && (item.type === undefined || item.type === "message")
+    && item.role === "system";
+}
+
 /**
  * The public Responses API accepts input system messages and `truncation`, but the canonical
  * ChatGPT Codex forward endpoint rejects both. Fold only fully textual system messages into the
@@ -1225,7 +1288,7 @@ function normalizeCanonicalForwardPromptEnvelope(body: unknown): unknown {
   let sawSystemMessage = false;
   let canFoldAllSystemMessages = true;
   for (const item of input) {
-    if (!isPlainObject(item) || item.role !== "system") continue;
+    if (!isCanonicalForwardSystemMessage(item)) continue;
     sawSystemMessage = true;
     const text = canonicalForwardSystemText(item);
     if (text === null) {
@@ -1239,7 +1302,7 @@ function normalizeCanonicalForwardPromptEnvelope(body: unknown): unknown {
   const next: Record<string, unknown> = { ...body };
   if (stripTruncation) delete next.truncation;
   if (sawSystemMessage && canFoldAllSystemMessages) {
-    next.input = input.filter(item => !isPlainObject(item) || item.role !== "system");
+    next.input = input.filter(item => !isCanonicalForwardSystemMessage(item));
     const folded = foldedText.join("\n\n");
     if (folded !== "") {
       const existing = typeof body.instructions === "string" ? body.instructions : "";
@@ -1991,6 +2054,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         parsed._rawBody,
         forward || parsed._previousResponseInputExpanded === true,
       );
+      outBody = mapRoutedResponsesReasoningEffort(outBody, provider, parsed.modelId);
       // stripPreviousResponseId() intentionally returns its input on a no-op. Detach before the
       // tier write so a force-fast/default decision can never mutate parsed._rawBody.
       outBody = applyTierDecisionToResponsesBody(outBody, parsed.options?.tierDecision);
@@ -2001,6 +2065,9 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       // pair from its own storage either, so it needs the same repair the forward
       // backend gets — dropping previous_response_id is not much use if the body that
       // reaches the wire is unparseable.
+      if (provider.annotateEmptyToolOutputs === true) {
+        outBody = annotateEmptyResponsesToolOutputs(outBody, true);
+      }
       if (forward || stateless) {
         outBody = repairOrphanedInputItems(outBody, unexpandedMiss, stateless && !forward);
       }
@@ -2063,6 +2130,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         // Preserve xAI's cached-only fail-closed semantics and image-search mapping before the
         // generic capability fallback removes the private OpenAI fields.
         outBody = normalizeXaiResponsesWebSearch(outBody, provider);
+        outBody = injectXaiResponsesXSearch(outBody, provider, parsed._replayPrefixLen);
         // xAI and explicitly classified compatible gateways reject these OpenAI web_search
         // extensions. Keep them for OpenAI API-key traffic and unclassified gateways.
         if (provider.supportsOpenAiWebSearchToolFields === false) {

package/src/adapters/registry.ts

@@ -8,6 +8,7 @@ import { createGoogleAdapter } from "./google";
 import { createKiroAdapter } from "./kiro";
 import { createMimoFreeAdapter } from "./mimo-free";
 import { createOpenAIChatAdapter } from "./openai-chat";
+import { createOllamaNativeAdapter } from "./ollama-native";
 import { createResponsesPassthroughAdapter } from "./openai-responses";
 import type { OcxProviderConfig } from "../types";
 import { createAdapterTierMetadata } from "../providers/fastwire";
@@ -21,6 +22,7 @@ export interface AdapterFactoryContext {
 export type AdapterWire =
   | "command-code"
   | "openai-chat"
+  | "ollama-native"
   | "anthropic"
   | "openai-responses"
   | "google"
@@ -62,6 +64,11 @@ export const ADAPTER_REGISTRY = {
     create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) =>
       withClinePassDeepSeekV4ToolReplayCompatibility(createOpenAIChatAdapter(provider)),
   },
+  "ollama-native": {
+    wire: "ollama-native",
+    mutation: "codex-owned",
+    create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) => createOllamaNativeAdapter(provider),
+  },
   anthropic: {
     wire: "anthropic",
     mutation: "codex-owned",

package/src/adapters/xai-web-search.ts

@@ -3,6 +3,7 @@ import { isXaiResponsesDestination } from "../providers/xai-transport";
 
 const CODEX_WEB_SEARCH_TOOL = "web_search";
 const CODEX_WEB_SEARCH_PREVIEW_TOOL = "web_search_preview";
+const XAI_SEARCH_TOOL = "x_search";
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -135,6 +136,15 @@ function normalizeToolChoice(body: Record<string, unknown>): Record<string, unkn
   return body;
 }
 
+function currentInputStart(inputLength: number, replayPrefixLength: number | undefined): number {
+  if (typeof replayPrefixLength !== "number" || !Number.isFinite(replayPrefixLength)) return 0;
+  return Math.min(inputLength, Math.max(0, Math.trunc(replayPrefixLength)));
+}
+
+function hasToolType(tools: unknown, type: string): boolean {
+  return Array.isArray(tools) && tools.some(tool => isPlainObject(tool) && tool.type === type);
+}
+
 /**
  * Make Codex's hosted web-search declaration acceptable to xAI Responses without changing other
  * providers or mutating the caller-owned request body.
@@ -184,3 +194,51 @@ export function normalizeXaiResponsesWebSearch(
 
   return normalizeToolChoice(next);
 }
+
+function isLiveWebSearchTool(tool: unknown): boolean {
+  return isPlainObject(tool)
+    && tool.type === CODEX_WEB_SEARCH_TOOL
+    && (!Object.hasOwn(tool, "external_web_access") || tool.external_web_access === true);
+}
+
+/**
+ * Add xAI's hosted X search declaration without changing web-search normalization or selectors.
+ * Destination classification belongs only to this opt-in injection path; the public-API
+ * normalizer above intentionally retains its narrower causality boundary.
+ */
+export function injectXaiResponsesXSearch(
+  body: unknown,
+  provider: Pick<OcxProviderConfig, "baseUrl" | "xaiResponsesXSearch">,
+  replayPrefixLength?: number,
+): unknown {
+  if (
+    !isPlainObject(body)
+    || !isXaiResponsesDestination(provider)
+    || provider.xaiResponsesXSearch !== true
+  ) return body;
+
+  const input = Array.isArray(body.input) ? body.input : undefined;
+  const inputStart = input ? currentInputStart(input.length, replayPrefixLength) : 0;
+  const currentInput = input?.slice(inputStart) ?? [];
+  const currentXSearchDeclared = hasToolType(body.tools, XAI_SEARCH_TOOL)
+    || currentInput.some(item =>
+      isPlainObject(item)
+      && item.type === "additional_tools"
+      && hasToolType(item.tools, XAI_SEARCH_TOOL)
+    );
+  if (currentXSearchDeclared) return body;
+
+  const liveWebSearchSurvives = Array.isArray(body.tools) && body.tools.some(isLiveWebSearchTool)
+    || currentInput.some(item =>
+      isPlainObject(item)
+      && item.type === "additional_tools"
+      && Array.isArray(item.tools)
+      && item.tools.some(isLiveWebSearchTool)
+    );
+  if (!liveWebSearchSurvives) return body;
+
+  // Declaration does not grant selection when `tool_choice` names a specific tool or carries an
+  // `allowed_tools` set that excludes x_search, so leave that selector byte-shape untouched.
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  return { ...body, tools: [...tools, { type: XAI_SEARCH_TOOL }] };
+}

package/src/claude/desktop-3p.ts

@@ -585,7 +585,9 @@ export function writeDesktop3pConfig(
       ? metadata.entries.map(current => current === existing ? entry : current)
       : [...metadata.entries, entry];
 
-    const configJson = JSON.stringify(generateDesktop3pConfig(port, nativeSlugs, routedModels, apiKey, mode, profile, nativeContextCap), null, 2) + "\n";
+    const generated = generateDesktop3pConfig(port, nativeSlugs, routedModels, apiKey, mode, profile, nativeContextCap);
+    const preserved = readDesktopProfileForeignKeys(configPath);
+    const configJson = JSON.stringify({ ...preserved, ...generated }, null, 2) + "\n";
     const fingerprint = createHash("sha256").update(configJson).digest("hex").slice(0, 16);
     const { backupPath } = atomicReplaceDesktopConfig(configPath, configJson);
     try {
@@ -602,6 +604,24 @@ export function writeDesktop3pConfig(
   }
 }
 
+const OPENCODEX_DESKTOP_PROFILE_KEYS = new Set([
+  "inferenceProvider",
+  "inferenceCredentialKind",
+  "inferenceGatewayBaseUrl",
+  "inferenceGatewayApiKey",
+  "modelDiscoveryEnabled",
+  "inferenceModels",
+]);
+
+function readDesktopProfileForeignKeys(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+  if (!isRecord(parsed)) throw new Error("Claude Desktop 3P profile is not a JSON object");
+  return Object.fromEntries(
+    Object.entries(parsed).filter(([key]) => !OPENCODEX_DESKTOP_PROFILE_KEYS.has(key)),
+  );
+}
+
 /** Backup an existing owned config then atomically replace it. Exported for failure-path tests. */
 export function atomicReplaceDesktopConfig(
   path: string,

package/src/claude/desktop-policy.ts

@@ -0,0 +1,149 @@
+/** Read-only, privacy-safe Windows policy diagnosis for Claude Desktop 3P. */
+import { spawnSync } from "node:child_process";
+import { win32 } from "node:path";
+import { resolveTrustedWindowsSystemDirectory } from "../lib/windows-elevation";
+import { decodeWindowsTextBytes } from "../lib/windows-text";
+
+const CLAUDE_POLICY_KEY = "HKLM\\SOFTWARE\\Policies\\Claude";
+const CLAUDE_POLICY_PARENT_KEY = "HKLM\\SOFTWARE\\Policies";
+const POLICY_PROBE_TIMEOUT_MS = 2_000;
+
+export type ClaudeDesktopPolicyState = "present" | "absent" | "unknown" | "not_applicable";
+
+export interface ClaudeDesktopPolicyProbeResult {
+  readonly status: number | null;
+  /** Kept inside the probe boundary; diagnostics never return or log it. */
+  readonly stdout: string;
+  readonly timedOut: boolean;
+  readonly spawnFailed: boolean;
+}
+
+export type ClaudeDesktopPolicyProbeRunner = (
+  file: string,
+  args: readonly string[],
+) => ClaudeDesktopPolicyProbeResult;
+
+export interface ClaudeDesktopPolicyProbeOptions {
+  readonly platform?: NodeJS.Platform;
+  readonly run?: ClaudeDesktopPolicyProbeRunner;
+  readonly resolveSystemDirectory?: () => string;
+}
+
+export interface ClaudeDesktopPolicyHealth {
+  readonly ok: boolean;
+  readonly status: "ok" | "warning";
+  readonly state: ClaudeDesktopPolicyState;
+  readonly message: string;
+  readonly action: string;
+}
+
+const defaultPolicyProbeRunner: ClaudeDesktopPolicyProbeRunner = (file, args) => {
+  const result = spawnSync(file, [...args], {
+    encoding: "buffer",
+    maxBuffer: 64 * 1024,
+    timeout: POLICY_PROBE_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  const errorCode = (result.error as NodeJS.ErrnoException | undefined)?.code;
+  return {
+    status: result.status,
+    // Decoded only to prove key absence. This never crosses the probe boundary.
+    stdout: result.stdout ? decodeWindowsTextBytes(result.stdout) : "",
+    timedOut: errorCode === "ETIMEDOUT" || result.signal !== null,
+    spawnFailed: result.error !== undefined && errorCode !== "ETIMEDOUT",
+  };
+};
+
+function usable(result: ClaudeDesktopPolicyProbeResult): boolean {
+  return !result.timedOut && !result.spawnFailed && result.status !== null;
+}
+
+function parentListsPolicyKey(output: string): boolean {
+  const expected = CLAUDE_POLICY_KEY.toLowerCase();
+  return output.split(/\r?\n/).some(line => line.trim().toLowerCase()
+    .replace(/^hkey_local_machine\\/, "hklm\\") === expected);
+}
+
+/**
+ * Detect machine-level Claude managed policy without reading or exposing its contents.
+ *
+ * `reg.exe` returns exit 1 for both a missing key and query/access failures. As in the
+ * Windows tray registry reader, absence is therefore accepted only when the immediate
+ * parent can be queried successfully. Every other failure stays unknown.
+ */
+export function probeClaudeDesktopPolicy(
+  options: ClaudeDesktopPolicyProbeOptions = {},
+): ClaudeDesktopPolicyState {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") return "not_applicable";
+
+  let regExe: string;
+  try {
+    const systemDirectory = (options.resolveSystemDirectory ?? resolveTrustedWindowsSystemDirectory)();
+    regExe = win32.join(systemDirectory, "reg.exe");
+  } catch {
+    return "unknown";
+  }
+
+  const run = options.run ?? defaultPolicyProbeRunner;
+  let policy: ClaudeDesktopPolicyProbeResult;
+  try {
+    policy = run(regExe, ["query", CLAUDE_POLICY_KEY, "/reg:64"]);
+  } catch {
+    return "unknown";
+  }
+  if (!usable(policy)) return "unknown";
+  if (policy.status === 0) return "present";
+  if (policy.status !== 1) return "unknown";
+
+  let parent: ClaudeDesktopPolicyProbeResult;
+  try {
+    parent = run(regExe, ["query", CLAUDE_POLICY_PARENT_KEY, "/reg:64"]);
+  } catch {
+    return "unknown";
+  }
+  if (!usable(parent) || parent.status !== 0) return "unknown";
+  // The child can be listed by a readable parent while its own ACL blocks the
+  // query. That is unreadable, not absent.
+  return parentListsPolicyKey(parent.stdout) ? "unknown" : "absent";
+}
+
+/** State-only health projection shared by CLI, apply, and management status. */
+export function claudeDesktopPolicyHealth(
+  state: ClaudeDesktopPolicyState,
+): ClaudeDesktopPolicyHealth {
+  if (state === "present") {
+    return {
+      ok: false,
+      status: "warning",
+      state,
+      message: "Windows managed Claude policy is active, so Claude Desktop will ignore the local third-party profile.",
+      action: "Ask your administrator to remove or revise the managed Claude policy, then fully quit and reopen Claude Desktop.",
+    };
+  }
+  if (state === "unknown") {
+    return {
+      ok: false,
+      status: "warning",
+      state,
+      message: "OpenCodex could not verify Windows managed Claude policy; Desktop third-party profile health is unverified.",
+      action: "Check access to Windows machine policy and run the status check again before relying on Claude Desktop 3P.",
+    };
+  }
+  return {
+    ok: true,
+    status: "ok",
+    state,
+    message: state === "absent"
+      ? "No Windows managed Claude policy was detected."
+      : "Windows managed Claude policy is not applicable on this platform.",
+    action: "No action required.",
+  };
+}
+
+export function claudeDesktopPolicyWarning(
+  state: ClaudeDesktopPolicyState,
+): string | undefined {
+  const health = claudeDesktopPolicyHealth(state);
+  return health.ok ? undefined : `${health.message} Action: ${health.action}`;
+}

package/src/cli/account.ts

@@ -25,8 +25,19 @@ type TargetProvenance = "live-oauth-list" | "config" | "codex";
 
 const MAIN_ALIAS = "main";
 const MAIN_CODEX_ID = "__main__";
-/** Replacement-style single-slot OAuth (no stable identity; not HTTP-derivable). */
-const REPLACEMENT_STYLE_OAUTH = new Set(["kiro"]);
+/**
+ * Replacement-style single-slot OAuth (no stable identity; not HTTP-derivable).
+ *
+ * Empty since `d82b3049d` gave Kiro a quota-aware account pool: multiple Kiro accounts are
+ * stored under multiauth, ranked by remaining headroom in `rankAccountsByHeadroom`, and
+ * rotated on 429 by the generic OAuth failover path, which does not exclude Kiro. Printing a
+ * "single login slot" note alongside a list of several pooled accounts told operators the
+ * opposite of what the runtime does.
+ *
+ * Kept as a named seam rather than deleted: the replacement-style shape is a real category,
+ * and a future provider without stable per-account identity belongs here.
+ */
+const REPLACEMENT_STYLE_OAUTH = new Set<string>();
 
 const ACCOUNT_USAGE = `Usage:
   ocx account list [provider] [--json] [--all] [--quota [--refresh]]
@@ -111,6 +122,9 @@ function quotaText(row: AccountRow): string {
   const short = quota.fiveHourPercent ?? quota.shortPercent;
   if (typeof short === "number") parts.push(`5h ${short}%`);
   if (typeof quota.weeklyPercent === "number") parts.push(`wk ${quota.weeklyPercent}%`);
+  // Kiro bills a monthly allowance and reports no shorter window, so without this arm a
+  // perfectly healthy Kiro account prints "-" and reads as broken.
+  if (typeof quota.monthlyPercent === "number") parts.push(`mo ${Math.round(quota.monthlyPercent)}%`);
   return parts.length > 0 ? parts.join(" ") : "-";
 }
 

package/src/cli/claude-desktop.ts

@@ -37,7 +37,8 @@ export interface ApplyProfileDeps {
   postApplyImpl?: (
     mode: Desktop3pConfigMode,
     profile: DesktopProfile,
-  ) => Promise<{ ok?: boolean; path?: string; error?: string }>;
+  ) => Promise<{ ok?: boolean; path?: string; error?: string; warning?: string }>;
+  probeClaudeDesktopPolicy?: typeof import("../claude/desktop-policy").probeClaudeDesktopPolicy;
 }
 
 export async function applyProfile(
@@ -71,10 +72,11 @@ export async function applyProfile(
       // Partial success: Desktop was written but the applied marker was not
       // persisted. Pass the degradation up instead of reporting a clean apply.
       const partial = (applied as { saved?: boolean; warning?: string }).saved === false;
+      const warning = (applied as { warning?: string }).warning;
       return {
         ok: true,
         path: applied.path ?? "",
-        ...(partial ? { warning: (applied as { warning?: string }).warning ?? "applied marker was not saved" } : {}),
+        ...(warning ? { warning } : partial ? { warning: "applied marker was not saved" } : {}),
       };
     } catch (error) {
       return { ok: false, path: "", reason: error instanceof Error ? error.message : String(error) };
@@ -102,7 +104,15 @@ export async function applyProfile(
     state.profile,
     nativeContextLimits(config),
   );
-  return { ok: result.written, path: result.path, reason: result.reason };
+  const { claudeDesktopPolicyWarning, probeClaudeDesktopPolicy } = await import("../claude/desktop-policy");
+  const policyState = (deps.probeClaudeDesktopPolicy ?? probeClaudeDesktopPolicy)();
+  const warning = result.written ? claudeDesktopPolicyWarning(policyState) : undefined;
+  return {
+    ok: result.written,
+    path: result.path,
+    reason: result.reason,
+    ...(warning ? { warning } : {}),
+  };
 }
 
 export async function handleClaudeDesktopCommand(argv: string[], deps: ApplyProfileDeps = {}): Promise<number> {

package/src/cli/combo.ts

@@ -14,7 +14,7 @@ const USAGE = `Usage:
   ocx combo [list] [--json]
   ocx combo show <id> [--json]
   ocx combo set <id> --targets <provider/model[:weight],...>
-      [--strategy <failover|round-robin>] [--sticky <1-100>]
+      [--strategy <failover|round-robin|random|least-used|reset-window>] [--sticky <1-100>]
       [--effort <low|medium|high|xhigh|max|ultra|->] [--alias <name|->]
       [--native-alias] [--display-name <label|->]
       [--rename-from <id>] [--json]
@@ -73,9 +73,12 @@ async function set(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const targetsRaw = takeOption(args, "--targets");
   if (!targetsRaw) throw new CliUsageError("--targets is required", USAGE);
   const strategy = takeOption(args, "--strategy") ?? "failover";
-  if (strategy !== "failover" && strategy !== "round-robin") throw new CliUsageError("--strategy must be failover or round-robin", USAGE);
-  const stickyLimit = takeIntegerOption(args, "--sticky", { min: 1 }) ?? 1;
-  if (stickyLimit > 100) throw new CliUsageError("--sticky must be <= 100", USAGE);
+  if (strategy !== "failover" && strategy !== "round-robin" && strategy !== "random" && strategy !== "least-used" && strategy !== "reset-window") throw new CliUsageError("--strategy must be failover, round-robin, random, least-used, or reset-window", USAGE);
+  const stickyLimit = takeIntegerOption(args, "--sticky", { min: 1 });
+  if (stickyLimit !== undefined) {
+    if (stickyLimit > 100) throw new CliUsageError("--sticky must be <= 100", USAGE);
+    if (strategy !== "round-robin") throw new CliUsageError("--sticky applies only to round-robin", USAGE);
+  }
   const effort = takeOption(args, "--effort");
   const alias = takeOption(args, "--alias");
   const nativeAlias = takeFlag(args, "--native-alias");
@@ -84,7 +87,7 @@ async function set(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   rejectArgs(args, USAGE);
   const combo: Record<string, unknown> = {
     strategy,
-    stickyLimit,
+    stickyLimit: stickyLimit ?? 1,
     targets: parseTargets(targetsRaw),
   };
   if (effort !== undefined) combo.defaultEffort = effort === "-" ? null : effort;