@bitkyc08/opencodex 2.84.0 → 2.86.0

package/src/claude/model-default-settings.ts

@@ -0,0 +1,154 @@
+import { createHash, randomUUID } from "node:crypto";
+import { linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteFileNoFollow } from "../config/atomic-write";
+import { hardenSecretDir, hardenSecretPath } from "../lib/windows-secret-acl";
+import { assertNotRealClaudeConfigUnderTest } from "../lib/test-home-guard";
+import { claudeConfigDir } from "./auth-detect";
+import { claudeTierDisplayName, type ClaudeTierModels } from "./context-windows";
+
+const tiers = ["opus", "sonnet", "haiku", "fable"] as const;
+
+function readSettings(path: string): { raw: string; exists: boolean; doc: Record<string, unknown>; env: Record<string, unknown> } {
+  let raw = "";
+  let exists = false;
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024) throw new Error("settings_unreadable");
+    raw = readFileSync(path, "utf8");
+    exists = true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw new Error("settings_unreadable");
+  }
+  let doc: Record<string, unknown>;
+  try {
+    const parsed: unknown = exists ? JSON.parse(raw) : {};
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+    doc = parsed as Record<string, unknown>;
+    if (doc.env !== undefined && (!doc.env || typeof doc.env !== "object" || Array.isArray(doc.env))) throw new Error();
+  } catch { throw new Error("settings_unreadable"); }
+  return { raw, exists, doc, env: (doc.env ?? {}) as Record<string, unknown> };
+}
+
+function snapshotFingerprint(current: ReturnType<typeof readSettings>, models: ClaudeTierModels | undefined) {
+  const target = selectedEnv(models, current.env);
+  return createHash("sha256").update(JSON.stringify([current.exists, current.raw, target])).digest("hex");
+}
+
+/** Test seams for edits at publication boundaries; never configured through the API. */
+export interface ModelDefaultWriteHooks {
+  beforeCapture?: () => void;
+  beforePublish?: () => void;
+}
+
+export class ModelDefaultsRecoveryError extends Error {
+  constructor(readonly backupPath: string, options?: ErrorOptions) {
+    super("settings_recovery_required", options);
+  }
+}
+
+/** Unset tiers stay untouched; only a label matching its current alias is managed. */
+function selectedEnv(models: ClaudeTierModels | undefined, current: Record<string, unknown>): Record<string, string | null> {
+  const env: Record<string, string | null> = {};
+  for (const tier of tiers) {
+    const slot = `ANTHROPIC_DEFAULT_${tier.toUpperCase()}_MODEL`;
+    const name = `${slot}_NAME`;
+    const value = models?.[tier]?.trim();
+    if (!value) continue;
+    env[slot] = value;
+    const previous = typeof current[slot] === "string" ? claudeTierDisplayName(current[slot]) : undefined;
+    const managed = previous !== undefined && current[name] === previous;
+    // Custom (including empty/non-string) labels are user-owned. Exact pairing
+    // follows the launcher label convention; the name alone proves no ownership.
+    if (!Object.hasOwn(current, name) || managed) {
+      const label = claudeTierDisplayName(value);
+      if (label !== undefined) env[name] = label;
+      else if (managed) env[name] = null;
+    }
+  }
+  return env;
+}
+
+export function previewClaudeModelDefaults(models: ClaudeTierModels | undefined, configDir = claudeConfigDir()) {
+  const path = join(configDir, "settings.json");
+  const current = readSettings(path);
+  const target = selectedEnv(models, current.env);
+  const changes = Object.entries(target).filter(([key, value]) => current.env[key] !== value)
+    // The existing preview wire shape uses an empty replacement for label removal.
+    .map(([key, value]) => ({ key, before: typeof current.env[key] === "string" ? current.env[key] as string : null, after: value ?? "" }));
+  const fingerprint = snapshotFingerprint(current, models);
+  return { path, fingerprint, changes };
+}
+
+export function applyClaudeModelDefaults(
+  models: ClaudeTierModels | undefined,
+  fingerprint: string,
+  configDir = claudeConfigDir(),
+  backupDir = join(configDir, "model-default-backups"),
+  hooks: ModelDefaultWriteHooks = {},
+) {
+  const preview = previewClaudeModelDefaults(models, configDir);
+  if (preview.fingerprint !== fingerprint) throw new Error("settings_changed");
+  if (!preview.changes.length) return { changed: false, path: preview.path };
+  assertNotRealClaudeConfigUnderTest(configDir, preview.path);
+  const current = readSettings(preview.path);
+  const check = snapshotFingerprint(current, models);
+  if (check !== fingerprint) throw new Error("settings_changed");
+  mkdirSync(configDir, { recursive: true });
+  mkdirSync(backupDir, { recursive: true, mode: 0o700 });
+  const recoveryDir = mkdtempSync(join(backupDir, "apply-"));
+  if (process.platform === "win32") hardenSecretDir(recoveryDir, { required: true });
+  const backupPath = join(recoveryDir, "settings.json");
+  const staged = join(configDir, `.model-defaults-${randomUUID()}.tmp`);
+  let captured = false;
+  let published = false;
+  try {
+    const env = { ...current.env };
+    for (const [key, value] of Object.entries(selectedEnv(models, current.env))) {
+      if (value === null) delete env[key];
+      else env[key] = value;
+    }
+    current.doc.env = env;
+    atomicWriteFileNoFollow(staged, `${JSON.stringify(current.doc, null, 2)}\n`);
+    // Verify same-volume exclusive publication before moving the shared file.
+    const probe = join(recoveryDir, "link-probe");
+    linkSync(staged, probe);
+    unlinkSync(probe);
+    hooks.beforeCapture?.();
+    if (current.exists) {
+      // Move the actual destination, not a stale in-memory copy. A same-filesystem
+      // move captures late edits; cross-device failures leave the original alone.
+      try { renameSync(preview.path, backupPath); } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") throw new Error("settings_changed");
+        throw error;
+      }
+      captured = true;
+      const capturedEntry = lstatSync(backupPath);
+      if (!capturedEntry.isFile() || capturedEntry.isSymbolicLink()) throw new Error("settings_changed");
+      if (process.platform === "win32") hardenSecretPath(backupPath, { required: true });
+      if (snapshotFingerprint(readSettings(backupPath), models) !== fingerprint) throw new Error("settings_changed");
+    }
+    hooks.beforePublish?.();
+    // A hard-link publish is exclusive on POSIX and Windows: never replace a
+    // document created by another writer during the brief move-aside interval.
+    try { linkSync(staged, preview.path); } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new Error("settings_changed");
+      throw error;
+    }
+    published = true;
+    return { changed: true, path: preview.path, ...(captured ? { backupPath } : {}) };
+  } catch (error) {
+    if (captured && !published) {
+      try { linkSync(backupPath, preview.path); } catch (restoreError) {
+        // A newer destination wins. Retain the captured document privately;
+        // never delete the winner or overwrite it as an automatic rollback.
+        throw new ModelDefaultsRecoveryError(backupPath, { cause: restoreError });
+      }
+    }
+    throw error;
+  } finally {
+    // The private stage is also present at the destination after successful
+    // linking; cleanup failure must not turn a committed apply into failure.
+    try { unlinkSync(staged); } catch { /* private residue, no shared-file cleanup */ }
+  }
+}

