@bitkyc08/opencodex 2.7.43-preview.20260728 → 2.8.0

package/src/adapters/openai-responses.ts

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import type { IncomingMeta, ProviderAdapter } from "./base";
-import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig, OcxUsage } from "../types";
+import { namespacedToolName, type AdapterEvent, type OcxParsedRequest, type OcxProviderConfig, type OcxUsage } from "../types";
 import { catalogModelSupportsReasoningSummaries } from "../codex/catalog";
 import { COMPACT_PROMPT, decodeCompactionSummary, SUMMARY_PREFIX } from "../responses/compaction";
+import { collectResponsesToolGroups } from "../responses/tool-groups";
 import { decodeServerSentEvents } from "../lib/sse-decoder";
 import { isCanonicalOpenAiForwardProvider } from "../providers/openai-tiers";
 import { OCX_REASONING_PREFIX } from "../responses/reasoning-envelope";
@@ -500,72 +501,252 @@ function stripUnsupportedForwardParams(body: unknown): unknown {
   return rest;
 }
 
+const IMAGE_GEN_NAMESPACE = "image_gen";
+const HOSTED_IMAGE_GENERATION_TOOL = "image_generation";
+const IMAGE_GEN_DOTTED_PREFIX = `${IMAGE_GEN_NAMESPACE}.`;
+const IMAGE_GEN_WIRE_PREFIX = `${IMAGE_GEN_NAMESPACE}__`;
+
+/** Remove a supported client prefix before constructing the canonical image-gen wire alias. */
+function imageGenLocalName(name: string): string {
+  if (name.startsWith(IMAGE_GEN_DOTTED_PREFIX)) return name.slice(IMAGE_GEN_DOTTED_PREFIX.length);
+  if (name.startsWith(IMAGE_GEN_WIRE_PREFIX)) return name.slice(IMAGE_GEN_WIRE_PREFIX.length);
+  return name;
+}
+
+/** Build the flat public-Responses name used only on the upstream wire. */
+function imageGenWireName(name: string): string {
+  return namespacedToolName(IMAGE_GEN_NAMESPACE, imageGenLocalName(name));
+}
+
+/** Match client image-gen declarations across namespace, legacy dotted, and canonical wire forms. */
+function isImageGenClientName(name: string): boolean {
+  return name === IMAGE_GEN_NAMESPACE
+    || name.startsWith(IMAGE_GEN_DOTTED_PREFIX)
+    || name.startsWith(IMAGE_GEN_WIRE_PREFIX);
+}
+
+/** Identify declarations that should activate image-gen request normalization. */
+function declaresImageGenClientTool(tool: unknown): boolean {
+  if (!isPlainObject(tool) || typeof tool.name !== "string") return false;
+  if (tool.type === "namespace") return tool.name === IMAGE_GEN_NAMESPACE;
+  return isImageGenClientName(tool.name);
+}
+
 /**
- * Hosted tool types whose server-side function names collide with the client tools Codex
- * declares for the matching app skill. Codex sends BOTH (e.g. hosted `image_generation` plus a
- * declared `image_gen.imagegen` function/namespace tool for the imagegen skill). The ChatGPT
- * backend tolerates the pair, but the platform `/v1/responses` rejects it:
- * `Invalid Value: 'tools'. Function 'image_gen.imagegen' conflicts with a hosted tool in the
- * same request.` Keyed hosted-type → conflicting client tool-name prefix; the hosted entry is
- * dropped (the declared tool wins — Codex executes the skill client-side either way).
+ * Lower one complete Codex image-gen namespace to public Responses function tools.
+ *
+ * The public API reserves the `image_gen` namespace and restricts function names to a flat safe
+ * alphabet. `image_gen__<tool>` is therefore an upstream-only alias; client-facing responses are
+ * restored to explicit `{ namespace: "image_gen", name: "<tool>" }` calls by the server. Only a
+ * non-empty namespace containing named function tools is safe to lower. Malformed, empty, and
+ * future namespace shapes stay untouched instead of silently losing client capabilities.
  */
