@bitkyc08/opencodex 2.75.0 → 2.76.0

package/src/cli/chatgpt-command.ts

@@ -0,0 +1,140 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig } from "../config";
+import {
+  chatgptShimLauncherPath,
+  resolveChatgptCodexBinary,
+  writeChatgptShimLauncher,
+} from "../chatgpt/app-server-shim/launcher";
+import { untrustedChatgptBundleReason } from "../chatgpt/app-server-shim/bundle-trust";
+import { darwinDefaultExec, darwinDesktopAppAdapter } from "../codex/desktop-app/darwin";
+import type { DesktopAppInstall } from "../codex/desktop-app/types";
+
+const USAGE = `Usage (experimental, macOS only):
+  ocx chatgpt launch   Relaunch ChatGPT with the experimental app-server shim (requires appServerShim: true)
+  ocx chatgpt restore  Relaunch ChatGPT without the experimental shim and remove its launcher
+  ocx chatgpt status   Inspect experimental flag, launcher and running app environment`;
+
+function run(command: string, args: string[]) {
+  const result = spawnSync(command, args, { encoding: "utf8", timeout: 5000 });
+  return { ok: result.status === 0, output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim() };
+}
+
+/**
+ * The installed app, found and confirmed by bundle identifier (com.openai.codex) the same way the
+ * desktop restart adapter does. "ChatGPT" is a display name another app can share, so quitting,
+ * relaunching and the binary path all key on this verified bundle rather than on the name.
+ */
+function discoverApp(): DesktopAppInstall | null {
+  try {
+    return darwinDesktopAppAdapter.discover(darwinDefaultExec);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Only inspect the verified bundle's own process; never print the environment being inspected.
+ * `-a` keeps ancestors in the match: when ocx runs inside a ChatGPT/Codex session the app is
+ * one of this process's ancestors, and plain `pgrep -x` would report it as not running.
+ */
+function appState(install: DesktopAppInstall, launcher: string): { running: boolean; shim: boolean } {
+  const shell = join(install.root, "Contents", "MacOS", "ChatGPT");
+  // Only this user's processes: another account's ChatGPT can neither be quit nor relaunched here.
+  const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+  const pids = run("pgrep", [...(uid === undefined ? [] : ["-U", String(uid)]), "-a", "-x", "ChatGPT"]);
+  if (!pids.ok) return { running: false, shim: false };
+  for (const pid of pids.output.split(/\s+/).filter(value => /^\d+$/.test(value))) {
+    const command = run("ps", ["eww", "-o", "command=", "-p", pid]);
+    if (command.ok && (command.output === shell || command.output.startsWith(`${shell} `))) {
+      const marker = `CODEX_CLI_PATH=${launcher}`;
+      const start = command.output.indexOf(marker);
+      return { running: true, shim: start >= 0 && (start === 0 || command.output[start - 1] === " ")
+        && (start + marker.length === command.output.length || command.output[start + marker.length] === " ") };
+    }
+  }
+  return { running: false, shim: false };
+}
+
+/** Adapted from #5947: open ignores new launch settings until the previous app exits. */
+async function quitApp(install: DesktopAppInstall, launcher: string): Promise<boolean> {
+  if (!appState(install, launcher).running) return true;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    run("/usr/bin/osascript", ["-e", `quit app id "${install.id}"`]);
+    for (let poll = 0; poll < 20; poll++) {
+      if (!appState(install, launcher).running) return true;
+      await Bun.sleep(250);
+    }
+  }
+  return !appState(install, launcher).running;
+}
+
+export async function handleChatgptCommand(args: string[], platform: NodeJS.Platform = process.platform): Promise<number> {
+  const sub = args[0];
+  if (!sub || ["help", "--help", "-h"].includes(sub)) {
+    console.log(USAGE);
+    return sub ? 0 : 64;
+  }
+  if (!["launch", "restore", "status"].includes(sub) || args.length !== 1) {
+    console.error(USAGE);
+    return 64;
+  }
+  if (platform !== "darwin") {
+    console.error("ChatGPT app-server shim (experimental): macOS only.");
+    return 1;
+  }
+  try {
+    const config = loadConfig();
+    const launcher = chatgptShimLauncherPath();
+    const install = discoverApp();
+    if (sub === "status") {
+      const app = install ? appState(install, launcher) : { running: false, shim: false };
+      console.log(`app-server shim (experimental): ${config.chatgptDesktop?.appServerShim === true ? "on" : "off"}
+launcher: ${existsSync(launcher) ? "present" : "absent"}
+app: ${install ? (app.running ? "running" : "not running") : "not installed"}
+CODEX_CLI_PATH launcher: ${app.shim ? "yes" : "no"}`);
+      return 0;
+    }
+    if (!install) {
+      if (sub === "restore") rmSync(launcher, { force: true });
+      console.error("ChatGPT (com.openai.codex) was not found; install or open it once, then retry.");
+      return 1;
+    }
+    if (sub === "launch") {
+      if (config.chatgptDesktop?.appServerShim !== true) {
+        console.error('Experimental shim disabled; set chatgptDesktop.appServerShim: true before launching.');
+        return 1;
+      }
+      const binary = resolveChatgptCodexBinary(install.root);
+      if (!binary) {
+        console.error(`No bundled app-server binary was found in ${install.root}; the shim cannot launch this build.`);
+        return 1;
+      }
+      const untrusted = untrustedChatgptBundleReason(install.root, binary);
+      if (untrusted) {
+        console.error(`Refusing to launch the shim: ${untrusted}.`);
+        return 1;
+      }
+      writeChatgptShimLauncher(undefined, binary);
+    }
+    if (!(await quitApp(install, launcher))) {
+      console.error("ChatGPT did not quit; quit it manually and retry.");
+      return 1;
+    }
+    // Remove an inherited override too: restore must launch without CODEX_CLI_PATH.
+    const env = { ...process.env };
+    delete env.CODEX_CLI_PATH;
+    // Open the verified bundle by path, so the relaunch is the same app that was quit.
+    const result = spawnSync("/usr/bin/open", ["-a", install.root, ...(sub === "launch" ? ["--env", `CODEX_CLI_PATH=${launcher}`] : [])], {
+      encoding: "utf8", env, timeout: 10000,
+    });
+    if (result.status !== 0) throw new Error(result.error?.message ?? (result.stderr?.trim() || "open failed"));
+    if (sub === "restore") rmSync(launcher, { force: true });
+    console.log(`ChatGPT relaunched ${sub === "launch" ? "with" : "without"} the experimental app-server shim.`);
+    return 0;
+  } catch (error) {
+    console.error(`ChatGPT shim (experimental): ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+}

package/src/cli/combo.ts

@@ -1,3 +1,4 @@
+import { JEV_DECISION_TIMEOUT_MAX_MS, JEV_DECISION_TIMEOUT_MIN_MS } from "../combos/types";
 import {
   CliUsageError,
   printData,
@@ -5,7 +6,6 @@ import {
   runCliAction,
   runtimeRequest,
   takeFlag,
-  takeIntegerOption,
   takeOption,
   type RuntimeApiDeps,
 } from "./runtime-api";
@@ -13,15 +13,21 @@ import {
 const USAGE = `Usage:
   ocx combo [list] [--json]
   ocx combo show <id> [--json]
-  ocx combo set <id> --targets <provider/model[:weight],...>
-      [--strategy <failover|round-robin|random|least-used|reset-window|jev>] [--sticky <1-100>]
-      [--effort <low|medium|high|xhigh|max|ultra|->] [--effort-mode <fallback|force>]
+  ocx combo set <id> [--targets <provider/model[:weight],...>]
+      [--strategy <failover|round-robin|random|least-used|reset-window|jev>] [--sticky <1-100|->]
+      [--effort <low|medium|high|xhigh|max|ultra|->] [--effort-mode <fallback|force|->]
       (force overrides valid client effort and can increase cost/latency) [--alias <name|->]
       [--native-alias] [--display-name <label|->]
+      [--decision-provider <provider|-> | --decision-model <route|->] [--decision-timeout <ms|->]
+      (jev only; the provider must be a configured jev-decision row)
       [--rename-from <id>] [--json]
-  ocx combo remove <id> --yes [--json]`;
+  ocx combo remove <id> --yes [--json]
+  ocx combo test [--combo <id>] [--decision-provider <provider|jev> | --decision-model <route>]
+      [--decision-timeout <ms>] [--json]
+      (one synthetic decision probe through the decision method; may spend a decision call)
+  ocx combo discover [--query <text>] [--json]`;
 
-type ComboRow = Record<string, unknown> & { id?: string; model?: string };
+type ComboRow = Record<string, unknown> & { id?: string; model?: string; strategy?: string };
 
 function parseTargets(value: string): Array<{ provider: string; model: string; weight?: number }> {
   const targets = value.split(",").map(part => part.trim()).filter(Boolean).map(part => {
@@ -72,35 +78,87 @@ async function set(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const wantsJson = takeFlag(args, "--json");
   if (!id) throw new CliUsageError("combo id is required", USAGE);
   const targetsRaw = takeOption(args, "--targets");
-  if (!targetsRaw) throw new CliUsageError("--targets is required", USAGE);
-  const strategy = takeOption(args, "--strategy") ?? "failover";
+  const renameFrom = takeOption(args, "--rename-from");
+  const partialCurrent = targetsRaw === undefined
+    ? await runtimeRequest<{ combos?: ComboRow[] }>("/api/combos", {}, deps)
+    : undefined;
+  const partialExisting = partialCurrent?.combos?.find(row => row.id === (renameFrom ?? id));
+  if (targetsRaw === undefined && !partialExisting) {
+    throw new CliUsageError("--targets is required when creating a combo", USAGE);
+  }
+  const strategyRaw = takeOption(args, "--strategy");
+  const strategy = strategyRaw ?? partialExisting?.strategy ?? "failover";
   if (strategy !== "failover" && strategy !== "round-robin" && strategy !== "random" && strategy !== "least-used" && strategy !== "reset-window" && strategy !== "jev") throw new CliUsageError("--strategy must be failover, round-robin, random, least-used, reset-window, or jev", USAGE);
-  const stickyLimit = takeIntegerOption(args, "--sticky", { min: 1 });
+  const stickyRaw = takeOption(args, "--sticky");
+  const stickyLimit = stickyRaw === undefined ? undefined : stickyRaw === "-" ? 1 : Number(stickyRaw);
+  if (stickyLimit !== undefined && (!Number.isInteger(stickyLimit) || stickyLimit < 1)) {
+    throw new CliUsageError("--sticky must be an integer from 1 to 100, or -", USAGE);
+  }
   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 effortMode = takeOption(args, "--effort-mode");
-  if (effortMode !== undefined && effortMode !== "fallback" && effortMode !== "force") {
-    throw new CliUsageError("--effort-mode must be fallback or force", USAGE);
+  if (effortMode !== undefined && effortMode !== "fallback" && effortMode !== "force" && effortMode !== "-") {
+    throw new CliUsageError("--effort-mode must be fallback, force, or -", USAGE);
   }
   const alias = takeOption(args, "--alias");
   const nativeAlias = takeFlag(args, "--native-alias");
   const displayName = takeOption(args, "--display-name");
-  const renameFrom = takeOption(args, "--rename-from");
+  const decisionProvider = takeOption(args, "--decision-provider");
+  const decisionModel = takeOption(args, "--decision-model");
+  if (decisionModel !== undefined && decisionModel !== "-" && decisionProvider !== undefined && decisionProvider !== "-") {
+    throw new CliUsageError("--decision-model cannot be combined with --decision-provider", USAGE);
+  }
+  if (decisionModel !== undefined && decisionModel !== "-" && strategy !== "jev") {
+    throw new CliUsageError("--decision-model applies only to the jev strategy", USAGE);
+  }
+  if (decisionProvider !== undefined && decisionProvider !== "-" && strategy !== "jev") {
+    throw new CliUsageError("--decision-provider applies only to the jev strategy", USAGE);
+  }
+  const decisionTimeout = takeOption(args, "--decision-timeout");
+  let decisionTimeoutMs: number | null | undefined;
+  if (decisionTimeout !== undefined) {
+    decisionTimeoutMs = decisionTimeout === "-" ? null : Number(decisionTimeout);
+    if (decisionTimeoutMs !== null
+      && (!Number.isInteger(decisionTimeoutMs)
+        || decisionTimeoutMs < JEV_DECISION_TIMEOUT_MIN_MS
+        || decisionTimeoutMs > JEV_DECISION_TIMEOUT_MAX_MS)) {
+      throw new CliUsageError(
+        `--decision-timeout must be an integer from ${JEV_DECISION_TIMEOUT_MIN_MS} to ${JEV_DECISION_TIMEOUT_MAX_MS}, or -`,
+        USAGE,
+      );
+    }
+    if (decisionTimeoutMs !== null && strategy !== "jev") {
+      throw new CliUsageError("--decision-timeout applies only to the jev strategy", USAGE);
+    }
+  }
   rejectArgs(args, USAGE);
-  const combo: Record<string, unknown> = {
-    strategy,
-    stickyLimit: stickyLimit ?? 1,
-    targets: parseTargets(targetsRaw),
-  };
+  // Listing-only nulls must not be resent as explicit clears (alias rejects null).
+  const combo: Record<string, unknown> = partialExisting
+    ? Object.fromEntries(Object.entries(partialExisting).filter(([, value]) => value !== null))
+    : { strategy, stickyLimit: stickyLimit ?? 1, targets: parseTargets(targetsRaw!) };
+  delete combo.id;
+  delete combo.model;
+  if (strategyRaw !== undefined) combo.strategy = strategy;
+  if (stickyLimit !== undefined) combo.stickyLimit = stickyLimit;
   if (effort !== undefined) combo.defaultEffort = effort === "-" ? null : effort;
-  if (effortMode !== undefined) combo.defaultEffortMode = effortMode;
+  if (effortMode !== undefined) combo.defaultEffortMode = effortMode === "-" ? "fallback" : effortMode;
   if (alias !== undefined) combo.alias = alias === "-" ? "" : alias;
   if (nativeAlias) combo.nativeAlias = true;
   if (displayName !== undefined) combo.displayName = displayName === "-" ? "" : displayName;
-  const current = await runtimeRequest<{ combos?: ComboRow[] }>("/api/combos", {}, deps);
+  if (decisionProvider !== undefined) combo.decisionProvider = decisionProvider === "-" ? null : decisionProvider;
+  if (decisionModel !== undefined) combo.decisionModel = decisionModel === "-" ? null : decisionModel;
+  if (decisionProvider !== undefined && decisionProvider !== "-") combo.decisionModel = null;
+  if (decisionModel !== undefined && decisionModel !== "-") combo.decisionProvider = null;
+  if (decisionTimeoutMs !== undefined) combo.decisionTimeoutMs = decisionTimeoutMs;
+  if (strategy !== "jev") {
+    delete combo.decisionProvider;
+    delete combo.decisionModel;
+    delete combo.decisionTimeoutMs;
+  }
+  const current = partialCurrent ?? await runtimeRequest<{ combos?: ComboRow[] }>("/api/combos", {}, deps);
   const existing = (current.combos ?? []).find(row => row.id === (renameFrom ?? id));
   if (existing?.imageInput === "disabled") combo.imageInput = "disabled";
   if (effortMode === undefined && existing?.defaultEffortMode === "force") {
@@ -125,6 +183,71 @@ async function remove(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   printData(result, wantsJson, [`Removed combo ${id}.`]);
 }
 
+async function testDecision(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const comboId = takeOption(args, "--combo")?.trim();
+  let decisionProvider = takeOption(args, "--decision-provider")?.trim();
+  let decisionModel = takeOption(args, "--decision-model")?.trim();
+  const timeoutRaw = takeOption(args, "--decision-timeout");
+  rejectArgs(args, USAGE);
+  if (decisionProvider && decisionModel) {
+    throw new CliUsageError("use either --decision-provider or --decision-model", USAGE);
+  }
+  let decisionTimeoutMs: number | undefined = timeoutRaw === undefined ? undefined : Number(timeoutRaw);
+  if (decisionTimeoutMs !== undefined && (!Number.isInteger(decisionTimeoutMs)
+    || decisionTimeoutMs < JEV_DECISION_TIMEOUT_MIN_MS || decisionTimeoutMs > JEV_DECISION_TIMEOUT_MAX_MS)) {
+    throw new CliUsageError(
+      `--decision-timeout must be an integer from ${JEV_DECISION_TIMEOUT_MIN_MS} to ${JEV_DECISION_TIMEOUT_MAX_MS}`,
+      USAGE,
+    );
+  }
+  if (comboId && !decisionProvider && !decisionModel) {
+    // Without an override, probe the decision method the combo has saved.
+    const current = await runtimeRequest<{ combos?: ComboRow[] }>("/api/combos", {}, deps);
+    const row = (current.combos ?? []).find(item => item.id === comboId);
+    if (!row) throw new CliUsageError(`unknown combo ${comboId}`, USAGE);
+    if (row.strategy !== "jev") throw new CliUsageError(`combo ${comboId} does not use the jev strategy`, USAGE);
+    if (typeof row.decisionModel === "string") decisionModel = row.decisionModel;
+    else if (typeof row.decisionProvider === "string") decisionProvider = row.decisionProvider;
+    if (decisionTimeoutMs === undefined && typeof row.decisionTimeoutMs === "number") decisionTimeoutMs = row.decisionTimeoutMs;
+  }
+  const result = await runtimeRequest<Record<string, unknown>>("/api/combos/decision-test", {
+    method: "POST",
+    body: JSON.stringify({
+      ...(comboId ? { comboId } : {}),
+      ...(decisionProvider ? { decisionProvider } : {}),
+      ...(decisionModel ? { decisionModel } : {}),
+      ...(decisionTimeoutMs !== undefined ? { decisionTimeoutMs } : {}),
+    }),
+  }, deps);
+  const outcome = result.ok === true ? "Decision probe applied" : "Decision probe failed open";
+  printData(result, wantsJson, [
+    `${outcome} (${String(result.backend)}, gate ${String(result.gate)}, ${String(result.latencyMs)} ms).`,
+  ]);
+}
+
+async function discover(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const query = takeOption(args, "--query")?.trim();
+  rejectArgs(args, USAGE);
+  const path = query ? `/api/combos/decision-discovery?q=${encodeURIComponent(query)}` : "/api/combos/decision-discovery";
+  const result = await runtimeRequest<{
+    configured?: Array<{ id: string; url: string; model?: string; usable: boolean; issue?: string }>;
+    discovered?: Array<{ provider: string; model: string; endpoint: string }>;
+  }>(path, {}, deps);
+  const lines = [
+    ...(result.configured ?? []).map(row => {
+      const model = row.model ? ` (${row.model})` : "";
+      const issue = row.usable ? "" : ` [${row.issue ?? "unusable"}]`;
+      return `row ${row.id}: ${row.url}${model}${issue}`;
+    }),
+    ...(result.discovered ?? []).map(row => `catalog ${row.provider}/${row.model}: ${row.endpoint}`),
+  ];
+  printData(result, wantsJson, lines.length ? lines : ["No decision services found."]);
+}
+
 export async function handleComboCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
   return runCliAction(async () => {
     const [sub = "list", ...rest] = argv;
@@ -132,6 +255,8 @@ export async function handleComboCommand(argv: string[], deps: RuntimeApiDeps =
     else if (sub === "show") await show(rest, deps);
     else if (sub === "set" || sub === "create" || sub === "update") await set(rest, deps);
     else if (sub === "remove" || sub === "delete") await remove(rest, deps);
+    else if (sub === "test") await testDecision(rest, deps);
+    else if (sub === "discover") await discover(rest, deps);
     else throw new CliUsageError(`unknown combo command ${sub}`, USAGE);
   });
 }

package/src/cli/config-command.ts

@@ -159,14 +159,16 @@ function setPath(root: Record<string, unknown>, path: string, value: unknown, re
   else current[leaf] = value;
 }
 
+/** Interpret config-set input as JSON when valid, otherwise preserve it as a string. */
 function parseValue(raw: string): unknown {
   try { return JSON.parse(raw); }
   catch { return raw; }
 }
 
+/** Accept one UTF-8 BOM from Windows JSON files or piped input. */
 function loadInput(path: string): unknown {
   const raw = path === "-" ? readFileSync(0, "utf8") : readFileSync(path, "utf8");
-  try { return JSON.parse(raw); }
+  try { return JSON.parse(raw.replace(/^\uFEFF/, "")); }
   catch { throw new CliUsageError(`invalid JSON in ${path}`); }
 }
 

package/src/cli/dispatch.ts

@@ -351,7 +351,8 @@ const commandRunners: Record<string, CommandRunner> = {
       console.error(clientState.kind === "connected"
         ? "Client mode does not start a local provider proxy; use 'ocx sync'."
         : `Client state is ${clientState.kind}: ${clientState.reason}`);
-      return 1;
+      // A validated client delegates inference to its hub; no local startup is needed.
+      return clientState.kind === "connected" ? 0 : 1;
     }
     await deps.handleEnsure();
     return Number(process.exitCode ?? 0);
@@ -947,6 +948,10 @@ const commandRunners: Record<string, CommandRunner> = {
     const { handleLabCommand } = await import("./lab");
     return await handleLabCommand(deps.args.slice(1));
   },
+  chatgpt: async deps => {
+    const { handleChatgptCommand } = await import("./chatgpt-command");
+    return await handleChatgptCommand(deps.args.slice(1));
+  },
   claude: async deps => {
     const { cmdClaude } = await import("./claude");
     // "ocx claude desktop" → write Desktop 3P config
@@ -956,6 +961,10 @@ const commandRunners: Record<string, CommandRunner> = {
       if (exitCode !== 0) return exitCode;
       return 0;
     }
+    if (deps.args[1] === "intercept") {
+      const { handleClaudeInterceptCommand } = await import("./integrations");
+      return await handleClaudeInterceptCommand(deps.args.slice(2));
+    }
     if (deps.args[1] === "config") {
       const { handleClaudeConfigCommand } = await import("./integrations");
       return await handleClaudeConfigCommand(deps.args.slice(2));

package/src/cli/help.ts

@@ -90,6 +90,7 @@ Usage:
   ocx config <sub>            Validated configuration show/get/set/import/export
   ocx companion <show|set|reset>  Menu-bar and widget companion usage settings
   ocx lab <sub>               Read-only Compatibility Lab projection inspection
+  ocx chatgpt <sub>          Experimental app-server shim: launch|restore|status (macOS)
   ocx claude [args...]        Launch Claude Code wired to the proxy (model discovery on)
   ocx claude desktop [sub]    Manage and apply Claude Desktop's four-family profile
   ocx opencode [args...]      Launch opencode wired to the proxy (runtime provider config)

package/src/cli/index.ts

@@ -127,7 +127,6 @@ import { assertNotAdminToken, diagnoseService, isServiceOwnershipError, proxySti
 import { acquireOwnershipMutationLease } from "../service/ownership-mutation-lease.mjs";
 import { formatStartupRoutingDetail, startupHealthSummary } from "../codex/autostart-health";
 import { injectSystemEnv, reconcileShellHook, revertSystemEnv, uninstallShellHook } from "../server/system-env";
-import { buildDesktop3pRegistry } from "../claude/desktop-3p";
 import { startTokenGuardian } from "../oauth/token-guardian";
 import { startHistoryMigrationGuardian } from "../codex/history-migration-guardian";
 import { maybeShowStarPrompt } from "./star-prompt";
@@ -711,27 +710,9 @@ async function handleStart(options: { block?: boolean } = {}) {
       ? Promise.resolve(null)
       : syncClaudeAgentDefsAtProxyStartup(config, port),
     async () => {
-      try {
-        const { fetchAllModels } = await import("../server/management-api");
-        const { desktopVisibleNativeSlugs } = await import("../codex/catalog");
-        const { resolveAdmittedCodexModelEntitlements } = await import("../codex/model-entitlement-admission");
-        const { buildDesktopDiscoveryInputs } = await import("../claude/desktop-discovery-inputs");
-        const [models, modelEntitlements] = await Promise.all([
-          fetchAllModels(config),
-          resolveAdmittedCodexModelEntitlements(config, { clientVersion: null }),
-        ]);
-        const inputs = buildDesktopDiscoveryInputs({
-          config, models, modelEntitlements,
-          desktopNativeCandidates: desktopVisibleNativeSlugs(config),
-        });
-        buildDesktop3pRegistry(
-          inputs.nativeSlugs, inputs.routedModels,
-          config.claudeCode?.desktopProfile, inputs.nativeContextCap,
-        );
-      } catch {
-        // Best-effort; model discovery can rebuild it. Never reflect credential or provider errors.
-        console.warn("[opencodex] Claude Desktop model registry could not be initialized at startup.");
-      }
+      // Shared with the Claude Code CLI picker, which awaits this same build (desktop-3p-startup.ts).
+      const { initDesktop3pRegistry } = await import("../claude/desktop-3p-startup");
+      await initDesktop3pRegistry(config);
     },
   );
   if (!startupSync.ran) console.log(startupLeftCodexNativeLine(localClientSkipReason(config), server.port ?? port));
@@ -1212,7 +1193,7 @@ async function handleStopUnlocked(snapshot?: GuardedStopSnapshot) {
 
   if (snapshot) {
     if (guardedStep?.effect === "approval-changed") {
-      return approvalChanged();
+      return approvalChanged(guardedStep.detail);
     }
     if (guardedStep?.effect === "manager-still-active") {
       return managerStillActive(record.service, record);
@@ -1705,7 +1686,7 @@ async function handleStatus() {
     process.exit(1);
   }
 
-  const status = await collectStatus();
+  const status = await collectStatus({ mainAccountPolicy: wantsJson });
   if (wantsJson) {
     console.log(JSON.stringify(status.json, null, 2));
     return;

package/src/cli/init.ts

@@ -11,6 +11,14 @@ import { deriveInitProviders } from "../providers/derive";
 import { pinSponsorsWithinKind } from "../providers/sponsor-order";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 
+/** Parse a setup TCP port; only an empty answer selects the default. */
+export function parseInitPort(raw: string): number | null {
+  const text = raw.trim();
+  if (!text) return 10100;
+  const value = /^\d+$/.test(text) ? Number(text) : NaN;
+  return Number.isInteger(value) && value >= 1 && value <= 65535 ? value : null;
+}
+
 class InitCancelledError extends Error {
   constructor(readonly exitCode: 1 | 130) {
     super(exitCode === 130 ? "Setup cancelled." : "stdin reached EOF while waiting for input. Re-run `ocx init` in an interactive terminal.");
@@ -111,6 +119,7 @@ export function cleanupOpenAiTierBackupAfterInit(configPath = getConfigPath()):
   } catch { /* cleanup is best-effort; never block init on backup housekeeping */ }
 }
 
+/** Create a first configuration interactively, preserving existing files and refusing invalid input. */
 export async function runInit(): Promise<void> {
   const initial = observeInitialConfigState();
   if (initial === "exists") {
@@ -194,8 +203,13 @@ export async function runInit(): Promise<void> {
       };
     }
 
-    const portStr = await prompt.ask("\nProxy port [10100]: ");
-    const port = parseInt(portStr, 10) || 10100;
+    // A mistyped port re-asks instead of discarding every earlier answer; EOF and SIGINT
+    // still reject the pending question with InitCancelledError.
+    let port: number | null;
+    do {
+      port = parseInitPort(await prompt.ask("\nProxy port [10100]: "));
+      if (port === null) console.error("Proxy port must be a whole decimal number from 1 to 65535. Please try again.");
+    } while (port === null);
 
     initializeProviderModelSelection(providerName, providerConfig);
     const config: OcxConfig = {

package/src/cli/integrations.ts

@@ -368,3 +368,16 @@ export async function handleZcodeCommand(argv: string[], deps: RuntimeApiDeps =
   }
   return code;
 }
+
+export async function handleClaudeInterceptCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
+  return runCliAction(async () => {
+    const args = [...argv];
+    const action = args.shift();
+    const wantsJson = takeFlag(args, "--json");
+    const usage = "Usage: ocx claude intercept start [--json]";
+    rejectArgs(args, usage);
+    if (action !== "start") throw new CliUsageError("Expected start", usage);
+    const result = await runtimeRequest("/api/claude-intercept/start", { method: "POST" }, deps);
+    printData(result, wantsJson, summaryLines(result));
+  });
+}

package/src/cli/internal-command.ts

@@ -3,21 +3,20 @@
  *
  * Deliberately NOT in `src/cli/registry.ts` and NOT in `src/cli/capabilities.ts`, so it
  * is absent from help, from the generated skill surface, and from the registry-parity
- * gate. It is not a user-facing capability and must not become one: it exists so the
- * detached restart helper is the same audited binary running the same audited ladder,
- * rather than a second implementation in a shell script.
+ * gate. These are implementation entrypoints for the detached restart helper and
+ * experimental ChatGPT stdout filter; compiled builds re-enter the same CLI binary.
  *
  * It is routed before the dispatch table for the same reason `help` is - adding it as a
  * runner key would make it a command the registry-parity test expects to find
  * documented.
  *
- * It is intentionally unauthenticated, and that is not an oversight. Any process running
+ * The restart handoff is intentionally unauthenticated, and that is not an oversight. Any process running
  * as this user can invoke it with a hand-written plan file, and it gains nothing by
  * doing so: the helper only does what the public `--restart-codex` flag already does for
  * that same user, and a same-uid process could call `kill` directly. A token here would
  * protect nothing and would imply a boundary that does not exist.
  */
-const USAGE = "Usage: ocx internal desktop-restart-handoff --plan <path>";
+const USAGE = "Usage: ocx internal desktop-restart-handoff --plan <path> | chatgpt-app-server-filter [--self-test]";
 
 function optionValue(args: readonly string[], name: string): string | undefined {
   const index = args.indexOf(name);
@@ -26,6 +25,14 @@ function optionValue(args: readonly string[], name: string): string | undefined
 
 export async function handleInternalCommand(args: readonly string[]): Promise<number> {
   const sub = args[0];
+  if (sub === "chatgpt-app-server-filter") {
+    if (args.length > 2 || (args[1] !== undefined && args[1] !== "--self-test")) {
+      console.error(USAGE);
+      return 2;
+    }
+    const { runChatgptAppServerFilter } = await import("../chatgpt/app-server-shim/filter");
+    return await runChatgptAppServerFilter({ selfTest: args[1] === "--self-test" });
+  }
   if (sub !== "desktop-restart-handoff") {
     console.error(`Unknown internal command: ${sub ?? "(none)"}. ${USAGE}`);
     return 2;

package/src/cli/observe.ts

@@ -52,6 +52,7 @@ function logRows(data: unknown): LogEntry[] {
   return [];
 }
 
+/** Render one human log row with an exact, control-free request ID suitable for history lookup. */
 function formatLog(row: LogEntry): string {
   const time = String(row.timestamp ?? row.createdAt ?? "");
   const route = [row.provider, row.model].filter(Boolean).join("/");
@@ -69,9 +70,13 @@ function formatLog(row: LogEntry): string {
   const account = typeof row.accountLogLabel === "string" && row.accountLogLabel.length > 0
     ? `acct=${row.accountLogLabel}`
     : "";
-  return [time, String(status), route, duration, account, conversation].filter(Boolean).join("  ");
+  const requestId = typeof row.requestId === "string" && row.requestId.length > 0
+    && !/[\x00-\x1f\x7f-\x9f\u2028\u2029]/.test(row.requestId)
+    ? `id=${row.requestId}` : "";
+  return [time, String(status), route, duration, account, conversation, requestId].filter(Boolean).join("  ");
 }
 
+/** Read or follow request logs while preserving raw JSON and JSONL output. */
 async function logs(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const args = [...argv];
   const wantsJson = takeFlag(args, "--json");

package/src/cli/registry.ts

@@ -8,6 +8,12 @@ export interface CliCommandEntry {
 }
 
 export const CLI_COMMANDS: CliCommandEntry[] = [
+  {
+    name: "chatgpt",
+    usage: "ocx chatgpt <launch|restore|status>",
+    summary: "Experimental ChatGPT app-server shim (macOS only, default off).",
+    details: ["Experimental launch requires chatgptDesktop.appServerShim: true; restore removes its launcher."],
+  },
   {
     name: "init",
     aliases: ["setup"],

package/src/cli/route-policy.ts

@@ -1,5 +1,6 @@
 import {
   CliUsageError,
+  RuntimeApiError,
   printData,
   rejectArgs,
   runCliAction,
@@ -38,6 +39,7 @@ async function list(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   );
 }
 
+/** Show an existing routing profile, distinguishing malformed usage from a missing record. */
 async function show(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const args = [...argv];
   const id = args.shift();
@@ -46,7 +48,7 @@ async function show(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   rejectArgs(args, USAGE);
   const result = await runtimeRequest<{ profiles?: ProfileRow[] }>("/api/routing-profiles", {}, deps);
   const profile = (result.profiles ?? []).find(candidate => candidate.id === id);
-  if (!profile) throw new CliUsageError(`unknown routing profile: ${id}`, USAGE);
+  if (!profile) throw new RuntimeApiError(`unknown routing profile: ${id}`, 404, null);
   printData(profile, wantsJson);
 }