@bitkyc08/opencodex 2.90.0 → 2.92.0

package/src/server/responses-phase-inference.ts

@@ -0,0 +1,267 @@
+import type { OcxMessagePhase } from "../types";
+import { Buffer } from "node:buffer";
+import type { TranslatorBudget } from "../lib/translator-budget";
+import type { SseBlockRewrite } from "./sse-payload-rewrite";
+import { replaceSseDataPayload, sseDataPayload } from "./sse-payload-rewrite";
+
+/**
+ * Opt-in per-provider phase inference for Responses passthrough streams.
+ *
+ * OpenAI models annotate assistant messages with a commentary/final_answer
+ * phase; the Codex desktop UI collapses commentary into progress rows and
+ * only fully renders the final answer. Third-party gateways forward plain
+ * Responses items without that field, so every narration chunk renders
+ * expanded. The wire has no phase field, so phase is inferred from what
+ * follows each completed message, mirroring the openai-chat bridge strategy:
+ * a message followed by tool-call work is commentary; a message at turn end
+ * is the final answer. Messages already carrying commentary or final_answer
+ * are left untouched and forwarded without buffering; a null or unknown phase
+ * is inferred like a missing one. Each rewritten message stays
+ * buffered until the next protocol event (SSE keepalives keep it pending).
+ * Live text deltas are not buffered, but message completion waits for that
+ * event. Snapshots reuse each item decision when their phase is absent,
+ * matched by item id or, when either side lacks an id, by output index;
+ * explicit snapshot phases take precedence, and failed snapshots are untouched.
+ */
+
+const TERMINAL_EVENT_TYPES = new Set([
+  "response.completed",
+  "response.incomplete",
+  "response.failed",
+]);
+const TOOL_CALL_ITEM_TYPES = new Set([
+  "function_call",
+  "custom_tool_call",
+  "local_shell_call",
+  "shell_call",
+  "apply_patch_call",
+  "mcp_call",
+  "tool_search_call",
+  "web_search_call",
+]);
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Only these two values are decisions; null or unknown phases count as missing. */
+function isMessagePhase(value: unknown): value is OcxMessagePhase {
+  return value === "commentary" || value === "final_answer";
+}
+
+function isToolCallItem(item: unknown): boolean {
+  if (!isPlainObject(item)) return false;
+  const type = item.type;
+  return typeof type === "string"
+    && (TOOL_CALL_ITEM_TYPES.has(type)
+      // Unknown hosted/extension call shapes still prove the turn continued.
+      || (type.endsWith("_call") && !type.endsWith("_call_output")));
+}
+
+function parseDataPayload(block: string): Record<string, unknown> | null {
+  const payload = sseDataPayload(block);
+  if (payload === null) return null;
+  try {
+    const parsed = JSON.parse(payload) as unknown;
+    return isPlainObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isDoneSentinel(block: string): boolean {
+  return sseDataPayload(block)?.trim() === "[DONE]";
+}
+
+function isMessageDoneBlock(block: string): boolean {
+  const parsed = parseDataPayload(block);
+  return parsed?.type === "response.output_item.done"
+    && isPlainObject(parsed.item) && parsed.item.type === "message";
+}
+
+function withMessagePhase(block: string, phase: OcxMessagePhase): string {
+  const parsed = parseDataPayload(block);
+  if (!parsed || parsed.type !== "response.output_item.done") return block;
+  if (!isPlainObject(parsed.item) || isMessagePhase(parsed.item.phase)) return block;
+  const patched = { ...parsed, item: { ...parsed.item, phase } };
+  return replaceSseDataPayload(block, JSON.stringify(patched));
+}
+
+/** One per-item decision, findable by item id and by output index. */
+interface PhaseDecision {
+  readonly id: string | null;
+  readonly index: number | null;
+  readonly phase: OcxMessagePhase;
+}
+
+interface PhaseDecisions {
+  readonly byId: ReadonlyMap<string, PhaseDecision>;
+  readonly byIndex: ReadonlyMap<number, PhaseDecision>;
+}
+
+function outputIndexOf(value: unknown): number | null {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+/**
+ * The phase already emitted on the wire for the snapshot item at `position`.
+ * An id match wins. A position match is used only when the event or the
+ * snapshot item lacks an id, so two different ids never share a decision.
+ */
+function decidedPhase(decisions: PhaseDecisions, id: string | null, position: number): OcxMessagePhase | undefined {
+  const byId = id !== null ? decisions.byId.get(id) : undefined;
+  if (byId) return byId.phase;
+  const byIndex = decisions.byIndex.get(position);
+  return byIndex && (byIndex.id === null || id === null) ? byIndex.phase : undefined;
+}
+
+function withSnapshotPhases(block: string, decisions: PhaseDecisions): string {
+  const parsed = parseDataPayload(block);
+  if (!parsed) return block;
+  const response = parsed.response;
+  if (!isPlainObject(response) || !Array.isArray(response.output)) return block;
+  let changed = false;
+  const output = response.output.map((item: unknown, position: number) => {
+    if (isPlainObject(item) && item.type === "message" && !isMessagePhase(item.phase)) {
+      // Mirror the decision already emitted for this item on the wire, so
+      // clients reconciling the final snapshot never re-expand a message
+      // whose output_item.done said commentary. Items the rewrite never saw
+      // (joined mid-stream, no buffered decision) fall back to final_answer.
+      const id = typeof item.id === "string" ? item.id : null;
+      const phase = decidedPhase(decisions, id, position) ?? "final_answer";
+      changed = true;
+      return { ...item, phase };
+    }
+    return item;
+  });
+  if (!changed) return block;
+  const patched = { ...parsed, response: { ...response, output } };
+  return replaceSseDataPayload(block, JSON.stringify(patched));
+}
+
+export function createResponsesPhaseInferenceBlockRewrite(budget: TranslatorBudget): SseBlockRewrite {
+  // At most one message-done block is held at a time; the next block decides
+  // its phase and is then processed itself. Malformed blocks pass through
+  // without consuming the pending decision. Per-item decisions fill missing
+  // snapshot phases. Both pending blocks and decisions share the request
+  // retention budget and are released at a terminal event or teardown.
+  let pending: string | null = null;
+  let pendingBytes = 0;
+  let decisionBytes = 0;
+  const byId = new Map<string, PhaseDecision>();
+  const byIndex = new Map<number, PhaseDecision>();
+  const decisions: PhaseDecisions = { byId, byIndex };
+  const scope = { kind: "retained_collectors" as const };
+
+  const clearState = (): void => {
+    budget.releaseRetained(pendingBytes + decisionBytes, scope);
+    pending = null;
+    pendingBytes = 0;
+    decisionBytes = 0;
+    byId.clear();
+    byIndex.clear();
+  };
+
+  const decisionSize = (decision: PhaseDecision): number =>
+    Buffer.byteLength(JSON.stringify([decision.id, decision.index, decision.phase]));
+
+  const rememberPhase = (item: unknown, outputIndex: unknown, phase: OcxMessagePhase): void => {
+    const id = isPlainObject(item) && typeof item.id === "string" ? item.id : null;
+    const index = outputIndexOf(outputIndex);
+    if (id === null && index === null) return;
+    const next: PhaseDecision = { id, index, phase };
+    const replaced = new Set<PhaseDecision>();
+    const previousById = id !== null ? byId.get(id) : undefined;
+    const previousByIndex = index !== null ? byIndex.get(index) : undefined;
+    if (previousById) replaced.add(previousById);
+    if (previousByIndex) replaced.add(previousByIndex);
+    let delta = decisionSize(next);
+    for (const previous of replaced) delta -= decisionSize(previous);
+    // Charge before mutating, so a budget rejection leaves state consistent.
+    if (delta > 0) budget.chargeRetained(delta, scope);
+    else if (delta < 0) budget.releaseRetained(-delta, scope);
+    for (const previous of replaced) {
+      if (previous.id !== null && byId.get(previous.id) === previous) byId.delete(previous.id);
+      if (previous.index !== null && byIndex.get(previous.index) === previous) byIndex.delete(previous.index);
+    }
+    if (id !== null) byId.set(id, next);
+    if (index !== null) byIndex.set(index, next);
+    decisionBytes += delta;
+  };
+
+  const releasePending = (phase: OcxMessagePhase): readonly string[] => {
+    if (pending === null) return [];
+    const block = pending;
+    const parsed = parseDataPayload(block);
+    rememberPhase(parsed?.item, parsed?.output_index, phase);
+    const patched = withMessagePhase(block, phase);
+    budget.releaseRetained(pendingBytes, scope);
+    pending = null;
+    pendingBytes = 0;
+    return [patched];
+  };
+
+  const rewrite = (block: string): readonly string[] => {
+    const parsed = parseDataPayload(block);
+    const type = typeof parsed?.type === "string" ? parsed.type : null;
+    if (TERMINAL_EVENT_TYPES.has(type!)) {
+      // Turn end: any still-buffered message is the final answer, and the
+      // terminal snapshot mirrors the same per-item decisions for consistency.
+      const released = releasePending("final_answer");
+      const snapshot = type === "response.failed" ? block : withSnapshotPhases(block, decisions);
+      clearState();
+      return [...released, snapshot];
+    }
+    if (type === "response.output_item.done" && isMessageDoneBlock(block)) {
+      const item = parsed?.item;
+      if (isPlainObject(item) && isMessagePhase(item.phase)) {
+        // An explicit upstream phase needs no inference: forward immediately
+        // instead of buffering a message that an abnormal teardown would
+        // otherwise drop before it was ever emitted.
+        const released = releasePending("commentary");
+        rememberPhase(item, parsed?.output_index, item.phase);
+        return [...released, block];
+      }
+      // A following message done means the turn continued past the buffered
+      // one (a phase change or a guarded continuation): commentary. Buffer
+      // the current block for classification by whatever comes next.
+      const released = releasePending("commentary");
+      const bytes = Buffer.byteLength(block);
+      budget.chargeRetained(bytes, scope);
+      pending = block;
+      pendingBytes = bytes;
+      return released;
+    }
+    if (type === null) {
+      // Comment keepalives and other non-JSON data blocks carry no
+      // classification evidence in either direction, so a still-buffered
+      // message stays pending across them. The [DONE] sentinel closes the
+      // stream cleanly, which proves the buffered message was the turn's
+      // final answer.
+      if (isDoneSentinel(block)) {
+        const released = releasePending("final_answer");
+        clearState();
+        return [...released, block];
+      }
+      return [block];
+    }
+    // Any other protocol event after a completed message proves the turn
+    // continued past it (tool calls, reasoning, a new item): commentary.
+    return [...releasePending("commentary"), block];
+  };
+
+  return Object.assign((block: string): readonly string[] => {
+    try { return rewrite(block); }
+    catch (error) {
+      clearState();
+      throw error;
+    }
+  }, {
+    dispose: () => {
+      // Relay teardown after a terminal event leaves nothing pending. An
+      // abnormal teardown before classification drops the retained block,
+      // since the stream is failing anyway and no phase was ever proven.
+      clearState();
+    },
+  });
+}

package/src/server/restart-replacement.ts

@@ -214,6 +214,9 @@ export interface ReplacementStartIo extends ReplacementReadinessIo {
   logPath?: string | null;
   parentPid?: number;
   retryDelayMs?: number;
+  /** Exit waits for a terminated not-ready replacement; tests shorten them. */
+  termWaitMs?: number;
+  killWaitMs?: number;
 }
 
 export interface ReplacementStartRequest {
@@ -227,10 +230,19 @@ export interface ReplacementStartRequest {
   waitForHealth: boolean;
   /** The replacement's environment, already prepared by the caller; the parent marker is added here. */
   env: NodeJS.ProcessEnv;
+  /**
+   * What a replacement still unready at the deadline means. `handoff` (the default, every
+   * standalone restart) hands off to it anyway, because the parent is about to exit and release
+   * what it may be waiting for. `terminate` is for a parent that keeps serving when the
+   * replacement fails (the client runtime): the replacement is stopped, its exit is observed, and
+   * the call rejects with `not_ready`, so nothing that may still bind the port survives.
+   */
+  notReady?: "handoff" | "terminate";
 }
 
 type AttemptOutcome =
-  | { kind: "spawned" | "ready" | "not-ready"; pid: number | undefined }
+  | { kind: "spawned" | "ready"; pid: number | undefined }
+  | { kind: "not-ready"; pid: number | undefined; terminate: () => Promise<boolean> }
   | { kind: "early-exit"; pid: number | undefined; code: number | null; signal: NodeJS.Signals | null };
 
 function pinnedPort(port: number | undefined): number | undefined {
@@ -314,7 +326,11 @@ function runReplacementAttempt(
       void waitForReplacementReady(child.pid, parentPid, expectedPort, { ...io, cancelled: () => settled }).then(
         // Never kill a live ordinary start at its valid reclaim boundary. Parent exit is the
         // final resource release the child may still be waiting for.
-        ready => { settle({ kind: ready ? "ready" : "not-ready", pid: child.pid }); },
+        ready => {
+          settle(ready
+            ? { kind: "ready", pid: child.pid }
+            : { kind: "not-ready", pid: child.pid, terminate: () => terminateReplacement(child, io) });
+        },
         err => { settle({ error: err }); },
       );
     };
@@ -369,6 +385,11 @@ export async function spawnReplacementStart(
         continue;
       }
       if (outcome.kind === "not-ready") {
+        if (request.notReady === "terminate") {
+          const exited = await outcome.terminate();
+          log?.note(`replacement pid ${pid} did not answer within the readiness window; ${exited ? "stopped it" : "it did not exit after SIGKILL"}`);
+          throw handoffError(exited ? "not_ready" : "not_ready_unstopped");
+        }
         console.warn("Restart replacement is still starting after the readiness window; handing off to it anyway");
         log?.note(`replacement pid ${pid} is still starting after the readiness window; handing off anyway`);
       } else {
@@ -380,3 +401,30 @@ export async function spawnReplacementStart(
     log?.close();
   }
 }
+
+/** Exit-observation budgets for {@link terminateReplacement}. */
+export const REPLACEMENT_TERM_WAIT_MS = 3_000;
+export const REPLACEMENT_KILL_WAIT_MS = 2_000;
+
+function waitForChildExit(child: ChildProcess, ms: number, sleep: (ms: number) => Promise<void>): Promise<boolean> {
+  if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
+  return new Promise<boolean>(resolve => {
+    let done = false;
+    const finish = (exited: boolean) => { if (!done) { done = true; child.off("exit", onExit); resolve(exited); } };
+    const onExit = () => finish(true);
+    child.once("exit", onExit);
+    void sleep(ms).then(() => finish(child.exitCode !== null || child.signalCode !== null));
+  });
+}
+
+/**
+ * Stop a replacement that never answered: SIGTERM, wait for its exit, then SIGKILL and wait again.
+ * True only once the exit was observed; a kill call alone is not proof the port is free.
+ */
+async function terminateReplacement(child: ChildProcess, io: ReplacementStartIo): Promise<boolean> {
+  const sleep = io.sleep ?? Bun.sleep;
+  try { child.kill("SIGTERM"); } catch { /* exited between the check and the signal */ }
+  if (await waitForChildExit(child, io.termWaitMs ?? REPLACEMENT_TERM_WAIT_MS, sleep)) return true;
+  try { child.kill("SIGKILL"); } catch { /* exited between the check and the signal */ }
+  return waitForChildExit(child, io.killWaitMs ?? REPLACEMENT_KILL_WAIT_MS, sleep);
+}

package/src/server/sse-payload-rewrite.ts

@@ -96,6 +96,8 @@ export function createSseBlockBuffer(
   let buffer = "";
   let offset = 0;
   let scanOffset = 0;
+  let needsScan = false;
+  let lastCodeUnit = Number.NaN;
   let bufferBytes = 0;
   const delimiterPattern = /(?:\r\n|\r(?!\n)|\n){2}/g;
 
@@ -111,7 +113,7 @@ export function createSseBlockBuffer(
       if (!fragment) return;
       let fragmentBytes = Buffer.byteLength(fragment, "utf8");
       // Decoder output never splits a surrogate pair, but keep the helper exact for string callers.
-      const last = buffer.charCodeAt(buffer.length - 1);
+      const last = lastCodeUnit;
       const first = fragment.charCodeAt(0);
       if (offset < buffer.length && last >= 0xd800 && last <= 0xdbff && first >= 0xdc00 && first <= 0xdfff) {
         fragmentBytes -= 2;
@@ -122,6 +124,8 @@ export function createSseBlockBuffer(
       try {
         compact();
         buffer += fragment;
+        lastCodeUnit = fragment.charCodeAt(fragment.length - 1);
+        needsScan ||= fragment.includes("\r") || fragment.includes("\n");
         reservation.commitRetained();
         budget.releaseRetained(bufferBytes, scope);
         bufferBytes = nextBytes;
@@ -131,11 +135,16 @@ export function createSseBlockBuffer(
       }
     },
     next() {
+      if (!needsScan) {
+        scanOffset = Math.max(offset, buffer.length - 3);
+        return null;
+      }
       delimiterPattern.lastIndex = scanOffset;
       const match = delimiterPattern.exec(buffer);
       if (!match) {
         // A delimiter is at most four code units. Revisit only its possible split prefix.
         scanOffset = Math.max(offset, buffer.length - 3);
+        needsScan = false;
         return null;
       }
       const start = match.index;
@@ -153,6 +162,8 @@ export function createSseBlockBuffer(
         buffer = "";
         offset = 0;
         scanOffset = 0;
+        needsScan = false;
+        lastCodeUnit = Number.NaN;
       }
       return { block, delimiter };
     },
@@ -164,6 +175,8 @@ export function createSseBlockBuffer(
       buffer = "";
       offset = 0;
       scanOffset = 0;
+      needsScan = false;
+      lastCodeUnit = Number.NaN;
       bufferBytes = 0;
     },
   };

package/src/server/ws-bridge.ts

@@ -12,6 +12,7 @@ import { sseDataPayload as parseSseBlock } from "./sse-payload-rewrite";
 import { safeResponseHeaders } from "./safe-response-headers";
 import type { AudioSocketTarget } from "./audio-dictation";
 import type { CodexWebSocketActivity } from "../codex/websocket-activity";
+import { AGENT_ASSERTION_HEADER } from "../lib/authorization-scheme";
 
 export { safeResponseHeaders } from "./safe-response-headers";
 
@@ -131,6 +132,10 @@ export function selectForwardHeaders(
   if (codexOverride) {
     selected.set("authorization", `Bearer ${codexOverride.accessToken}`);
     selected.set("chatgpt-account-id", codexOverride.chatgptAccountId);
+  } else {
+    // Kept for the WS turn pipeline, which drops it again everywhere except first-party Direct.
+    const assertion = headers.get(AGENT_ASSERTION_HEADER);
+    if (assertion) selected.set(AGENT_ASSERTION_HEADER, assertion);
   }
   return selected;
 }

package/src/service/cli.ts

@@ -11,6 +11,7 @@ import { statusWinswRaw, type WinswStatus } from "../lib/winsw";
 import { withWindowsServiceMutationLock } from "../lib/windows-service-mutation-lock";
 import { maybeShowStarPrompt } from "../cli/star-prompt";
 import { serviceStatusReport } from "./diagnostics";
+import { collectServiceStatusJson } from "./status-json";
 import { assertServiceAuthEnvironment } from "./auth-preflight";
 import { assertServiceEnvironmentMatchesInstall } from "./guards";
 import { resolveServiceListenPort } from "./definition";
@@ -47,10 +48,14 @@ export function normalizeServiceSubcommand(sub?: string): string {
   return sub ?? "install";
 }
 
+const SERVICE_JSON_STATUS_ONLY = "--json applies to `ocx service status` only.";
+
 export interface ParsedServiceArgs {
   sub: string;
   backend: ServiceBackend | null;
   invalid: string[];
+  /** `--json`: accepted for `status` only; planServiceCommand rejects it elsewhere. */
+  json: boolean;
 }
 
 export type ServiceInstallationState = "installed" | "absent" | "unknown";
@@ -140,6 +145,9 @@ export function planServiceCommand(
   if (parsed.invalid.length > 0) {
     return { ok: false, message: `Unknown service option: ${parsed.invalid.join(" ")}` };
   }
+  if (parsed.json && parsed.sub !== "status") {
+    return { ok: false, message: SERVICE_JSON_STATUS_ONLY };
+  }
   if (parsed.backend && parsed.sub !== "install") {
     return { ok: false, message: "--native/--scheduler apply to `ocx service install` only; other subcommands use the installed backend." };
   }
@@ -174,9 +182,11 @@ export function planServiceCommand(
 export function parseServiceArgs(args: string[]): ParsedServiceArgs {
   let sub: string | undefined;
   let backend: ServiceBackend | null = null;
+  let json = false;
   const invalid: string[] = [];
   for (const arg of args) {
-    if (arg === "--native") {
+    if (arg === "--json") json = true;
+    else if (arg === "--native") {
       if (backend === "scheduler") { invalid.push("--native (conflicts with --scheduler)"); continue; }
       backend = "native";
     }
@@ -188,7 +198,7 @@ export function parseServiceArgs(args: string[]): ParsedServiceArgs {
     else if (sub === undefined) sub = arg;
     else invalid.push(arg);
   }
-  return { sub: normalizeServiceSubcommand(sub), backend, invalid };
+  return { sub: normalizeServiceSubcommand(sub), backend, invalid, json };
 }
 
 /** Remove the service credential only when no client connection can own it. */
@@ -243,6 +253,12 @@ export async function serviceCommand(...args: (string | undefined)[]): Promise<v
       process.exitCode = 1;
       return;
     }
+  // Answered before platformOps() resolves: the JSON status reaches no install, start, stop,
+  // repair or migration path, and an unsupported platform still gets a document, not an exit.
+  if (command === "status" && parsed.json) {
+    console.log(JSON.stringify(await collectServiceStatusJson(), null, 2));
+    return;
+  }
   if (command === "repair" || command === "restart") {
     const verb: ServiceRepairVerb = command === "restart" ? "restart" : "repair";
     assertServiceEnvironmentMatchesInstall();
@@ -488,6 +504,13 @@ export async function serviceCommand(...args: (string | undefined)[]): Promise<v
   };
 
   const preliminary = parseServiceArgs(filteredArgs);
+  // `claim` parses its own --json. Any other verb is refused here, before the Desktop check
+  // and the Windows mutation lock, so a misplaced --json never reaches either.
+  if (preliminary.json && preliminary.sub !== "status" && preliminary.sub !== "claim") {
+    console.error(SERVICE_JSON_STATUS_ONLY);
+    process.exitCode = 1;
+    return;
+  }
   if (preliminary.invalid.length === 0) {
     const refusal = desktopServiceCommandRefusal(preliminary.sub, undefined, supervisionLatch);
     if (refusal) {

package/src/service/definition.ts

@@ -7,7 +7,8 @@
  * route back through them (see `installedServiceListenPort` in `health.ts`, which
  * intentionally stays behind because it asks every backend).
  */
-import { loadConfig } from "../config";
+import { getConfigDir, loadConfig } from "../config";
+import { readClaudeInterceptProxyToken } from "../claude/intercept/proxy-auth";
 import { serviceApiTokenFilePath } from "../lib/service-secrets";
 import { PROXY_ENV_KEYS } from "../lib/proxy-env";
 
@@ -87,19 +88,30 @@ export function parseBakedListenPort(read: () => string): number | null {
  * own `applyProxyEnv` already treats both cases as equivalent. Only the canonical
  * upper-case name is baked, so a definition never carries two spellings of one setting.
  */
-export function resolvedProxyEnv(env: NodeJS.ProcessEnv = process.env): { name: string; value: string }[] {
+export function resolvedProxyEnv(
+  env: NodeJS.ProcessEnv = process.env,
+  ownClaudeInterceptProxy?: string | null,
+): { name: string; value: string }[] {
+  const token = ownClaudeInterceptProxy === undefined ? readClaudeInterceptProxyToken(getConfigDir()) : null;
   const resolved: { name: string; value: string }[] = [];
   for (const key of PROXY_ENV_KEYS) {
-    const value = [env[key]?.trim(), env[key.toLowerCase()]?.trim()].find(v => v && !OWN_CLAUDE_INTERCEPT_PROXY.test(v));
+    const value = [env[key]?.trim(), env[key.toLowerCase()]?.trim()].find(v => v && (
+      ownClaudeInterceptProxy === undefined ? !isOwnedClaudeInterceptProxy(v, token) : v !== ownClaudeInterceptProxy
+    ));
     if (value) resolved.push({ name: key, value });
   }
   return resolved;
 }
 
 /**
- * The URL Claude first-party writes into `~/.claude/settings.json` (`claudeInterceptProxyUrl`),
- * which every process Claude Code starts inherits. Baked into the service, it would send the
- * proxy's own outbound traffic back through its intercept listener. Only the token-bearing form
- * is matched: a plain `http://127.0.0.1:<port>` is a user's local proxy client and is kept.
+ * Match this installation's credential and exact URL components without creating a token.
+ * An inherited URL can still use an old bound port after the persisted config changes.
+ * Shape alone cannot establish ownership: a user proxy may also use an `opencodex` username.
  */
-const OWN_CLAUDE_INTERCEPT_PROXY = /^http:\/\/opencodex:[^@/]+@127\.0\.0\.1:\d{1,5}\/?$/i;
+function isOwnedClaudeInterceptProxy(value: string, token: string | null): boolean {
+  if (!token) return false;
+  const prefix = `http://opencodex:${encodeURIComponent(token)}@127.0.0.1:`;
+  if (!value.startsWith(prefix)) return false;
+  const port = value.slice(prefix.length).replace(/\/$/, "");
+  return /^\d{1,5}$/.test(port) && Number(port) > 0 && Number(port) <= 65535;
+}

package/src/service/diagnostics.ts

@@ -282,16 +282,30 @@ export function diagnoseService(): ServiceDiagnostic {
     const enabled = installed && (() => { try { return sh(`systemctl --user is-enabled ${TASK}`) === "enabled"; } catch { return false; } })();
     const running = installed && (() => { try { return sh(`systemctl --user is-active ${TASK}`) === "active"; } catch { return false; } })();
     const stale = installed && bakedServicePathsDiagnostic() !== null;
-    const viable = installed && enabled && running && !stale;
-    const summary = !installed ? `not installed (${diagnostics})`
-      : stale ? `installed, but stale (systemd user; ${diagnostics})`
-        : viable ? `installed, enabled and running (systemd user; ${diagnostics})`
-          : `installed, but ${!enabled ? "disabled" : "not running"} (systemd user; ${diagnostics})`;
-    return { supported: true, installed, enabled, running, viable, startable: installed && !stale, stale, conflict: false, backend: "systemd", summary };
+    return deriveSystemdServiceDiagnostic({ installed, enabled, running, stale, diagnostics });
   }
   return { supported: false, installed: false, enabled: false, running: false, viable: false, startable: false, stale: false, conflict: false, backend: null, summary: `unsupported on ${process.platform}` };
 }
 
+export interface SystemdServiceDiagnosticInputs {
+  installed: boolean;
+  enabled: boolean;
+  running: boolean;
+  stale: boolean;
+  diagnostics: string;
+}
+
+/** The systemd user-unit verdict, pure so its states are testable without a user bus. */
+export function deriveSystemdServiceDiagnostic(inputs: SystemdServiceDiagnosticInputs): ServiceDiagnostic {
+  const { installed, enabled, running, stale, diagnostics } = inputs;
+  const viable = installed && enabled && running && !stale;
+  const summary = !installed ? `not installed (${diagnostics})`
+    : stale ? `installed, but stale (systemd user; ${diagnostics})`
+      : viable ? `installed, enabled and running (systemd user; ${diagnostics})`
+        : `installed, but ${!enabled ? "disabled" : "not running"} (systemd user; ${diagnostics})`;
+  return { supported: true, installed, enabled, running, viable, startable: installed && !stale, stale, conflict: false, backend: "systemd", summary };
+}
+
 export function serviceStatusSummary(): string {
   return diagnoseService().summary;
 }