-const HOSTED_TOOL_NAME_CONFLICTS: ReadonlyArray<{ hostedType: string; namePrefix: string }> = [
-  { hostedType: "image_generation", namePrefix: "image_gen" },
-];
+function flattenImageGenNamespace(tool: unknown): Record<string, unknown>[] | undefined {
+  if (
+    !isPlainObject(tool)
+    || tool.type !== "namespace"
+    || tool.name !== IMAGE_GEN_NAMESPACE
+    || !Array.isArray(tool.tools)
+    || tool.tools.length === 0
+  ) return undefined;
+
+  for (const innerTool of tool.tools) {
+    if (
+      !isPlainObject(innerTool)
+      || innerTool.type !== "function"
+      || typeof innerTool.name !== "string"
+      || innerTool.name.length === 0
+    ) return undefined;
+  }
+
+  return tool.tools.map(innerTool => {
+    const functionTool = innerTool as Record<string, unknown> & { name: string };
+    return {
+      ...functionTool,
+      name: imageGenWireName(functionTool.name),
+    };
+  });
+}
+
+/** Convert a legacy dotted function declaration while preserving all other function metadata. */
+function normalizeFlatImageGenFunction(tool: unknown): unknown {
+  if (
+    !isPlainObject(tool)
+    || tool.type !== "function"
+    || typeof tool.name !== "string"
+    || !tool.name.startsWith(IMAGE_GEN_DOTTED_PREFIX)
+  ) return tool;
+  return { ...tool, name: imageGenWireName(tool.name) };
+}
+
+/** Return the image-gen function name used for stable cross-container deduplication. */
+function imageGenFunctionName(tool: unknown): string | undefined {
+  if (!isPlainObject(tool) || tool.type !== "function" || typeof tool.name !== "string") {
+    return undefined;
+  }
+  return isImageGenClientName(tool.name) ? tool.name : undefined;
+}
+
+/** True only when a declaration can yield a callable upstream-safe image-gen function alias. */
+function declaresUsableImageGenAlias(tool: unknown): boolean {
+  if (flattenImageGenNamespace(tool)) return true;
+  if (!isPlainObject(tool) || tool.type !== "function" || typeof tool.name !== "string") {
+    return false;
+  }
+  if (tool.name.startsWith(IMAGE_GEN_DOTTED_PREFIX)) {
+    return tool.name.length > IMAGE_GEN_DOTTED_PREFIX.length;
+  }
+  return tool.name.startsWith(IMAGE_GEN_WIRE_PREFIX)
+    && tool.name.length > IMAGE_GEN_WIRE_PREFIX.length;
+}
+
+/** Collect client tool-choice names and the exact upstream aliases declared for them. */
+function imageGenToolChoiceAliases(toolGroups: unknown[][]): Map<string, string> {
+  const aliases = new Map<string, string>();
+
+  for (const group of toolGroups) {
+    for (const tool of group) {
+      const flattened = flattenImageGenNamespace(tool);
+      if (flattened) {
+        for (const candidate of flattened) {
+          const wireName = candidate.name as string;
+          aliases.set(`${IMAGE_GEN_DOTTED_PREFIX}${imageGenLocalName(wireName)}`, wireName);
+          aliases.set(wireName, wireName);
+        }
+        continue;
+      }
+      if (!isPlainObject(tool) || tool.type !== "function" || typeof tool.name !== "string") {
+        continue;
+      }
+      if (
+        tool.name.startsWith(IMAGE_GEN_DOTTED_PREFIX)
+        && tool.name.length > IMAGE_GEN_DOTTED_PREFIX.length
+      ) {
+        aliases.set(tool.name, imageGenWireName(tool.name));
+      } else if (
+        tool.name.startsWith(IMAGE_GEN_WIRE_PREFIX)
+        && tool.name.length > IMAGE_GEN_WIRE_PREFIX.length
+      ) {
+        aliases.set(tool.name, tool.name);
+      }
+    }
+  }
+
+  return aliases;
+}
+
+/** Rewrite function selectors only when their corresponding declaration receives a wire alias. */
+function normalizeImageGenToolChoice(
+  toolChoice: unknown,
+  aliases: ReadonlyMap<string, string>,
+): unknown {
+  if (!isPlainObject(toolChoice)) return toolChoice;
+
+  if (toolChoice.type === "function" && typeof toolChoice.name === "string") {
+    const alias = aliases.get(toolChoice.name);
+    return alias && alias !== toolChoice.name ? { ...toolChoice, name: alias } : toolChoice;
+  }
+
+  if (toolChoice.type !== "allowed_tools" || !Array.isArray(toolChoice.tools)) return toolChoice;
+  let changed = false;
+  const tools = toolChoice.tools.map(tool => {
+    if (!isPlainObject(tool) || tool.type !== "function" || typeof tool.name !== "string") {
+      return tool;
+    }
+    const alias = aliases.get(tool.name);
+    if (!alias || alias === tool.name) return tool;
+    changed = true;
+    return { ...tool, name: alias };
+  });
+  return changed ? { ...toolChoice, tools } : toolChoice;
+}
+
+/** Identify replayed image-gen calls that require upstream wire encoding. */
+function declaresImageGenFunctionCall(item: unknown): boolean {
+  if (!isPlainObject(item) || item.type !== "function_call" || typeof item.name !== "string") {
+    return false;
+  }
+  return item.namespace === IMAGE_GEN_NAMESPACE || isImageGenClientName(item.name);
+}
+
+/** Encode native or legacy replay calls to the same flat name used by tool declarations. */
+function normalizeImageGenFunctionCall(item: unknown): unknown {
+  if (!declaresImageGenFunctionCall(item) || !isPlainObject(item) || typeof item.name !== "string") {
+    return item;
+  }
+  if (item.namespace === IMAGE_GEN_NAMESPACE) {
+    const { namespace: _namespace, ...rest } = item;
+    return { ...rest, name: imageGenWireName(item.name) };
+  }
+  if (item.name.startsWith(IMAGE_GEN_DOTTED_PREFIX)) {
+    return { ...item, name: imageGenWireName(item.name) };
+  }
+  return item;
+}
 
 /**
- * Drop hosted tools whose names collide with declared function/namespace tools (see
- * HOSTED_TOOL_NAME_CONFLICTS). Only applies on the API-key platform path: the ChatGPT backend
- * ("forward" mode) accepts the pair, and stripping there would disable native imagegen. No-op
- * (returns the original reference) when nothing matches.
+ * Normalize Codex's private image-gen tool declaration for API-key Responses providers.
  *
- * Codex Desktop Responses Lite requests do not always use top-level `body.tools`; they may place
- * the same declarations in `body.input[]` entries of type `additional_tools`. The platform validates
- * these containers as one tool namespace, so conflict detection must span all of them. The function
- * uses copy-on-write semantics and preserves the original request reference when nothing is removed.
+ * A complete `image_gen` namespace is flattened to safe `image_gen__<tool>` aliases even when it is
+ * the only image tool in the request. Replayed client calls are encoded to the same alias, including
+ * legacy dotted calls from older compatibility attempts. When a usable alias replaces a client
+ * image-gen declaration, the duplicate hosted `image_generation` entry is removed. Duplicate aliases
+ * are resolved in stable container order: top-level tools first, then Responses Lite
+ * `additional_tools` entries.
+ *
+ * This function is called only on the API-key path. ChatGPT forward mode understands the private
+ * namespace and must keep it. Copy-on-write preserves the original request reference when no
+ * namespace is flattened, hosted tool removed, or duplicate function discarded.
  */
