@bitkyc08/opencodex 2.66.0 → 2.67.0-preview.20260926

package/src/server/management/agent-settings-routes.ts

@@ -1226,7 +1226,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
         const committed = persistCommittedDesktopGateway(config, state.profile, result.fingerprint);
         const modeWarning = committed.ok ? undefined : `Gateway applied, but its mode/profile state was not saved (${committed.reason}).`;
         // The durable marker describes the committed gateway even if old-mode cleanup fails.
-        const firstPartyRemoved = removeDesktopFirstParty();
+        const firstPartyRemoved = removeDesktopFirstParty(loadConfig());
         if (!firstPartyRemoved.ok) {
           return { response: jsonResponse({
             error: `Claude Code settings could not be parsed (${firstPartyRemoved.path}); first-party cleanup remains incomplete after gateway apply.`,
@@ -1235,10 +1235,10 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
             ...(modeWarning ? { warning: modeWarning } : {}),
           }, 500) };
         }
-        return { result, committed, modeWarning, pickerOff };
+        return { result, committed, modeWarning, pickerOff, firstPartyRemoved };
       });
       if (outcome.response) return outcome.response;
-      const { result, committed, modeWarning, pickerOff } = outcome as Exclude<typeof outcome, { response: Response }>;
+      const { result, committed, modeWarning, pickerOff, firstPartyRemoved } = outcome as Exclude<typeof outcome, { response: Response }>;
       const { claudeDesktopPolicyWarning, getCachedClaudeDesktopPolicy } = await import("../../claude/desktop-policy");
       const policyState = deps.probeClaudeDesktopPolicy
         ? await deps.probeClaudeDesktopPolicy({ platform: deps.platform ?? process.platform })
@@ -1247,7 +1247,9 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       const pickerWarning = pickerOff.residual?.length
         ? `Picker mode cleanup is incomplete (${pickerOff.residual.join(", ")}); run ocx claude desktop picker off.`
         : undefined;