package/src/claude/model-info.ts

@@ -103,19 +103,19 @@ function modelInfo(id: string, displayName: string, ladder: readonly string[], i
 
 /**
  * Which id family the discovery list carries (devlog 050): Claude Code (CLI)
- * gets readable `claude-ocx-*` ids; Claude Desktop keeps the hashed
- * `claude-opus-4-8-<code>` family its 3P config was written with. Both families
+ * gets readable `ocx-claude-*` ids; Claude Desktop keeps its profile's
+ * `claude-fable-5-p<code>` ids (legacy no-profile callers use hash aliases). Both families
  * decode in resolveInboundModel regardless of the style served here.
  */
 export type AnthropicIdStyle = "desktop3p" | "readable";
 
-/** Build the full anthropic-flavor discovery list (ids are Desktop 3P aliases). */
+/** Build discovery rows; a Desktop resolver can return undefined to withhold an unbound ID. */
 export function buildAnthropicModelInfos(
   nativeSlugs: readonly string[],
   routedModels: readonly CatalogModel[],
   auto: AutoContextMode = AUTO_CONTEXT_OFF,
   idStyle: AnthropicIdStyle = "desktop3p",
-  aliasForRoute: (provider: string, modelId: string) => string = desktop3pAlias,
+  aliasForRoute: (provider: string, modelId: string) => string | undefined = desktop3pAlias,
   nativeContextCap?: NativeContextLimitsInput,
   fastMode?: boolean,
   // Presence is the feature gate: the caller passes undefined when `fastRows` is off, so a
@@ -144,7 +144,7 @@ export function buildAnthropicModelInfos(
         ? claudeCodeAlias(m.provider, listed)
         : aliasForRoute(m.provider, m.id);
     }),
-  ]);
+  ].filter((id): id is string => typeof id === "string" && id.length > 0));
   // [1m] picker variant (devlog 260712 B1; widened in devlog/_plan/261009_claude_1m_default/020):
   // Claude Code accounts exactly 1M for ids carrying the marker (2.1.207 binary: /\[1m\]/i -> 1e6,
   // compaction preserved). A discovery client may lack CLAUDE_CODE_AUTO_COMPACT_WINDOW, so the