-function stripConflictingHostedTools(body: unknown): unknown {
+function normalizeImageGenClientTools(body: unknown): unknown {
   if (!isPlainObject(body)) return body;
 
-  // Collect every tool container in the request. Traditional HTTP/SSE requests use top-level
-  // `tools`, while Responses Lite may carry the same declarations in `additional_tools` entries.
-  const toolGroups: unknown[][] = [];
-  if (Array.isArray(body.tools)) toolGroups.push(body.tools);
-  if (Array.isArray(body.input)) {
-    for (const item of body.input) {
-      if (isPlainObject(item) && item.type === "additional_tools" && Array.isArray(item.tools)) {
-        toolGroups.push(item.tools);
+  const toolGroups = collectResponsesToolGroups(body);
+  const hasImageGenClientTool = toolGroups.some(group => group.some(declaresImageGenClientTool))
+    || (Array.isArray(body.input) && body.input.some(declaresImageGenFunctionCall));
+  if (!hasImageGenClientTool) return body;
+  const hasUsableImageGenAlias = toolGroups.some(group => group.some(declaresUsableImageGenAlias));
+  const toolChoiceAliases = imageGenToolChoiceAliases(toolGroups);
+
+  const seenFunctionNames = new Set<string>();
+  const normalizeGroup = (tools: unknown[]): unknown[] => {
+    const normalized: unknown[] = [];
+    let groupChanged = false;
+
+    for (const tool of tools) {
+      if (
+        hasUsableImageGenAlias
+        && isPlainObject(tool)
+        && tool.type === HOSTED_IMAGE_GENERATION_TOOL
+      ) {
+        groupChanged = true;
+        continue;
+      }
+
+      const flattened = flattenImageGenNamespace(tool);
+      const candidates = flattened ?? [tool];
+      if (flattened) groupChanged = true;
+
+      for (const candidate of candidates) {
+        const normalizedCandidate = normalizeFlatImageGenFunction(candidate);
+        if (normalizedCandidate !== candidate) groupChanged = true;
+        const functionName = imageGenFunctionName(normalizedCandidate);
+        if (functionName && seenFunctionNames.has(functionName)) {
+          groupChanged = true;
+          continue;
+        }
+        if (functionName) seenFunctionNames.add(functionName);
+        normalized.push(normalizedCandidate);
       }
     }
-  }
-  if (toolGroups.length === 0) return body;
-
-  // Detect conflicts across containers because the client namespace and the hosted tool may be
-  // declared in different groups while still sharing one platform-validated namespace.
-  const conflicting = HOSTED_TOOL_NAME_CONFLICTS.filter(c => toolGroups.some(group =>
-    group.some(t => {
-      if (!isPlainObject(t) || typeof t.name !== "string") return false;
-      if (t.type === "namespace") return t.name === c.namePrefix;
-      return t.name === c.namePrefix || t.name.startsWith(`${c.namePrefix}.`);
-    }),
-  ));
-  if (conflicting.length === 0) return body;
-
-  // Allocate a replacement only when a hosted tool is removed. Preserve malformed entries,
-  // unrelated tools, and future tool types so this compatibility rule remains narrowly scoped.
-  const stripGroup = (tools: unknown[]): unknown[] => {
-    const filtered = tools.filter(t => {
-      const type = isPlainObject(t) && typeof t.type === "string" ? t.type : undefined;
-      if (!type) return true;
-      return !conflicting.some(c => c.hostedType === type);
-    });
-    return filtered.length === tools.length ? tools : filtered;
+
+    return groupChanged ? normalized : tools;
   };
 
   let changed = false;
   let tools = body.tools;
   if (Array.isArray(body.tools)) {
-    tools = stripGroup(body.tools);
+    tools = normalizeGroup(body.tools);
     changed ||= tools !== body.tools;
   }
 
@@ -573,13 +754,15 @@ function stripConflictingHostedTools(body: unknown): unknown {
   if (Array.isArray(body.input)) {
     let nestedChanged = false;
     const mappedInput = body.input.map(item => {
-      if (!isPlainObject(item) || item.type !== "additional_tools" || !Array.isArray(item.tools)) {
-        return item;
+      if (isPlainObject(item) && item.type === "additional_tools" && Array.isArray(item.tools)) {
+        const nestedTools = normalizeGroup(item.tools);
+        if (nestedTools === item.tools) return item;
+        nestedChanged = true;
+        return { ...item, tools: nestedTools };
       }
-      const nestedTools = stripGroup(item.tools);
-      if (nestedTools === item.tools) return item;
-      nestedChanged = true;
-      return { ...item, tools: nestedTools };
+      const normalizedCall = normalizeImageGenFunctionCall(item);
+      if (normalizedCall !== item) nestedChanged = true;
+      return normalizedCall;
     });
     if (nestedChanged) {
       input = mappedInput;
@@ -587,11 +770,15 @@ function stripConflictingHostedTools(body: unknown): unknown {
     }
   }
 
+  const toolChoice = normalizeImageGenToolChoice(body.tool_choice, toolChoiceAliases);
+  changed ||= toolChoice !== body.tool_choice;
+
   if (!changed) return body;
   return {
     ...body,
     ...(Array.isArray(body.tools) ? { tools } : {}),
     ...(Array.isArray(body.input) ? { input } : {}),
+    ...(Object.prototype.hasOwnProperty.call(body, "tool_choice") ? { tool_choice: toolChoice } : {}),
   };
 }
 
@@ -740,7 +927,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         outBody = repairOrphanedInputItems(outBody, unexpandedMiss);
         outBody = stripUnsupportedForwardParams(outBody);
       }
-      else outBody = stripConflictingHostedTools(outBody);
+      else outBody = normalizeImageGenClientTools(outBody);
       if (forward || parsed._previousResponseInputExpanded === true) {
         outBody = repairOversizedReplayCallIds(outBody);
       }

package/src/claude/agents-inject.ts

@@ -27,6 +27,7 @@ export interface ClaudeAgentDef {
   name: string;
   model: string;
   description: string;
+  effort?: NonNullable<OcxConfig["claudeCode"]>["subagentEffort"];
   blockedSkills: readonly string[];
 }
 
@@ -99,6 +100,7 @@ export function buildClaudeAgentDefs(config: OcxConfig, windows: Record<string,
       name: `${OWNED_PREFIX}${unique}`,
       model,
       description,
+      effort: config.claudeCode?.subagentEffort,
       blockedSkills: blockedSkillsFor(model),
     });
   };
@@ -124,6 +126,7 @@ export function buildClaudeAgentDefs(config: OcxConfig, windows: Record<string,
       name: `${OWNED_PREFIX}self`,
       model: marked,
       description: `Self-clone: delegate to your default main model (${marked}), synced from the /model picker at launch. ${NO_MODEL_ARG}`,
+      effort: config.claudeCode?.subagentEffort,
       blockedSkills: blockedSkillsFor(marked),
     });
   }
@@ -149,6 +152,7 @@ function renderAgentDef(def: ClaudeAgentDef): string {
     `name: ${JSON.stringify(def.name)}`,
     `description: ${JSON.stringify(def.description)}`,
     `model: ${JSON.stringify(def.model)}`,
+    ...(def.effort ? [`effort: ${JSON.stringify(def.effort)}`] : []),
     "---",
     "",
     `<!-- ${GENERATED_MARKER} -->`,
@@ -157,6 +161,7 @@ function renderAgentDef(def: ClaudeAgentDef): string {
     // BODY rides the subagent's system prompt verbatim. The proxy detects this
     // directive and overrides the request model before routing/passthrough.
     `<!-- ocx-route: ${def.model} -->`,
+    ...(def.effort ? [`<!-- ocx-effort: ${def.effort} -->`] : []),
     "",
     `You are a delegated worker running on \`${def.model}\` through the local opencodex proxy.`,
     `IDENTITY: your ACTUAL underlying model is \`${def.model}\` — the opencodex proxy routes this`,

package/src/claude/alias.ts

@@ -7,9 +7,19 @@
  * deterministic, reversible, and STABLE across releases (picker selections
  * persist to Claude Code's settings.json `model` field).
  *
+ * Versioned prefixes:
+ *  - `claude-ocx-` (v1) — legacy / plain model ids with no `/` or `~`. Decode
+ *    is literal (no escape expansion), so a persisted model id that literally
+ *    contained the two-char sequences `~s` / `~t` keeps resolving.
+ *  - `claude-ocx2-` (v2) — used whenever the model id needs escape encoding
+ *    (`/` → `~s`, `~` → `~t`). Decode expands those escapes. New slash/tilde
+ *    models always mint v2 so they cannot collide with v1 literals.
+ *
  * Reversibility rules:
  *  - providers containing `--` or `/` are not aliased (split boundary safety);
- *  - model ids containing `/` are not aliased (would be ambiguous on resolve);
+ *  - model ids MAY contain `/` or `~` — minted under the v2 prefix with escapes
+ *    (e.g. openrouter `anthropic/claude-opus-4-8` →
+ *    `claude-ocx2-openrouter--anthropic~sclaude-opus-4-8`);
  *  - model ids MAY contain `--` (resolve splits on the FIRST `--` only);
  *  - native OpenAI slugs use the pseudo-provider `native` and resolve back to
  *    the bare slug; a real provider named "native" is therefore never aliased.
@@ -17,20 +27,82 @@
 
 import { desktop3pAlias } from "./desktop-3p";
 
-export const CLAUDE_ALIAS_PREFIX = "claude-ocx-";
+/** Legacy / plain readable prefix (literal model portion on decode). */
+export const CLAUDE_ALIAS_PREFIX_V1 = "claude-ocx-";
+/** Escape-encoded readable prefix (`~s`/`~t` expanded on decode). */
+export const CLAUDE_ALIAS_PREFIX_V2 = "claude-ocx2-";
+/**
+ * Current write prefix for plain (unescaped) model ids.
+ * Escape-needing models mint {@link CLAUDE_ALIAS_PREFIX_V2} instead.
+ */
+export const CLAUDE_ALIAS_PREFIX = CLAUDE_ALIAS_PREFIX_V1;
+
+/** Encoded `/` inside the model portion of a v2 Claude Code alias. */
+const CLAUDE_ALIAS_SLASH_ENC = "~s";
+/** Encoded literal `~` inside the model portion of a v2 Claude Code alias. */
+const CLAUDE_ALIAS_TILDE_ENC = "~t";
 const NATIVE_PSEUDO_PROVIDER = "native";
 
+function modelNeedsEscapeEncoding(modelId: string): boolean {
+  return modelId.includes("/") || modelId.includes("~");
+}
+
+function encodeModelId(modelId: string): string {
+  // Escape literal tildes first so slash encoding cannot create ambiguity.
+  return modelId
+    .replaceAll("~", CLAUDE_ALIAS_TILDE_ENC)
+    .replaceAll("/", CLAUDE_ALIAS_SLASH_ENC);
+}
+
+function decodeEscapedModelId(encoded: string): string {
+  let out = "";
+  for (let i = 0; i < encoded.length; i++) {
+    if (encoded[i] === "~" && i + 1 < encoded.length) {
+      const next = encoded[i + 1];
+      if (next === "s") {
+        out += "/";
+        i += 1;
+        continue;
+      }
+      if (next === "t") {
+        out += "~";
+        i += 1;
+        continue;
+      }
+    }
+    out += encoded[i];
+  }
+  return out;
+}
+
+function splitAlias(id: string, prefix: string): { provider: string; model: string } | null {
+  const rest = id.slice(prefix.length);
+  const sep = rest.indexOf("--");
+  if (sep <= 0) return null;
+  const provider = rest.slice(0, sep);
+  const model = rest.slice(sep + 2);
+  if (!provider || !model) return null;
+  return { provider, model };
+}
+
 /** Alias for a routed "<provider>/<model>" pair; null when not representable. */
 export function aliasForRoute(provider: string, modelId: string): string | null {
   if (!provider || provider.includes("--") || provider.includes("/") || provider === NATIVE_PSEUDO_PROVIDER) return null;
-  if (!modelId || modelId.includes("/")) return null;
-  return `${CLAUDE_ALIAS_PREFIX}${provider}--${modelId}`;
+  if (!modelId) return null;
+  if (modelNeedsEscapeEncoding(modelId)) {
+    return `${CLAUDE_ALIAS_PREFIX_V2}${provider}--${encodeModelId(modelId)}`;
+  }
+  return `${CLAUDE_ALIAS_PREFIX_V1}${provider}--${modelId}`;
 }
 
 /** Alias for a native OpenAI slug (bare model id, no provider namespace). */
 export function aliasForNative(slug: string): string | null {
+  // Reject "/" — native ids are bare slugs. Literal `~` is fine via v2 + ~t.
   if (!slug || slug.includes("/") || slug.includes("--")) return null;
-  return `${CLAUDE_ALIAS_PREFIX}${NATIVE_PSEUDO_PROVIDER}--${slug}`;
+  if (modelNeedsEscapeEncoding(slug)) {
+    return `${CLAUDE_ALIAS_PREFIX_V2}${NATIVE_PSEUDO_PROVIDER}--${encodeModelId(slug)}`;
+  }
+  return `${CLAUDE_ALIAS_PREFIX_V1}${NATIVE_PSEUDO_PROVIDER}--${slug}`;
 }
 
 /**
@@ -38,20 +110,28 @@ export function aliasForNative(slug: string): string | null {
  * routed -> "<provider>/<model>", native -> bare slug. Null when not an alias.
  */
 export function resolveAlias(id: string): string | null {
-  if (!id.startsWith(CLAUDE_ALIAS_PREFIX)) return null;
-  const rest = id.slice(CLAUDE_ALIAS_PREFIX.length);
-  const sep = rest.indexOf("--");
-  if (sep <= 0) return null;
-  const provider = rest.slice(0, sep);
-  const model = rest.slice(sep + 2);
-  if (!model) return null;
-  return provider === NATIVE_PSEUDO_PROVIDER ? model : `${provider}/${model}`;
+  // Check v2 before v1 for clarity (prefixes are disjoint: ocx2 vs ocx-).
+  if (id.startsWith(CLAUDE_ALIAS_PREFIX_V2)) {
+    const parts = splitAlias(id, CLAUDE_ALIAS_PREFIX_V2);
+    if (!parts) return null;
+    const model = decodeEscapedModelId(parts.model);
+    if (!model) return null;
+    return parts.provider === NATIVE_PSEUDO_PROVIDER ? model : `${parts.provider}/${model}`;
+  }
+  if (id.startsWith(CLAUDE_ALIAS_PREFIX_V1)) {
+    const parts = splitAlias(id, CLAUDE_ALIAS_PREFIX_V1);
+    if (!parts) return null;
+    // Literal decode — preserves pre-escape aliases whose model id contained
+    // the two-char sequences ~s / ~t.
+    return parts.provider === NATIVE_PSEUDO_PROVIDER ? parts.model : `${parts.provider}/${parts.model}`;
+  }
+  return null;
 }
 
 /**
  * Claude Code (CLI) surface alias — devlog 050 + audit 051 #2.
  *
- * The readable `claude-ocx-*` form when representable; otherwise the desktop-3p
+ * The readable `claude-ocx*` form when representable; otherwise the desktop-3p
  * hash so the model still appears in discovery (collisions follow the same
  * first-wins policy as the desktop registry — audit 051 #1). Real Anthropic
  * models pass through unchanged (they must keep hitting the sk-ant passthrough).

package/src/claude/inbound.ts

@@ -147,23 +147,40 @@ export function effectiveBlockedSkillNames(cc?: Pick<OcxClaudeCodeConfig, "block
  * FIRST directive wins; the scan is bounded to the system field.
  */
 const OCX_ROUTE_RE = /<!--\s*ocx-route:\s*([^\s]+)\s*-->/;
+const OCX_EFFORT_RE = /<!--\s*ocx-effort:\s*(low|medium|high|xhigh|max)\s*-->/;
 
-export function extractOcxRouteDirective(body: unknown): string | null {
+function systemText(body: unknown): string | null {
   if (!isRec(body)) return null;
   const system = body.system;
-  let text: string | undefined;
-  if (typeof system === "string") text = system;
-  else if (Array.isArray(system)) {
-    text = system
-      .filter((b): b is Rec => isRec(b) && b.type === "text" && typeof b.text === "string")
-      .map(b => b.text as string)
-      .join("\n");
-  }
+  if (typeof system === "string") return system || null;
+  if (!Array.isArray(system)) return null;
+  const text = system
+    .filter((b): b is Rec => isRec(b) && b.type === "text" && typeof b.text === "string")
+    .map(b => b.text as string)
+    .join("\n");
+  return text || null;
+}
+
+export function extractOcxRouteDirective(body: unknown): string | null {
+  const text = systemText(body);
   if (!text) return null;
   const match = OCX_ROUTE_RE.exec(text);
   return match ? match[1]! : null;
 }
 
+/**
+ * Claude Code 2.1.220 collapses custom-agent frontmatter `effort: max` and
+ * `effort: xhigh` into the legacy `thinking.budget_tokens` shape. Preserve the
+ * exact generated-agent setting through the same trusted system-body channel as
+ * ocx-route so the inbound translator can restore `output_config.effort`.
+ */
+export function extractOcxEffortDirective(body: unknown): NonNullable<OcxClaudeCodeConfig["subagentEffort"]> | null {
+  const text = systemText(body);
+  if (!text) return null;
+  const match = OCX_EFFORT_RE.exec(text);
+  return match ? match[1] as NonNullable<OcxClaudeCodeConfig["subagentEffort"]> : null;
+}
+
 /** Injected-skill payloads below this size are never stubbed (not worth it). */
 const SKILL_ELISION_MIN_CHARS = 10_000;
 const SKILL_TEXT_MARKER = "Base directory for this skill: ";

package/src/claude/outbound.ts

@@ -453,12 +453,15 @@ export function responsesSseToAnthropicSse(
                 if (line.startsWith("event: ")) eventName = line.slice(7).trim();
                 else if (line.startsWith("data: ")) dataLine += line.slice(6);
               }
-              if (!eventName || !dataLine) continue;
+              if (!dataLine) continue;
               let data: unknown;
               try { data = JSON.parse(dataLine); } catch { continue; }
               if (!isRec(data)) continue;
-              if (terminated) continue;
-              handleFrame(eventName, data);
+              // Responses-compatible gateways may omit the optional SSE event field
+              // while retaining the event name in the JSON payload's required type.
+              const resolvedEventName = eventName || (typeof data.type === "string" ? data.type : "");
+              if (!resolvedEventName || terminated) continue;
+              handleFrame(resolvedEventName, data);
             }
           }
           // EOF without a terminal frame is a TRUNCATION, not success (devlog 100:

package/src/cli/account-auth.ts

@@ -137,11 +137,11 @@ async function login(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   for (let attempt = 0; attempt < 100; attempt++) {
     await Bun.sleep(2_000);
     const state = await runtimeRequest<Record<string, unknown>>(`/api/oauth/status?provider=${encodeURIComponent(provider)}`, {}, deps);
+    if (state.error) throw new CliUsageError(String(state.error));
     if (state.loggedIn === true) {
       printData(state, wantsJson, [`Logged in to ${provider}.`]);
       return;
     }
-    if (state.error) throw new CliUsageError(String(state.error));
   }
   throw new CliUsageError("login timed out");
 }