-      const warning = [modeWarning, policyWarning, pickerWarning].filter(Boolean).join(" ");
+      const warning = [modeWarning, policyWarning, pickerWarning,
+        firstPartyRemoved.retainedFor === "cli"
+          ? "Shared first-party settings remain for Claude Code CLI." : undefined].filter(Boolean).join(" ");
       return jsonResponse({
         ok: true,
         mode: "gateway",
@@ -1447,8 +1449,21 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
     );
     const webSearchOverride = config.claudeCode?.webSearchSidecar;
     const visionOverride = config.claudeCode?.visionSidecar;
+    const { firstPartyDesired, readFirstPartyProxyStatus } = await import("../../claude/first-party-settings");
+    const { observeClaudeDesktopMode } = await import("../../claude/desktop-first-party");
+    const { claudeInterceptEnabled, getClaudeInterceptState } = await import("../../claude/intercept/runtime");
+    const desired = firstPartyDesired(config, observeClaudeDesktopMode(config));
+    const bound = (deps.getClaudeInterceptState ?? getClaudeInterceptState)();
+    const eligible = claudeInterceptEnabled(config);
+    const sharedProxy = readFirstPartyProxyStatus(config, bound?.proxyPort ?? null);
     return jsonResponse({
       enabled: config.claudeCode?.enabled !== false,
+      cliFirstParty: config.claudeCode?.cliFirstParty === true,
+      cliFirstPartyApplied: config.claudeCode?.cliFirstParty === true && sharedProxy === "live",
+      desktopFirstParty: desired.desktop,
+      interceptEligible: eligible,
+      interceptRunning: bound !== null && eligible,
+      sharedProxy,
       // Three-state intent (devlog 260726_claude_auth_auto): an absent key is AUTO, not
       // subscription. The old coercion made every save convert an untouched auto config
       // into a sticky manual subscription with no way back.
@@ -1505,7 +1520,110 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       return prototype === Object.prototype || prototype === null;
     };
     if (!isPlainObject(parsedBody)) return jsonResponse({ error: "body must be an object" }, 400);
-    const body = parsedBody as { enabled?: unknown; authMode?: unknown; model?: unknown; smallFastModel?: unknown; modelMap?: unknown; classifierModel?: unknown; classifierFallbacks?: unknown; systemEnv?: unknown; fastMode?: unknown; maxContextTokens?: unknown; alwaysEnableEffort?: unknown; tierModels?: unknown; autoContext?: unknown; autoCompactWindow?: unknown; blockedSkills?: unknown; injectAgents?: unknown; webSearchSidecar?: unknown; visionSidecar?: unknown };
+    const body = parsedBody as { enabled?: unknown; cliFirstParty?: unknown; authMode?: unknown; model?: unknown; smallFastModel?: unknown; modelMap?: unknown; classifierModel?: unknown; classifierFallbacks?: unknown; systemEnv?: unknown; fastMode?: unknown; maxContextTokens?: unknown; alwaysEnableEffort?: unknown; tierModels?: unknown; autoContext?: unknown; autoCompactWindow?: unknown; blockedSkills?: unknown; injectAgents?: unknown; webSearchSidecar?: unknown; visionSidecar?: unknown };
+    if (body.cliFirstParty !== undefined && typeof body.cliFirstParty !== "boolean")
+      return jsonResponse({ error: "cliFirstParty must be a boolean" }, 400);
+    if (body.cliFirstParty !== undefined && Object.keys(body).length !== 1)
+      return jsonResponse({ error: "cliFirstParty must be sent alone", code: "cli_first_party_not_alone" }, 400);
+    if (body.cliFirstParty !== undefined) {
+      const { claudeInterceptEnabled, claudeInterceptProxyPort, getClaudeInterceptState } = await import("../../claude/intercept/runtime");
+      const { captureDesktopFirstPartyRollback, inspectDesktopFirstParty, observeClaudeDesktopMode, resolveClaudeDesktopMode } = await import("../../claude/desktop-first-party");
+      const { firstPartyDesired, readFirstPartyProxyStatus, reconcileClaudeFirstPartySettings } = await import("../../claude/first-party-settings");
+      const { commitClaudeCodeBlock } = await import("../../claude/claude-code-block");
+      const bound = (deps.getClaudeInterceptState ?? getClaudeInterceptState)();
+      if (body.cliFirstParty) {
+        if (!claudeInterceptEnabled(config)) return jsonResponse({ error: "Claude intercept is disabled", code: "intercept_disabled" }, 409);
+        if (bound === null) return jsonResponse({ error: "Claude intercept is unavailable", code: "intercept_unavailable" }, 409);
+        const targetPort = claudeInterceptProxyPort(config, config.port ?? 10100);
+        if (targetPort !== bound.proxyPort) return jsonResponse({
+          error: `Claude intercept port mismatch (configured ${targetPort}, bound ${bound.proxyPort}); restart needed`,
+          code: "intercept_unavailable",
+        }, 409);
+        let inspection: ReturnType<typeof inspectDesktopFirstParty>["settings"];
+        try { inspection = inspectDesktopFirstParty(config).settings; }
+        catch { return jsonResponse({ error: "Claude settings are unreadable", code: "unreadable" }, 500); }
+        if (inspection.kind === "foreign") return jsonResponse({ error: "Claude settings env is foreign", code: "foreign_env" }, 409);
+        if (inspection.kind === "unreadable") return jsonResponse({ error: "Claude settings are unreadable", code: "unreadable" }, 500);
+      }
+      let restoreSettings: (() => boolean) | undefined;
+      try { if (body.cliFirstParty) restoreSettings = captureDesktopFirstPartyRollback(config); }
+      catch { return jsonResponse({ error: "Claude settings are unreadable", code: "unreadable" }, 500); }
+      type FirstPartyMutation =
+        | { refusal: { error: string; code: "intercept_disabled" | "intercept_unavailable" } }
+        | { claudeCode: OcxConfig["claudeCode"]; previous: { present: boolean; value: boolean }; pinnedMode: "first-party" | "gateway" | undefined };
+      let outcome: ReturnType<typeof mutatePersistedConfig<FirstPartyMutation>>;
+      try {
+        outcome = mutatePersistedConfig<FirstPartyMutation>(persisted => {
+        if (body.cliFirstParty) {
+          if (!claudeInterceptEnabled(persisted)) return { changed: false, value: {
+            refusal: { error: "Claude intercept is disabled", code: "intercept_disabled" as const } } };
+          const persistedPort = claudeInterceptProxyPort(persisted, persisted.port ?? 10100);
+          if (bound === null || persistedPort !== bound.proxyPort) return { changed: false, value: {
+            refusal: { error: `Claude intercept port mismatch (configured ${persistedPort}, bound ${bound?.proxyPort ?? "none"}); restart needed`,
+              code: "intercept_unavailable" as const } } };
+        }
+        const before = structuredClone(persisted);
+        const previous = { present: Object.hasOwn(persisted.claudeCode ?? {}, "cliFirstParty"),
+          value: persisted.claudeCode?.cliFirstParty === true };
+        const pinnedMode = body.cliFirstParty && persisted.claudeCode?.desktopMode === undefined
+          ? resolveClaudeDesktopMode(before, observeClaudeDesktopMode(before)) : undefined;
+        const nextBlock = { ...(persisted.claudeCode ?? {}) };
+        if (body.cliFirstParty) nextBlock.cliFirstParty = true;
+        else delete nextBlock.cliFirstParty;
+        if (pinnedMode) nextBlock.desktopMode = pinnedMode;
+        commitClaudeCodeBlock(persisted, nextBlock);
+        return { changed: true, value: { claudeCode: structuredClone(persisted.claudeCode), previous, pinnedMode } };
+        });
+      } catch { return jsonResponse({ error: "Could not save Claude settings", code: "write_failed" }, 500); }
+      if (outcome.status === "unavailable") return jsonResponse({ error: "Could not save Claude settings", code: "write_failed" }, 500);
+      const committed = outcome.value;
+      if ("refusal" in committed) return jsonResponse(committed.refusal, 409);
+      adoptPersistedClaudeCode(config, committed.claudeCode);
+      const live = { ...(config.claudeCode ?? {}) };
+      if (body.cliFirstParty) live.cliFirstParty = true; else delete live.cliFirstParty;
+      if (committed.pinnedMode) live.desktopMode = committed.pinnedMode;
+      config.claudeCode = live;
+      let result: ReturnType<typeof reconcileClaudeFirstPartySettings> | undefined;
+      try { result = (deps.reconcileClaudeFirstPartySettings ?? reconcileClaudeFirstPartySettings)(config,
+        firstPartyDesired(config, observeClaudeDesktopMode(config))); }
+      catch { /* An unexpected settings failure is mapped after conditional rollback. */ }
+      if (!result?.ok) {
+        let settingsRestored = true;
+        if (body.cliFirstParty) {
+          try { settingsRestored = restoreSettings?.() ?? false; } catch { settingsRestored = false; }
+          let rollback: ReturnType<typeof mutatePersistedConfig<OcxConfig["claudeCode"]>>;
+          try {
+            rollback = mutatePersistedConfig(persisted => {
+            const block = { ...(persisted.claudeCode ?? {}) };
+            if (block.cliFirstParty === true) {
+              if (committed.previous.present) block.cliFirstParty = committed.previous.value;
+              else delete block.cliFirstParty;
+            }
+            if (committed.pinnedMode && block.desktopMode === committed.pinnedMode)
+              delete block.desktopMode;
+            persisted.claudeCode = block;
+            return { changed: true, value: structuredClone(block) };
+            });
+          } catch { return jsonResponse({ error: "Claude settings rollback failed", code: "write_failed",
+            warnings: ["settings_rollback_incomplete"] }, 500); }
+          if (rollback.status === "unavailable") return jsonResponse({ error: "Claude settings rollback failed", code: "write_failed",
+            warnings: ["settings_rollback_incomplete"] }, 500);
+          adoptPersistedClaudeCode(config, rollback.value);
+        }
+        const code = result?.reason ?? "write_failed";
+        return jsonResponse({ error: "Claude first-party reconciliation failed", code,
+          ...(!body.cliFirstParty && code === "unreadable"
+            ? { cliFirstParty: false, warnings: ["settings_residual"] } : {}),
+          ...(body.cliFirstParty && !settingsRestored
+            ? { warnings: ["settings_rollback_incomplete"] } : {}) },
+          code === "intercept_disabled" || code === "foreign_env" ? 409 : 500);
+      }
+      const finalDesired = firstPartyDesired(config, observeClaudeDesktopMode(config));
+      const residual = !finalDesired.desktop && !finalDesired.cli
+        && readFirstPartyProxyStatus(config, bound?.proxyPort ?? null) !== "none";
+      return jsonResponse({ ok: true, enabled: config.claudeCode?.enabled !== false,
+        cliFirstParty: body.cliFirstParty, warnings: residual ? ["settings_residual"] : [] });
+    }
     for (const field of ["webSearchSidecar", "visionSidecar"] as const) {
       const section = body[field];
       if (section === undefined || section === null) continue;

package/src/server/management/context.ts

@@ -44,6 +44,10 @@ export interface ManagementRequestIngress {
 }
 
 export interface ManagementApiDeps {
+  /** Bound Claude intercept state, injectable for isolated management-route tests. */
+  getClaudeInterceptState?: typeof import("../../claude/intercept/runtime").getClaudeInterceptState;
+  /** Reconciliation seam for field-scoped rollback tests. */
+  reconcileClaudeFirstPartySettings?: typeof import("../../claude/first-party-settings").reconcileClaudeFirstPartySettings;
   /** Read-only process-local aggregate metrics; absent keeps the scrape route unavailable. */
   requestMetrics?: RequestMetricsSnapshotter;
   checkPackageUpdate?: (channel: Channel) => Promise<UpdateCheckResult>;

package/src/server/management/native-integration-routes.ts

@@ -21,7 +21,7 @@ import { commitClaudeCodeBlock } from "../../claude/claude-code-block";
  */
 import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { getConfigPath, loadConfig, mutatePersistedConfig, saveConfigPreservingClaudeCode } from "../../config";
+import { adoptPersistedClaudeCode, getConfigPath, loadConfig, mutatePersistedConfig, saveConfigPreservingClaudeCode } from "../../config";
 import { readRuntimePort } from "../../config/process-state";
 import { desktopVisibleNativeSlugs, filterCatalogVisibleModels, nativeContextLimits } from "../../codex/catalog";
 import { getCodexHome } from "../../codex/paths";
@@ -676,9 +676,16 @@ function pickerCleanupNote(picker: DesktopPickerStatus): string {
 }
 
 /** Record which Desktop mode is applied; `false` when the config file could not be updated. */
-function persistDesktopModeMarker(desktopMode: ClaudeDesktopMode): boolean {
-  const outcome = mutatePersistedConfig(persisted => recordClaudeDesktopMode(persisted, desktopMode));
-  return outcome.status !== "unavailable";
+function persistDesktopModeMarker(config: ManagementContext["config"], desktopMode: ClaudeDesktopMode): boolean {
+  const outcome = mutatePersistedConfig(persisted => {
+    const result = recordClaudeDesktopMode(persisted, desktopMode);
+    return { changed: result.changed, value: structuredClone(persisted.claudeCode) };
+  });
+  if (outcome.status === "unavailable") return false;
+  adoptPersistedClaudeCode(config, outcome.value);
+  // Pin the committed leaf: an unarmed baseline can otherwise retain a stale live mode.
+  recordClaudeDesktopMode(config, desktopMode);
+  return true;
 }
 
 let claudeDesktopToggleFlight: Promise<Response> | null = null;
@@ -705,13 +712,15 @@ async function handleClaudeDesktopToggle(ctx: ManagementContext): Promise<Respon
     }
     const desiredEnabled = loadConfig().clientIntegrations?.["claude-desktop"] !== false;
     const current = loadConfig();
+    // Publish committed Desktop intent to the live config used by intercept routing.
+    ctx.config.clientIntegrations = structuredClone(current.clientIntegrations);
     const fingerprint = current.claudeCode?.desktopProfile?.appliedFingerprint ?? null;
 
     if (!body.enabled) {
       // Picker mode goes first: stop terminating claude.ai, drop its profile and trust.
       return await runPickerTransition(current, async ops => {
         const pickerOff = await ops.disableLocked({ persist: false });
-        const firstPartyRemoved = removeDesktopFirstParty();
+        const firstPartyRemoved = removeDesktopFirstParty(loadConfig());
         if (!firstPartyRemoved.ok) {
           return postCommitRefusal(409, "claude-desktop", "write_failed",
             `Claude Code settings could not be read (${firstPartyRemoved.path}); the first-party proxy env was left in place.`, { desiredEnabled });
@@ -731,6 +740,7 @@ async function handleClaudeDesktopToggle(ctx: ManagementContext): Promise<Respon
           ok: true, clientId: "claude-desktop", changed, state: "absent", desiredEnabled,
           message: [
             changed ? "Claude Desktop integration disabled." : "Claude Desktop integration is already off.",
+            firstPartyRemoved.retainedFor === "cli" ? "Shared first-party settings remain for Claude Code CLI." : "",
             pickerCleanupNote(pickerOff),
           ].filter(Boolean).join(" "),
         } satisfies NativeToggleEnvelope);
@@ -755,7 +765,7 @@ async function handleClaudeDesktopToggle(ctx: ManagementContext): Promise<Respon
             return postCommitRefusal(500, "claude-desktop", "write_failed",
               "Gateway cleanup and first-party settings rollback did not complete.", { desiredEnabled });
           }
-          const partialModeWarning = !removed.ok && removed.changed && !persistDesktopModeMarker("first-party")
+          const partialModeWarning = !removed.ok && removed.changed && !persistDesktopModeMarker(ctx.config, "first-party")
             ? " First-party is active but its mode marker was not saved." : "";
           if (removed.kind === "cleanup_incomplete") {
             return postCommitRefusal(500, "claude-desktop", "cleanup_incomplete",
@@ -768,7 +778,7 @@ async function handleClaudeDesktopToggle(ctx: ManagementContext): Promise<Respon
           }
           gatewayRemoved = removed.changed;
         }
-        const modeSaved = persistDesktopModeMarker("first-party");
+        const modeSaved = persistDesktopModeMarker(ctx.config, "first-party");
         const changed = applied.changed || gatewayRemoved;
         // Picker mode is on by default in first-party; only a committed mode turns it on.
         const picker = modeSaved && pickerPreferenceOn(loadConfig())
@@ -816,13 +826,14 @@ async function handleClaudeDesktopToggle(ctx: ManagementContext): Promise<Respon
         if (!result.written) return postCommitRefusal(500, "claude-desktop", "write_failed", "Claude Desktop apply failed.", { desiredEnabled: latestDesiredEnabled });
         const committed = persistCommittedDesktopGateway(ctx.config, latest.claudeCode?.desktopProfile, result.fingerprint);
         const stateWarning = committed.ok ? "" : " The committed gateway mode/profile state was not saved.";
-        const removed = removeDesktopFirstParty();
+        const removed = removeDesktopFirstParty(loadConfig());
         if (!removed.ok) return postCommitRefusal(500, "claude-desktop", "write_failed", "Gateway applied, but first-party settings cleanup did not complete." + stateWarning, { desiredEnabled: latestDesiredEnabled });
         return jsonResponse({
           ok: true, clientId: "claude-desktop", changed: true, state: "current", desiredEnabled: latestDesiredEnabled,
           message: [
             "Claude Desktop integration enabled.",
             stateWarning,
+            removed.retainedFor === "cli" ? "Shared first-party settings remain for Claude Code CLI." : "",
             pickerCleanupNote(pickerOff),
           ].filter(Boolean).join(" "),
         } satisfies NativeToggleEnvelope);

package/src/server/responses/core-normalize.ts

@@ -12,7 +12,7 @@ import { subagentFallbackNeedsModelEntitlements } from "../../codex/subagent-mod
 import { MAIN_CODEX_ACCOUNT_ID } from "../../codex/main-account";
 import type { RequestLogContext } from "../request-log";
 import type { HandleResponsesOptions } from "./core-options";
-import { prepareEffortNormalization } from "../effort-policy";
+import { prepareEffortNormalization, stripEmptyLadderEffort, supportedLadderFor } from "../effort-policy";
 import { resolveOpenCodeGoTransport } from "../../providers/opencode-go-transport";
 import { getOrAllocateRequestSessionLane } from "../request-log-conversation";
 import { shouldPreparePlaintextV2AgentMessages } from "../../responses/plaintext-v2-agent-messages";
@@ -307,6 +307,18 @@ export async function applyFinalRouteRequestNormalization(args: {
       logCtx.requestedEffort = `${logCtx.requestedEffort ?? "max"}->${clamped}`;
     }
   }
+  // Chat ingress cannot strip effort against a provisional policy pick. Apply the
+  // concrete target's restriction to BOTH adapter options and the raw wire copy;
+  // policy-fallback retains the original body before this attempt-local mutation.
+  if (inboundWire === "chat" && supportedLadderFor(route)?.length === 0) {
+    parsed.options.reasoning = undefined;
+    const raw = parsed._rawBody as { reasoning?: unknown } | undefined;
+    if (raw) {
+      const reasoning = stripEmptyLadderEffort(raw.reasoning, []);
+      if (reasoning === undefined) delete raw.reasoning;
+      else raw.reasoning = reasoning;
+    }
+  }
   recordAttemptRequestedEffort(logCtx);
   logCtx.modelSupportsServiceTier = SERVICE_TIER_ADAPTERS.has(route.provider.adapter)
     ? modelServiceTierSupport

package/src/server/responses/request-prepare.ts

@@ -229,7 +229,10 @@ export async function prepareResponsesRequest(
   // here instead, before comboIdFromRawBody reads `model`, and identify the combo by CONFIG
   // LOOKUP so the check can never observe a one-candidate collapse.
   let shadowCallIntercepted = false;
-  if (!options.comboAttempt && !options.compactionRoutingOverride && body && typeof body === "object" && !Array.isArray(body)) {
+  // A spawned sub-agent turn names its model on purpose; gpt-6-luna is both the helper
+  // slug and a default sub-agent model, so neither intercept site may rewrite that turn.
+  const threadSpawn = isThreadSpawnRequest(req.headers);
+  if (!options.comboAttempt && !options.compactionRoutingOverride && !threadSpawn && body && typeof body === "object" && !Array.isArray(body)) {
     const shadowIntercept = config.shadowCallIntercept;
     const rawShadowModel = (body as { model?: unknown }).model;
     if (shadowIntercept?.enabled && shadowIntercept.model && typeof rawShadowModel === "string"
@@ -483,7 +486,7 @@ export async function prepareResponsesRequest(
         : routeModel(config, modelId, evidenceFromBody(parsed._rawBody)));
     const _sci = config.shadowCallIntercept;
     let shadowRoute: RouteResult | undefined;
-    if (!options.compactionRoutingOverride && _sci?.enabled && _sci.model && isShadowSourceModel(parsed.modelId, _sci.sourceModels)) {
+    if (!options.compactionRoutingOverride && !threadSpawn && _sci?.enabled && _sci.model && isShadowSourceModel(parsed.modelId, _sci.sourceModels)) {
       const sourcePrefix = shadowSourceModelPrefix(parsed.modelId, _sci.sourceModels)!;
       let sourceIdentity = { providerName: OPENAI_CODEX_PROVIDER_ID, modelId: sourcePrefix };
       try {
@@ -549,7 +552,6 @@ export async function prepareResponsesRequest(
   // Exact account selectors are isolated from Pool-wide quota work. A canonical replay miss must
   // also fail closed without polling quota upstream. Cached fallback state can still select a
   // provider with native continuation support below.
-  const threadSpawn = isThreadSpawnRequest(req.headers);
   const initialSubagentFallbackChain = threadSpawn && !options.comboAttempt
     ? resolveSubagentFallbackChain(parsed, config)
     : null;

package/src/server/responses/sidecar-execution.ts

@@ -160,7 +160,12 @@ export async function executeResponsesSidecars(
     retryAfter: string | null,
     responseHeaders?: Headers,
     retryParsed?: OcxParsedRequest,
-  ): Promise<ProviderAdapter | null> => {
+  ): Promise<{ adapter: ProviderAdapter; recoveryKind: AttemptRecoveryKind } | null> => {
+    // Which credential axis actually moved. The main routed path already reports these three
+    // separately (`adapter-dispatch`: key-429 / anthropic-oauth-429 / oauth-account-429); the
+    // sidecar loops used to flatten all three to `key-429`, so an account rotation read as a key
+    // rotation in the attempt row and in the Logs UI.
+    let recoveryKind: AttemptRecoveryKind = "key-429";
     const rotated = rotateProviderTransportOn429(config, route.providerName, route.provider, {
       retryAfter,
       now: Date.now(),
@@ -209,6 +214,7 @@ export async function executeResponsesSidecars(
         hop.permit?.release();
         return null;
       }
+      recoveryKind = "oauth-account-429";
       hop.permit?.use();
     } else if (
       // Anthropic's pool is excluded from generic failover, so without this arm a 429 inside a
@@ -252,6 +258,7 @@ export async function executeResponsesSidecars(
         hop.permit?.release();
         return null;
       }
+      recoveryKind = "anthropic-oauth-429";
       hop.permit?.use();
     } else {
       // No key pool, no generic OAuth roster, no Anthropic pool could produce a replacement
@@ -281,7 +288,7 @@ export async function executeResponsesSidecars(
       provider: route.provider,
       adapterName: rotatedAdapter.name,
     });
-    return rotatedAdapter;
+    return { adapter: rotatedAdapter, recoveryKind };
   };
   if ((imgPlan || vidPlan) && wsPlan) {
     // Web search takes priority when both are active — the media bridge cannot run

package/src/server/search.ts

@@ -38,8 +38,8 @@ import {
   resolveFirstUsableOpenAiSidecar,
   type ExactOpenAiSidecarAccount,
 } from "../providers/openai-sidecar";
-import { routeModel } from "../router";
-import { handleAlphaSearchSidecarFallback } from "../web-search/alpha-search";
+import { previewRouteModel, routeModel } from "../router";
+import { handleAlphaSearchSidecarFallback, handleDevinAlphaSearch } from "../web-search/alpha-search";
 import { readJsonRequestBody, resolveInboundBodyLimitBytes } from "./request-decompress";
 import { ForwardAdmissionCredentialError, validateForwardAdmissionCredential } from "./auth-cors";
 import type { RequestLogContext } from "./request-log";
@@ -65,11 +65,6 @@ export async function handleSearch(
   turnAdmissionLease?: AdmissionLease,
   admission?: DataPlaneAdmission,
 ): Promise<Response> {
-  try { validateForwardAdmissionCredential(req.headers, config); }
-  catch (err) {
-    if (err instanceof ForwardAdmissionCredentialError) return formatErrorResponse(401, "authentication_error", err.message);
-    throw err;
-  }
   let body: unknown;
   try {
     body = await readJsonRequestBody(req, undefined, resolveInboundBodyLimitBytes(config.maxInboundBodyBytes));
@@ -79,6 +74,32 @@ export async function handleSearch(
   const model = (body as { model?: unknown } | null)?.model;
   if (typeof model === "string" && model) logCtx.model = model;
 
+  if (typeof model === "string" && model.trim()) {
+    try {
+      const route = previewRouteModel(config, model);
+      if (route.providerName === "devin" || route.staticPolicy.model.adapter === "devin") {
+        const denial = admissionScopeDenial(config, admission, model, route);
+        if (denial) return denial;
+        logCtx.provider = route.providerName;
+        logCtx.routeDecision = route.routeDecision;
+        return handleDevinAlphaSearch(
+          body,
+          "devin",
+          config.search?.timeoutMs ?? SEARCH_UPSTREAM_TIMEOUT_MS,
+          req.signal,
+        );
+      }
+    } catch {
+      // Preview is advisory: existing relay/fallback still owns unsupported or unroutable models.
+    }
+  }
+
+  try { validateForwardAdmissionCredential(req.headers, config); }
+  catch (err) {
+    if (err instanceof ForwardAdmissionCredentialError) return formatErrorResponse(401, "authentication_error", err.message);
+    throw err;
+  }
+
   let exactAccount: ExactOpenAiSidecarAccount | undefined;
   let relayBody = body;
   const accountNamespace = typeof model === "string"

package/src/storage/policy-job.ts

@@ -6,6 +6,7 @@
  * proxy event loop stays responsive.
  */
 import type { CleanupMode, CleanupResult } from "./cleanup";
+import { spawnWorker } from "../lib/worker-embed";
 import { resolveCodexHomeDir } from "../codex/home";
 import {
   tryBeginStorageMutation,
@@ -310,7 +311,7 @@ function runInWorker(opts: RequestPolicyRunOptions & { blockMs?: number }): Prom
     let settled = false;
     let worker: Worker;
     try {
-      worker = new Worker(new URL("./policy-worker.ts", import.meta.url).href);
+      worker = spawnWorker(new URL("./policy-worker.ts", import.meta.url).href, "policy-worker");
       reservation.bind(worker);
     } catch (error) {
       reservation.release();

package/src/storage/restore-job.ts

@@ -9,6 +9,7 @@
  * `storage_mutation_busy` (409) instead of queueing.
  */
 import { resolveCodexHomeDir } from "../codex/home";
+import { spawnWorker } from "../lib/worker-embed";
 import { restoreTrashEntry, type RestoreResult, type RestoreTestHooks } from "./cleanup";
 import {
   resetStorageMutationCoordinatorForTests,
@@ -167,7 +168,7 @@ function runInWorker(opts: {
     let settled = false;
     let worker: Worker;
     try {
-      worker = new Worker(new URL("./restore-worker.ts", import.meta.url).href);
+      worker = spawnWorker(new URL("./restore-worker.ts", import.meta.url).href, "restore-worker");
       reservation.bind(worker);
     } catch (error) {
       reservation.release();

package/src/types/config.ts

@@ -37,6 +37,9 @@ export interface OcxProtocolsConfig {
  * /v1/messages surface, the `ocx claude` launcher, and the GUI Claude page.
  */
 export interface OcxClaudeCodeConfig {
+  /** Route the standalone Claude Code CLI through the first-party intercept (settings.json env).
+   * Independent of Desktop's first-party mode. Absent/false = off. */
+  cliFirstParty?: boolean;
   /**
    * Opt-in relocation of supported trailing Claude harness notices from system instructions
    * to a user input message on translated routes. Changes the Desktop cache-key prefix.
@@ -737,19 +740,22 @@ export interface OcxConfig {
   /**
   * Shadow call intercept: redirect Codex's hard-coded helper calls (title generation,
   * commit messages, skill orchestration) to a user-chosen model. Default intercepted
-  * source model: gpt-5.6-luna (Codex 0.145.0+). Clients through 0.144.x emitted
-  * gpt-5.4-mini instead; that model is retired upstream, but it stays available as an
-  * opt-in `sourceModels` prefix so an old client's helper calls can still be intercepted.
+  * source models: gpt-6-luna (Codex 0.154.0+) and gpt-5.6-luna (0.145.0-0.153.x).
+  * Clients through 0.144.x emitted gpt-5.4-mini instead; that model is retired upstream,
+  * but it stays available as an opt-in `sourceModels` prefix so an old client's helper
+  * calls can still be intercepted.
   * Opt-in; disabled by default. Matching requests preserve their configured reasoning effort.
   * All requests for configured shadow source models are intercepted regardless of request kind,
-  * except when the replacement intersects the same provider+model source set.
+  * except when the replacement intersects the same provider+model source set, and except
+  * spawned sub-agent turns (x-openai-subagent: collab_spawn / subagent_kind thread_spawn),
+  * which keep the model they were spawned with.
   */
  shadowCallIntercept?: {
    /** When true, requests for known shadow/helper source models are rewritten to the configured model. */
    enabled?: boolean;
    /** Replacement model id (e.g. "gpt-5.5"). */
    model?: string;
-   /** Optional override of intercepted source-model prefixes (default: gpt-5.6-luna). */
+   /** Optional override of intercepted source-model prefixes (default: gpt-6-luna, gpt-5.6-luna). */
    sourceModels?: string[];
  };
   /**

package/src/update/transactional-install.mjs

@@ -189,8 +189,12 @@ function createOwnedStage(scopeDir, pkgName, deps = {}) {
       pid: process.pid,
       createdAt: (deps.now ?? Date.now)(),
     }), { flag: "wx" });
+    // npm's strict script policy plans the global tree before it creates the prefix layout, so
+    // `-g --prefix` into a bare stage fails with ENOENT on <stage>/lib (#5760). POSIX global
+    // prefixes keep packages under lib/; Windows installs into the prefix itself.
+    if (process.platform !== "win32") mkdir(join(stageRoot, "lib"));
   } catch (error) {
-    // Still empty and created by this call: remove it rather than leave an unmarked stage.
+    // Created by this call and not yet handed to npm: remove it rather than leave a partial stage.
     try { rmSync(stageRoot, { recursive: true, force: true }); } catch { /* reported by the caller */ }
     throw error;
   }

package/src/web-search/alpha-search.ts

@@ -12,12 +12,14 @@
  * and pulling it in recreates the cycle sidecar-providers.ts exists to avoid.
  */
 import { formatErrorResponse } from "../bridge";
+import { signalWithTimeout } from "../lib/abort";
 import { redactSecretString } from "../lib/redact";
 import { sidecarEnter } from "../lib/sidecar-tracker";
 import { admissionScopeDenial } from "../server/admission-model-scope";
 import type { DataPlaneAdmission } from "../server/auth-cors";
 import type { OcxConfig, OcxProviderConfig, OcxWebSearchSidecarConfig } from "../types";
 import { runAnthropicWebSearch } from "./anthropic-executor";
+import { resolveDevinWebSearchSnapshot, runDevinWebSearch } from "./devin-executor";
 import { runExaWebSearch } from "./exa-executor";
 import type { SidecarOutcome, SidecarSettings } from "./executor";
 import { runGeminiWebSearch } from "./gemini-executor";
@@ -203,6 +205,75 @@ async function runAlphaSearchQuery(
   }
 }
 
+function raceAbort<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      value => { signal.removeEventListener("abort", onAbort); resolve(value); },
+      error => { signal.removeEventListener("abort", onAbort); reject(error); },
+    );
+  });
+}
+
+export async function handleDevinAlphaSearch(
+  body: unknown,
+  providerName: string,
+  timeoutMs: number,
+  signal?: AbortSignal,
+): Promise<Response> {
+  const queries = extractAlphaSearchQueries(body);
+  if (queries.length === 0) {
+    return formatErrorResponse(
+      400,
+      "invalid_request_error",
+      "Built-in web search request is missing a usable query (commands.search_query, query, q, or search_query).",
+    );
+  }
+  const deadline = signalWithTimeout(timeoutMs, signal);
+  try {
+    const resolved = await raceAbort(resolveDevinWebSearchSnapshot(providerName), deadline.signal);
+    if ("error" in resolved) {
+      return formatErrorResponse(502, "upstream_error", `devin web search failed: ${redactSecretString(resolved.error)}`);
+    }
+    const texts: string[] = [];
+    const sources: SidecarOutcome["sources"] = [];
+    for (const query of queries) {
+      const outcome = await runDevinWebSearch(query, resolved.snapshot, deadline.signal);
+      if (outcome.error) {
+        if (signal?.aborted) {
+          return formatErrorResponse(499, "client_closed_request", "search request canceled by client");
+        }
+        if (deadline.signal.aborted) {
+          return formatErrorResponse(504, "upstream_error", "devin web search timed out");
+        }
+        const detail = redactSecretString(outcome.error);
+        return formatErrorResponse(502, "upstream_error", `devin web search failed: ${detail}`);
+      }
+      texts.push(queries.length > 1 ? `Results for "${query}":\n${outcome.text}` : outcome.text);
+      for (const source of outcome.sources) {
+        if (!sources.some(existing => existing.url === source.url)) sources.push(source);
+      }
+    }
+    return new Response(JSON.stringify(formatAlphaSearchBody(texts.join("\n\n"), sources)), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+  } catch (error) {
+    if (signal?.aborted) {
+      return formatErrorResponse(499, "client_closed_request", "search request canceled by client");
+    }
+    if (deadline.signal.aborted) {
+      return formatErrorResponse(504, "upstream_error", "devin web search timed out");
+    }
+    const detail = redactSecretString(error instanceof Error ? error.message : String(error));
+    return formatErrorResponse(502, "upstream_error", `devin web search failed: ${detail}`);
+  } finally {
+    deadline.cleanup();
+  }
+}
+
 function formatAlphaSearchBody(text: string, sources: SidecarOutcome["sources"]): {
   encrypted_output: null;
   output: string;