@@ -201,7 +201,7 @@ export function buildAnthropicModelInfos(
   };
   for (const slug of nativeSlugs) {
     const id = idStyle === "readable" ? claudeCodeNativeAlias(slug) : aliasForRoute("native", slug);
-    if (seen.has(id)) continue;
+    if (!id || seen.has(id)) continue;
     seen.add(id);
     const nativeWindow = nativeOpenAiContextWindow(slug, nativeContextCap);
     const nativeMaxInput = nativeOpenAiMaxInputTokens(slug, nativeContextCap);
@@ -228,7 +228,7 @@ export function buildAnthropicModelInfos(
     const id = idStyle === "readable"
       ? claudeCodeAlias(m.provider, listedModelId)
       : aliasForRoute(m.provider, m.id);
-    if (seen.has(id)) continue;
+    if (!id || seen.has(id)) continue;
     seen.add(id);
     const groupStart = out.length;
     const ladder = Array.isArray(m.reasoningEfforts) ? m.reasoningEfforts : [];

package/src/claude/outbound.ts

@@ -11,7 +11,7 @@
  *  - errors: {type:"error", error:{type,message}}; may arrive mid-stream after HTTP 200.
  */
 import { createHash } from "node:crypto";
-import { httpStatusFromTerminalError } from "../lib/errors";
+import { httpStatusFromTerminalError, UNDECLARED_TOOL_CALL_ERROR_CODE } from "../lib/errors";
 import { isTransientUpstreamStatus } from "../lib/upstream-retry";
 import {
   isTranslatorBudgetExceededError,
@@ -81,12 +81,16 @@ export function anthropicErrorType(status: number): string {
  * (devlog/_plan/261009_claude_1m_default/010).
  */
 const CLAUDE_PROMPT_TOO_LONG_RE = /prompt is too long|input is too long for requested model/i;
-const STATED_CONTEXT_COUNTS_RE = /maximum context length is (\d+) tokens[\s\S]*?(?:resulted in|you requested) (\d+) tokens/i;
+const MAX_OVERFLOW_MESSAGE_CHARS = 64 * 1024;
+const STATED_CONTEXT_LIMIT_RE = /maximum context length is (\d+) tokens/i;
+const STATED_REQUEST_COUNT_RE = /(?:resulted in|you requested) (\d+) tokens/i;
 
 export function claudePromptTooLongMessage(message: string): string {
+  message = message.slice(0, MAX_OVERFLOW_MESSAGE_CHARS);
   if (CLAUDE_PROMPT_TOO_LONG_RE.test(message)) return message;
-  const counts = STATED_CONTEXT_COUNTS_RE.exec(message);
-  if (counts) return `prompt is too long: ${counts[2]} tokens > ${counts[1]} maximum`;
+  const limit = STATED_CONTEXT_LIMIT_RE.exec(message);
+  const requested = limit && STATED_REQUEST_COUNT_RE.exec(message.slice(limit.index + limit[0].length));
+  if (limit && requested) return `prompt is too long: ${requested[1]} tokens > ${limit[1]} maximum`;
   return `prompt is too long: ${message}`;
 }
 
@@ -804,11 +808,14 @@ export function responsesSseToAnthropicSse(
             // Unclassified status-absent response.failed (relaySseWithFailedTail synthetic
             // tail) still lands on a transient 5xx here — the mid-stream reset shape maps to
             // overloaded_error by design.
+            // The undeclared-tool refusal is deterministic and proxy-owned, not an upstream
+            // condition: keep its api_error type and code instead of a retryable overload.
+            const deterministic = code === UNDECLARED_TOOL_CALL_ERROR_CODE;
             fail(
               status,
               message,
-              true,
-              code === "context_length_exceeded" ? code : undefined,
+              !deterministic,
+              deterministic || code === "context_length_exceeded" ? code : undefined,
             );
             break;
           }

package/src/cli/advisor.ts

@@ -0,0 +1,151 @@
+import { ADVISOR_CONTEXT_SHARING_CONSENT_VERSION, ADVISOR_CONTEXT_SHARING_DISCLOSURE } from "../advisor/disclosure";
+import { CliUsageError, printData, rejectArgs, runCliAction, runtimeRequest, takeFlag, type RuntimeApiDeps } from "./runtime-api";
+
+const USAGE = `Usage:
+  ocx advisor status [--json]
+  ocx advisor on [--ack-context-sharing] [--json]
+  ocx advisor off [--json]
+  ocx advisor consent [--revoke] [--json]
+  ocx advisor set [--model <model>] [--effort <effort>] [--policy <manual|preflight>] [--timeout-ms <ms>] [--json]`;
+
+const VALUED_FLAGS = new Set(["--model", "--effort", "--policy", "--timeout-ms"]);
+
+interface SetOptions {
+  model?: string;
+  effort?: string;
+  policy?: string;
+  timeoutMs?: string;
+}
+
+function parseSetArgs(args: string[]): SetOptions {
+  const options: SetOptions = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]!;
+    if (!VALUED_FLAGS.has(arg)) throw new CliUsageError(`unknown advisor set option ${arg}`, USAGE);
+    const value = args[++index];
+    if (value === undefined || value.startsWith("--")) throw new CliUsageError(`${arg} requires a value`, USAGE);
+    // An explicitly supplied empty value is meaningful for --model alone: the settings route
+    // treats "" as the supported "clear the model" state. Every other valued flag still needs one.
+    if (value === "" && arg !== "--model") throw new CliUsageError(`${arg} requires a value`, USAGE);
+    if (arg === "--model") options.model = value;
+    else if (arg === "--effort") options.effort = value;
+    else if (arg === "--policy") options.policy = value;
+    else options.timeoutMs = value;
+  }
+  if (Object.keys(options).length === 0) {
+    throw new CliUsageError("advisor set requires at least one of --model, --effort, --policy, --timeout-ms", USAGE);
+  }
+  return options;
+}
+
+async function status(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  rejectArgs(args, USAGE);
+  printData(await runtimeRequest("/api/advisor/settings", {}, deps), wantsJson);
+}
+
+function printDisclosure(): void {
+  console.error(ADVISOR_CONTEXT_SHARING_DISCLOSURE);
+}
+
+async function readConsent(deps: RuntimeApiDeps): Promise<unknown> {
+  const current = await runtimeRequest("/api/advisor/settings", {}, deps) as {
+    settings?: { contextSharingConsent?: unknown };
+  };
+  return current.settings?.contextSharingConsent;
+}
+
+async function setEnabled(enabled: boolean, argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const acknowledge = takeFlag(args, "--ack-context-sharing");
+  rejectArgs(args, USAGE);
+  if (!enabled) {
+    if (acknowledge) {
+      throw new CliUsageError(
+        "--ack-context-sharing has no effect with `ocx advisor off`; it never records consent.",
+        USAGE,
+      );
+    }
+    printData(await runtimeRequest("/api/advisor/settings", {
+      method: "PUT",
+      body: JSON.stringify({ enabled: false }),
+    }, deps), wantsJson, ["Advisor disabled."]);
+    return;
+  }
+  const consent = await readConsent(deps);
+  if (acknowledge) {
+    printDisclosure();
+    printData(await runtimeRequest("/api/advisor/settings", {
+      method: "PUT",
+      body: JSON.stringify({
+        enabled: true,
+        contextSharingConsent: ADVISOR_CONTEXT_SHARING_CONSENT_VERSION,
+      }),
+    }, deps), wantsJson, ["Advisor enabled with context-sharing consent v1."]);
+    return;
+  }
+  if (consent !== ADVISOR_CONTEXT_SHARING_CONSENT_VERSION) {
+    printDisclosure();
+    throw new CliUsageError(
+      "Advisor context-sharing consent is required before consultations can send task content. "
+      + "Re-run `ocx advisor on --ack-context-sharing` after reading the disclosure, or run `ocx advisor consent`.",
+      USAGE,
+    );
+  }
+  printData(await runtimeRequest("/api/advisor/settings", {
+    method: "PUT",
+    body: JSON.stringify({ enabled: true }),
+  }, deps), wantsJson, ["Advisor enabled."]);
+}
+
+async function consent(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const revoke = takeFlag(args, "--revoke");
+  rejectArgs(args, USAGE);
+  if (!revoke) printDisclosure();
+  printData(await runtimeRequest("/api/advisor/settings", {
+    method: "PUT",
+    body: JSON.stringify({
+      contextSharingConsent: revoke ? null : ADVISOR_CONTEXT_SHARING_CONSENT_VERSION,
+    }),
+  }, deps), wantsJson, [revoke
+    ? "Advisor context-sharing consent removed. Consultations will not send task content."
+    : "Advisor context-sharing consent v1 recorded.",
+  ]);
+}
+
+async function set(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const options = parseSetArgs(args);
+  const patch: Record<string, unknown> = {};
+  if (options.model !== undefined) patch.model = options.model;
+  if (options.effort !== undefined) patch.effort = options.effort;
+  if (options.policy !== undefined) patch.policy = options.policy;
+  if (options.timeoutMs !== undefined) {
+    const parsed = Number(options.timeoutMs);
+    if (!Number.isFinite(parsed)) throw new CliUsageError("--timeout-ms must be a number", USAGE);
+    patch.timeoutMs = parsed;
+  }
+  printData(await runtimeRequest("/api/advisor/settings", {
+    method: "PUT",
+    body: JSON.stringify(patch),
+  }, deps), wantsJson, ["Advisor settings saved."]);
+}
+
+export async function handleAdvisorCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
+  return runCliAction(async () => {
+    const [sub = "status", ...rest] = argv;
+    if (sub === "status") await status(rest, deps);
+    else if (sub === "on") await setEnabled(true, rest, deps);
+    else if (sub === "off") await setEnabled(false, rest, deps);
+    else if (sub === "consent") await consent(rest, deps);
+    else if (sub === "set") await set(rest, deps);
+    else throw new CliUsageError(`unknown advisor command ${sub}`, USAGE);
+  });
+}
+
+export const ADVISOR_USAGE = USAGE;

package/src/cli/auxiliary-listener-preflight.ts

@@ -0,0 +1,37 @@
+import type { OcxConfig } from "../types";
+import { AuxiliaryListenerBindError } from "../server/ports";
+import { createServer } from "node:net";
+
+/**
+ * Reject impossible auxiliary binds before startup creates private state. On Windows
+ * that publication requires several synchronous ACL subprocesses. This is only an
+ * early rejection: startServer still owns the actual bind and transactional rollback
+ * if another process takes the port between this probe and startup.
+ */
+export async function assertAuxiliaryListenerPortsAvailable(config: OcxConfig): Promise<void> {
+  const loopback = config.unauthenticatedLoopbackListener;
+  const management = config.runtimeRole === "hub" ? config.hub?.managementIngress : undefined;
+  const targets = [
+    { listener: "unauthenticatedLoopbackListener", port: loopback?.enabled ? loopback.port : undefined },
+    { listener: "hub.managementIngress", port: management?.enabled ? management.port : undefined },
+  ] as const;
+  // Each probe releases its socket, so two listeners configured for one port would both
+  // pass and startup would still fail on the second bind. Reject the collision directly.
+  if (targets[0].port !== undefined && targets[0].port === targets[1].port) {
+    throw new AuxiliaryListenerBindError(
+      "hub.managementIngress", targets[1].port, "127.0.0.1",
+      new Error("port is also configured for unauthenticatedLoopbackListener"),
+    );
+  }
+  for (const { listener, port } of targets) {
+    // The port-less companion shares the public bind; it has no independent target.
+    if (port === undefined) continue;
+    await new Promise<void>((resolve, reject) => {
+      const probe = createServer(socket => socket.destroy());
+      const fail = (cause: unknown) => reject(new AuxiliaryListenerBindError(listener, port, "127.0.0.1", cause));
+      probe.once("error", fail);
+      probe.once("listening", () => probe.close(error => error ? fail(error) : resolve()));
+      try { probe.listen({ port, host: "127.0.0.1" }); } catch (error) { fail(error); }
+    });
+  }
+}

package/src/cli/capabilities-agents-routing.ts

@@ -25,6 +25,24 @@ export const AGENT_ROUTING_CAPABILITIES: readonly Capability[] = [
       "queued means submitted, not processed. unknown must not be replayed; no automatic retry, daemon start or thread resume.",
       "Exit 0: queued; 1: not sent; 3: unknown; 64: invalid usage. No remote/Claude transport or skill installation."],
   },
+  {
+    command: ["advisor"],
+    summary: "Inspect and configure the advisor sidecar (expert consultation for routed workers).",
+    routes: [
+      { method: "GET", path: "/api/advisor/settings" },
+      { method: "PUT", path: "/api/advisor/settings" },
+    ],
+    flags: [{ name: "--json", value: "boolean", summary: "Emit advisor settings as JSON." }],
+    mutates: true,
+    json: "payload",
+    details: [
+      "`status` (the default) reads the resolved settings; `on`/`off` toggle the sidecar; `consent` records or revokes context-sharing consent; `set` updates model, effort, policy, or timeout.",
+      "`on` does not grant consent. Without current consent it refuses and prints the disclosure. `on --ack-context-sharing` records consent v1 and enables. `consent --revoke` removes consent and stops task-context transfer.",
+      "The advisor model may be any routable model string: a bare native model, an explicit `provider/model`, or an account-qualified native model.",
+      "`policy: preflight` makes OpenCodex attempt one automatic consultation per task with a stable conversation identity once the task shows orientation evidence (an assistant tool call or a tool result after the latest user message). Without a stable identity, each eligible request may trigger another consultation. `policy: manual` consults only when the worker calls the synthetic `advisor` tool. Neither path sends task context without current context-sharing consent.",
+    ],
+  },
+
   {
     command: ["agent", "status"],
     usage: "ocx agent status [--json]",

package/src/cli/capabilities-base.ts

@@ -786,7 +786,7 @@ export const CAPABILITIES: readonly Capability[] = [
     command: ["api","policy"],
     summary: "Read the protocol policy, or change the Messages surface, unrepresentable policy and rollout switches.",
     routes: [{"method":"GET","path":"/api/protocols"},{"method":"PATCH","path":"/api/protocols/settings"}],
-    flags: [{"name":"--messages","value":"string","summary":"Open or close the Messages API: on or off. Off also turns the Claude integration off."},{"name":"--unrepresentable","value":"string","summary":"legacy keeps today's behavior; reject refuses a request its path cannot carry."},{"name":"--rollout","value":"string","summary":"One switch as name=on or name=off; repeatable. Every switch defaults off."},{"name":"--json","value":"boolean","summary":"Emit the resulting GET /api/protocols body."}],
+    flags: [{"name":"--messages","value":"string","summary":"Open or close the Messages API: on or off. Off also turns the Claude integration off."},{"name":"--unrepresentable","value":"string","summary":"legacy keeps today's behavior; reject refuses a request its path cannot carry."},{"name":"--rollout","value":"string","summary":"One switch as name=on or name=off; repeatable. Every switch defaults off except antigravityDirect."},{"name":"--json","value":"boolean","summary":"Emit the resulting GET /api/protocols body."}],
     mutates: true,
     json: "payload",
     details: ["A bare invocation reads and never writes.","A setting flag changes the operator's config; run it only when the operator asks for that change."],

package/src/cli/chatgpt-command.ts

@@ -20,7 +20,7 @@ const USAGE = `Usage (experimental, macOS only):
 
 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() };
+  return { ok: result.status === 0, status: result.status, output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim() };
 }
 
 /**
@@ -42,11 +42,12 @@ function chatgptDesktopIssueInFile(): string | null {
  * 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 {
+function discoverApp(): DesktopAppInstall | null | undefined {
   try {
     return darwinDesktopAppAdapter.discover(darwinDefaultExec);
   } catch {
-    return null;
+    // An inspection error is not evidence that the app is uninstalled.
+    return undefined;
   }
 }
 
@@ -55,14 +56,20 @@ function discoverApp(): DesktopAppInstall | null {
  * `-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 } {
+function appState(install: DesktopAppInstall, launcher: string): { running: boolean | null; shim: boolean | null } {
   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))) {
+  // pgrep exit 1 means no match; timeout, signal, or command errors are unknown.
+  if (!pids.ok) return pids.status === 1
+    ? { running: false, shim: false } : { running: null, shim: null };
+  const candidates = pids.output.split(/\s+/).filter(value => /^\d+$/.test(value));
+  if (candidates.length === 0) return { running: null, shim: null };
+  let unreadable = false;
+  for (const pid of candidates) {
     const command = run("ps", ["eww", "-o", "command=", "-p", pid]);
+    if (!command.ok || !command.output) unreadable = true;
     if (command.ok && (command.output === shell || command.output.startsWith(`${shell} `))) {
       const marker = `CODEX_CLI_PATH=${launcher}`;
       const start = command.output.indexOf(marker);
@@ -70,20 +77,24 @@ function appState(install: DesktopAppInstall, launcher: string): { running: bool
         && (start + marker.length === command.output.length || command.output[start + marker.length] === " ") };
     }
   }
-  return { running: false, shim: false };
+  return unreadable ? { running: null, shim: null } : { 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;
+  const initial = appState(install, launcher).running;
+  if (initial === false) return true;
+  if (initial === null) return false;
   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;
+      const running = appState(install, launcher).running;
+      if (running === false) return true;
+      if (running === null) return false;
       await Bun.sleep(250);
     }
   }
-  return !appState(install, launcher).running;
+  return appState(install, launcher).running === false;
 }
 
 export async function handleChatgptCommand(args: string[], platform: NodeJS.Platform = process.platform): Promise<number> {
@@ -105,16 +116,21 @@ export async function handleChatgptCommand(args: string[], platform: NodeJS.Plat
     const launcher = chatgptShimLauncherPath();
     const install = discoverApp();
     if (sub === "status") {
-      const app = install ? appState(install, launcher) : { running: false, shim: false };
+      const app = install ? appState(install, launcher)
+        : install === undefined ? { running: null, shim: null } : { running: false, shim: false };
       const configIssue = config.chatgptDesktop?.appServerShim === true ? null : chatgptDesktopIssueInFile();
       const flag = config.chatgptDesktop?.appServerShim === true ? "on"
         : configIssue ? `off (config.json ${configIssue}; the whole chatgptDesktop block is ignored)` : "off";
       console.log(`app-server shim (experimental): ${flag}
 launcher: ${existsSync(launcher) ? "present" : "absent"}
-app: ${install ? (app.running ? "running" : "not running") : "not installed"}
-CODEX_CLI_PATH launcher: ${app.shim ? "yes" : "no"}`);
+app: ${install === undefined ? "unknown (app discovery failed)" : install ? (app.running === null ? "unknown (process inspection failed)" : app.running ? "running" : "not running") : "not installed"}
+CODEX_CLI_PATH launcher: ${app.shim === null ? "unknown" : app.shim ? "yes" : "no"}`);
       return 0;
     }
+    if (install === undefined) {
+      console.error("ChatGPT app discovery failed; no launcher was changed and no app was opened. Retry after resolving discovery.");
+      return 1;
+    }
     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.");
@@ -143,9 +159,14 @@ CODEX_CLI_PATH launcher: ${app.shim ? "yes" : "no"}`);
       console.error(`Refusing to ${sub === "launch" ? "launch the shim" : "restore ChatGPT"}: ${untrusted}.`);
       return 1;
     }
+    // Preflight before changing the launcher. quitApp rechecks at the action boundary.
+    if (appState(install, launcher).running === null) {
+      console.error("ChatGPT process inspection failed; no launcher was changed and no app was opened. Retry after resolving inspection.");
+      return 1;
+    }
     if (binary) writeChatgptShimLauncher(undefined, binary);
     if (!(await quitApp(install, launcher))) {
-      console.error("ChatGPT did not quit; quit it manually and retry.");
+      console.error("ChatGPT exit could not be confirmed; no new app was opened. Check the running app and retry.");
       return 1;
     }
     // Remove an inherited override too: restore must launch without CODEX_CLI_PATH.