codex-copilot-dx 0.6.1 → 0.6.3

package/README.md

@@ -29,11 +29,13 @@ npm install -g codex-copilot-dx@latest
 ccdx
 ```
 
-The shorter `ccdx` command is the primary launcher. The existing `codex-copilot-dx`
-command remains an equivalent compatibility alias. For a one-off run without a
-global install, use `npx codex-copilot-dx@latest`.
-Both installed commands expose the same options and subcommands; help, version,
-doctor, status, and argument-error output use the command name that was invoked.
+`ccdx` is the only documented command and primary launcher. The old
+`codex-copilot-dx` executable remains temporarily as a compatibility shim: it
+prints a deprecation warning and runs `ccdx`, and will be removed in a future
+breaking release. For a one-off run without a global install, use
+`npm exec --yes --package=codex-copilot-dx@latest -- ccdx`.
+Run `ccdx <command> --help` (including `auth login claude --help` and
+`pms status --help`) for command-specific behavior and side-effect details.
 
 To query the models currently advertised as selectable for the saved Codex
 Copilot account, run:
@@ -47,8 +49,7 @@ starting the adapter, opening device login, reading the local model cache, or
 consuming an inference request. It lists model IDs by provider with their
 advertised API capabilities and reports the live Claude/Anthropic count. A model
 being advertised does not guarantee that a later inference request will avoid
-quota, rate-limit, or policy enforcement. `codex-copilot-dx models` is fully
-equivalent.
+quota, rate-limit, or policy enforcement.
 
 ### Separate GitHub account for Claude
 
@@ -60,11 +61,14 @@ while using a different personal account that has Claude models enabled, run:
 ccdx auth login claude --github-login <personal-github-login>
 ```
 
-This is the only command that starts the additional Device Flow. It verifies
+This is the only command that may start the additional Device Flow. Before
+opening a browser, it checks compatible local Copilot credentials, excludes the
+current Codex identity, and reuses an unambiguous valid account. It then verifies
 the selected GitHub identity, Copilot entitlement, and an enabled Claude model
 before saving anything. It refuses the current Codex account and never changes,
 migrates, or deletes the existing Codex credential. The optional login pin is
-recommended so authorizing the wrong browser account fails before activation.
+recommended so a machine with multiple accounts selects only the requested
+identity. Use `--reauth` to bypass local discovery and force Device Flow.
 
 The existing Codex token remains at
 `~/.local/share/copilot-api/github_token`. The isolated Claude credential is
@@ -80,7 +84,8 @@ Once enabled, routing is fixed by API surface rather than by model name:
 - `/v1/messages/count_tokens` remains local and uses neither account.
 
 The two profiles keep separate service tokens, API bases, refresh/backoff state,
-model endpoint metadata, and model caches. If the isolated Claude profile later
+model endpoint metadata, and credential-bound model caches. Switching either
+GitHub account invalidates that profile's old cache instead of borrowing it. If the isolated Claude profile later
 becomes invalid, Claude requests fail with a reauthentication instruction while
 Codex remains available; CCDX never silently falls back to the enterprise
 account. Reauthorize it explicitly with:
@@ -114,6 +119,15 @@ ccdx auth login claude --reauth --github-login <personal-github-login>
 ccdx pms setup
 ```
 
+Inspect the installed version, exact patch integrity, isolated Claude profile,
+and relay without changing files:
+
+```bash
+ccdx pms status
+```
+
+`pm-studio status` and `pm-studio setup` are equivalent long-form aliases.
+
 `ccdx pms setup` performs only local preflight, backup, staging, integrity,
 signing, and replacement work. It never starts Device Flow, the adapter,
 Codex, or PM Studio, and it does not modify PM profiles, cached model lists, or
@@ -178,7 +192,7 @@ It saves the selection in `~/.config/codex-copilot-dx/config.json` (or under
 `XDG_CONFIG_HOME` when set); choosing `gpt-5.5` clears the override and restores
 the package default. A running 0.5.1+
 adapter reads the setting on the next Auto-review request, so it does not need to
-be restarted. `codex-copilot-dx auto-review-model` is fully equivalent.
+be restarted.
 
 To update the globally installed package, choose a source interactively:
 
@@ -201,8 +215,7 @@ latest commit from `DaleXiao/codex-copilot-dx` `main` and opts in to Git fetchin
 for that command, as required by npm 12. It does not change npm's persistent
 `allow-git` setting. Both paths use npm's global installer without shell
 interpolation. A currently running adapter keeps its loaded version until it is
-stopped and started again. The
-`codex-copilot-dx update` compatibility command behaves identically.
+stopped and started again.
 If a configured npm mirror has not synchronized the current release yet, use
 the GitHub source to install the current `main` revision.
 
@@ -232,7 +245,11 @@ ccdx doctor
 
 The command exits with status `1` when it finds an invalid configuration and `0` when checks contain only OK or warning results.
 
-The doctor checks the GitHub token, Codex config, Claude Code settings, Claude App gateway profile, and whether the local adapter port is listening.
+The doctor checks the GitHub token, Codex config, Claude Code settings, Claude
+App gateway profile, adapter availability, and an installed PM Studio bundle.
+It ends with passed/warning/error totals and deduplicated next-step commands.
+An absent PM Studio installation is ignored; unsupported versions are reported
+without modification, while integrity drift remains an error.
 
 For a read-only live check of the saved GitHub token, Copilot entitlement, and models endpoint, run:
 
@@ -259,15 +276,13 @@ For a read-only summary of the running adapter, use:
 ccdx status
 ```
 
-The compatibility alias supports the same command as
-`codex-copilot-dx status`. For the complete machine-readable payload, query the
-loopback endpoint directly:
+For the complete machine-readable payload, query the loopback endpoint directly:
 
 ```bash
 curl -s http://127.0.0.1:2026/_ccdx/status | jq
 ```
 
-The status endpoint is restricted to the socket's real loopback address, even when LAN binding is explicitly enabled. It reports fixed-size request counters, bounded TTFT/TPOT histograms for streaming routes, admission pressure, memory use, response-history size, image queue/cache state, model cache counts, and token expiry state. It never retains metric samples or includes prompts, completions, tool arguments, image content, account names, or token values. API responses always include a safe `X-Request-Id` for correlation. To include the same ID as `request_id` in related terminal and file log lines, start the adapter with:
+The status endpoint is restricted to the socket's real loopback address, even when LAN binding is explicitly enabled. It reports fixed-size request counters, bounded TTFT/TPOT histograms for streaming routes, admission pressure, memory use, response-history size, image queue/cache and adaptive-history state, profile model cache counts, PM relay route totals, and token expiry state. It never retains metric samples or includes prompts, completions, tool arguments, image content, account names, or token values. API responses always include a safe `X-Request-Id` for correlation. If the adapter is not running, the CLI prints the exact start-and-retry command. To include the same ID as `request_id` in related terminal and file log lines, start the adapter with:
 
 ```bash
 ccdx --show-request-id
@@ -287,13 +302,17 @@ ccdx
 Claude App support is opt-in so the default Codex Desktop and Claude Code setup stays unchanged:
 
 ```bash
-npx codex-copilot-dx@latest --configure-claude-desktop
+npm exec --yes --package=codex-copilot-dx@latest -- ccdx start --configure-claude-app
 ```
 
+The previous `--configure-claude-desktop` spelling remains a compatibility
+alias. Startup reports Claude App as ready only when a matching managed gateway
+key is restored or the profile is configured in that run.
+
 Or set:
 
 ```bash
-CCDX_CONFIGURE_CLAUDE_DESKTOP=1 npx codex-copilot-dx@latest
+CCDX_CONFIGURE_CLAUDE_DESKTOP=1 npm exec --yes --package=codex-copilot-dx@latest -- ccdx
 ```
 
 This writes a local Claude App 3P gateway profile that points to the adapter root URL, such as `http://127.0.0.1:2026`. The profile uses a generated local bearer key unless `CCDX_CLAUDE_DESKTOP_API_KEY` is set. Later starts restore that key only from the active managed profile when its gateway URL matches the adapter. Once that managed profile is active, successful Copilot model refreshes automatically keep its `inferenceModels` list current without changing the gateway key or other profile settings. Restart Claude App after the initial setup. Later model changes require no profile reconfiguration, although a running Claude App may need to be reopened if it has not reloaded the updated profile yet.
@@ -369,7 +388,7 @@ Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-d
 
 ### Image optimization
 
-Long computer-use sessions can accumulate screenshots inside the conversation history. Each screenshot is shipped on later turns, and GitHub Copilot's `/responses` endpoint can reject oversized requests with `408 Request Timeout` while reading the body or `413 Payload Too Large`.
+Long computer-use sessions can accumulate screenshots inside the conversation history. Each screenshot is shipped on later turns, which can increase local preparation time, upstream handshake latency, and the chance of a `413 Payload Too Large` response.
 
 The adapter automatically downsamples embedded screenshots to model-appropriate pixel bounds (with a conservative 2048 px long-edge fallback) and initially re-encodes them as WebP quality 82 before forwarding `/v1/responses`. It never replaces an image with a larger encoding and applies one global concurrency limit across direct, function-tool, and custom-tool output images.
 
@@ -377,6 +396,8 @@ The final serialized UTF-8 request body is measured before forwarding. Above the
 
 Completed image transforms are reused from a byte-bounded process-local LRU cache, and concurrent requests for the same transform share one encode. The cache key includes source content, MIME type, model-aware dimensions, WebP quality, and encoder settings; failures are not cached and request cancellation remains isolated.
 
+Before image encoding, CCDX leaves ordinary visual history byte-for-byte unchanged while it has at most 24 historical images and the expanded body is at most 18 MiB. Above either threshold, the temporary upstream view keeps every current-turn image and at most 16 recent historical images, targeting 16 MiB. If that history tree then times out during local preparation or upstream handshake, the next retry automatically uses an 8-image, 10 MiB recovery window for ten minutes. Two successful requests or a successful compaction clear recovery mode. CCDX never transparently repeats the ambiguous timed-out POST, and no local history is deleted; retrying does not require restarting the service.
+
 When expanded Responses history exceeds Copilot's 50-image request limit, the adapter removes older duplicate image occurrences first, then keeps the 50 most recent images. This applies only to the forwarded request: local history remains complete, current images are preferred over older history, and requests at or below the limit are unchanged.
 
 For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and rebuilds a replayable snapshot from recent system, developer, user, and assistant messages plus every compaction item. Only a validated snapshot becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.

package/bin/cli.mjs

@@ -39,7 +39,7 @@ try {
 }
 
 if (CLI.command === "help") {
-  console.log(cliHelp(CLI_NAME));
+  console.log(cliHelp(CLI_NAME, CLI.helpTopic));
   process.exit(0);
 }
 if (CLI.command === "version") {
@@ -125,6 +125,11 @@ if (CLI.command === "update") {
 }
 if (CLI.command === "pms") {
   try {
+    if (CLI.action === "status") {
+      const { runPmStudioStatus } = await import("../src/pm-studio-status.mjs");
+      const result = await runPmStudioStatus({ commandName: CLI_NAME });
+      process.exit(result.ok ? 0 : 1);
+    }
     const { runPmStudioSetup } = await import("../src/pm-studio-setup.mjs");
     await runPmStudioSetup({ commandName: CLI_NAME });
     process.exit(0);
@@ -206,7 +211,7 @@ async function reuseRunningAdapterIfAvailable() {
       console.log(status("warn", "Existing adapter is running; skip Claude App profile update unless CCDX_CLAUDE_DESKTOP_API_KEY or CCDX_PROXY_API_KEY is set"));
     }
   } else {
-    console.log(status("ok", "Claude App support available with --configure-claude-desktop"));
+    console.log(status("ok", "Claude App support available with --configure-claude-app"));
   }
 
   await openCodex();
@@ -270,6 +275,7 @@ try {
     codexClient: profileRuntime.codexClient,
     claudeClient: profileRuntime.claudeClient,
     claudeMode: profileRuntime.claudeMode,
+    codexCredentialFingerprint: profileRuntime.codexCredentialFingerprint,
     claudeCredentialFingerprint: profileRuntime.claudeCredentialFingerprint,
     timeoutMs: MODEL_REFRESH_TIMEOUT_MS,
     commandName: CLI_NAME,
@@ -329,7 +335,7 @@ try {
     console.log(status("ok", `Configured Claude App gateway profile at ${result.baseUrl}`));
     console.log(formatClaudeDesktopApplyResult(result));
   } else {
-    console.log(status("ok", "Claude App support available with --configure-claude-desktop"));
+    console.log(status("ok", "Claude App support available with --configure-claude-app"));
   }
 
   // Launch Codex when available.
@@ -345,8 +351,10 @@ try {
     modelRefreshTimer.unref?.();
   }
 
+  const readyClients = ["Codex App", "Claude Code"];
+  if (claudeDesktopApiKey) readyClients.splice(1, 0, "Claude App");
   console.log(`
-  ${status("ok", "Ready, Claude Code, Claude App and Codex App are now ready to use")}
+  ${status("ok", `Ready, ${readyClients.join(", ")} ${readyClients.length === 1 ? "is" : "are"} ready to use`)}
 
   Adapter: ${adapterBaseUrl(ADAPTER_HOST, ADAPTER_PORT)}
 

package/bin/codex-copilot-dx.mjs

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-import "./cli.mjs";
+console.warn("codex-copilot-dx is deprecated; use ccdx instead. The compatibility alias will be removed in a future breaking release.");
+await import("./cli.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/scripts/benchmark.mjs

@@ -8,6 +8,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import sharp from "sharp";
 import { optimizeImagesInBody, prepareResponsesPayload } from "../src/image-optimization.mjs";
+import { createPmStudioModelRouter } from "../src/profile-routing.mjs";
 
 const packageRoot = fileURLToPath(new URL("../", import.meta.url));
 
@@ -176,6 +177,60 @@ function largeTokenCountProbe(mode) {
   `);
 }
 
+function visualHistoryPressureProbe() {
+  return runProbe(`
+    import { applyResponsesImagePressure } from "./src/responses-image-pressure.mjs";
+
+    const concurrency = 4;
+    const historicalImages = 36;
+    const imageBytes = 256 * 1024;
+    const dataUrls = Array.from({ length: historicalImages }, (_, index) => (
+      \`data:image/png;base64,\${Buffer.alloc(imageBytes, index + 1).toString("base64")}\`
+    ));
+    const contexts = Array.from({ length: concurrency }, (_, requestIndex) => ({
+      historyRootId: \`resp_benchmark_\${requestIndex}\`,
+      currentInputStart: historicalImages,
+      body: {
+        model: "gpt-5.6-sol",
+        stream: true,
+        input: [
+          ...dataUrls.map((imageUrl) => ({
+            type: "message",
+            role: "user",
+            content: [{ type: "input_image", image_url: imageUrl }],
+          })),
+          { type: "message", role: "user", content: "continue" },
+        ],
+      },
+    }));
+    globalThis.gc?.();
+    const before = process.memoryUsage();
+    let peakRss = before.rss;
+    let peakHeap = before.heapUsed;
+    const started = performance.now();
+    const results = await Promise.all(contexts.map(async (context) => {
+      await Promise.resolve();
+      const result = applyResponsesImagePressure(context);
+      const memory = process.memoryUsage();
+      peakRss = Math.max(peakRss, memory.rss);
+      peakHeap = Math.max(peakHeap, memory.heapUsed);
+      return result;
+    }));
+    const mib = (bytes) => +(bytes / 1048576).toFixed(1);
+    process.stdout.write(JSON.stringify({
+      concurrency,
+      historical_images_per_request: historicalImages,
+      elapsed_ms: +(performance.now() - started).toFixed(1),
+      omitted_images: results.map((result) => result.imagesOmitted),
+      retained_historical_images: results.map((result) => result.historicalImages),
+      input_body_mib: results.map((result) => mib(result.initialBodyBytes)),
+      output_body_mib: results.map((result) => mib(result.bodyBytes)),
+      rss_peak_delta_mib: mib(peakRss - before.rss),
+      heap_peak_delta_mib: mib(peakHeap - before.heapUsed),
+    }));
+  `);
+}
+
 const adapterImport = runProbe(`
   const started = performance.now();
   await import("./src/adapter.mjs");
@@ -235,6 +290,34 @@ const duplicateImages = {
   optimizer_calls: duplicateCalls,
 };
 
+const routingCatalog = {
+  data: Array.from({ length: 1000 }, (_, index) => index % 5 === 0
+    ? {
+        id: `claude-benchmark-${index}`,
+        vendor: "Anthropic",
+        model_picker_enabled: true,
+        supported_endpoints: ["/chat/completions"],
+      }
+    : { id: `gpt-benchmark-${index}`, vendor: "OpenAI", supported_endpoints: ["/responses"] }),
+};
+const modelRouter = createPmStudioModelRouter({
+  getCatalog: () => routingCatalog,
+  isClaudeEnabled: () => true,
+});
+const routingIterations = 100000;
+const routingStarted = performance.now();
+let claudeClassifications = 0;
+for (let index = 0; index < routingIterations; index += 1) {
+  if (modelRouter.classify("claude-benchmark-0") === "claude") claudeClassifications += 1;
+}
+const pmModelRouting = {
+  catalog_models: routingCatalog.data.length,
+  iterations: routingIterations,
+  elapsed_ms: +(performance.now() - routingStarted).toFixed(1),
+  claude_classifications: claudeClassifications,
+  availability_rebuilds: modelRouter.diagnostics().rebuilds,
+};
+
 const pixels = deterministicPixels(1024 * 1024 * 3, 0x87654321);
 const webp = await sharp(pixels, { raw: { width: 1024, height: 1024, channels: 3 } })
   .webp({ quality: 100 })
@@ -281,6 +364,7 @@ const report = {
   adapter_import: adapterImport,
   token_count_100kb: tokenCount,
   duplicate_images: duplicateImages,
+  pm_model_routing: pmModelRouting,
   oversized_payload: oversizedPayload,
 };
 
@@ -294,6 +378,7 @@ if (checkMode) {
     largePayloadProbe(30, 1),
     largePayloadProbe(30, 2),
   ];
+  report.visual_history_pressure_36x4 = visualHistoryPressureProbe();
 } else if (process.argv.includes("--large-payload")) {
   report.large_payload_peak = [
     largePayloadProbe(5, 1),
@@ -308,6 +393,10 @@ console.log(JSON.stringify(report, null, 2));
 
 if (checkMode) {
   const failures = [];
+  if (report.pm_model_routing.availability_rebuilds !== 1
+    || report.pm_model_routing.claude_classifications !== report.pm_model_routing.iterations) {
+    failures.push("PM Studio model routing did not reuse the memoized catalog classification");
+  }
   const proxy = report.large_token_count.proxy;
   const array = report.large_token_count.materialized_array;
   if (proxy.tokens !== array.tokens) failures.push(`token counts differ: proxy=${proxy.tokens} array=${array.tokens}`);
@@ -325,6 +414,12 @@ if (checkMode) {
       failures.push(`request admission exceeded its budget at ${payload.target_request_mib}MiB x${payload.concurrency}`);
     }
   }
+  const visualHistory = report.visual_history_pressure_36x4;
+  if (!visualHistory.omitted_images.every((count) => count === 20)
+    || !visualHistory.retained_historical_images.every((count) => count === 16)
+    || !visualHistory.output_body_mib.every((size, index) => size < visualHistory.input_body_mib[index])) {
+    failures.push("36-image x4 visual history pressure did not preserve the expected 16-image upstream window");
+  }
   if (failures.length) {
     for (const failure of failures) console.error(`[FAIL] ${failure}`);
     process.exitCode = 1;

package/src/adapter.mjs

@@ -17,6 +17,7 @@ import { status } from "./status.mjs";
 import { createTerminalActivityIndicator } from "./terminal-activity.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import { createResponsesCompactHandler, createResponsesHandler } from "./responses-handler.mjs";
+import { createResponsesImagePressureController } from "./responses-image-pressure.mjs";
 import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
 import {
   createRequestAdmission,
@@ -138,6 +139,7 @@ export function createAdapterHandler(options = {}) {
   const acquireRequest = options.acquireRequest || createRequestAdmission();
   const requestMetrics = options.requestMetrics || createRequestMetrics();
   const streamPerformanceMetrics = options.streamPerformanceMetrics || createStreamPerformanceMetrics();
+  const imagePressure = options.imagePressure || createResponsesImagePressureController();
   const claudeDesktopModelOptions = () => {
     const modelDefs = claudeModelRegistry?.modelDefs || options.claudeDesktopModelDefs;
     return Array.isArray(modelDefs) ? { modelDefs } : {};
@@ -147,6 +149,7 @@ export function createAdapterHandler(options = {}) {
     autoReviewModelResolver: options.autoReviewModelResolver,
     chatCompletionsFn: codexChatCompletionsFn,
     getCachedModelEndpointsFn,
+    imagePressure,
     openAIModelEnv,
     responsesPayloadOptions: options.responsesPayloadOptions,
     responsesFn,
@@ -157,6 +160,7 @@ export function createAdapterHandler(options = {}) {
   const responsesCompactHandler = createResponsesCompactHandler({
     acquireRequest,
     autoReviewModelResolver: options.autoReviewModelResolver,
+    imagePressure,
     openAIModelEnv,
     responsesCompactFn,
     streamHandshakeTimeoutMs,
@@ -197,6 +201,7 @@ export function createAdapterHandler(options = {}) {
         metrics: requestMetrics,
         streamPerformance: streamPerformanceMetrics,
         admission: acquireRequest,
+        imagePressure,
         modelRegistry: codexModelRegistry,
         codexClient,
         claudeClient,

package/src/auth.mjs

@@ -326,6 +326,7 @@ export async function discoverGithubToken({
   fetchImpl = fetch,
   signal,
   excludeTokens = [],
+  excludeIdentities = [],
   expectedIdentity,
   strictExpectedIdentity = false,
 } = {}) {
@@ -348,6 +349,10 @@ export async function discoverGithubToken({
 
     const validation = await validateGithubToken(token, { fetchImpl, signal });
     if (validation.ok) {
+      if (excludeIdentities.some((identity) => githubIdentityMatchesExpected(validation, identity))) {
+        failures.push({ source, validation, reason: "github_account_excluded" });
+        continue;
+      }
       const candidate = { ok: true, token, source, validation };
       const explicitSource = source.type === "env" || source.type === "token-file";
       if (expectedIdentity && (strictExpectedIdentity || !explicitSource)) {

package/src/cli-auth.mjs

@@ -1,8 +1,10 @@
 import os from "node:os";
 import { spawn } from "node:child_process";
 import {
+  discoverGithubToken,
   fetchGithubIdentity,
   interpretPoll,
+  sourceDescription,
   validateGithubToken,
 } from "./auth.mjs";
 import {
@@ -19,6 +21,7 @@ import {
   normalizeGithubIdentity,
 } from "./github-identity.mjs";
 import { saveModelCache } from "./model-cache.mjs";
+import { profileRouting } from "./profile-routing.mjs";
 import { status } from "./status.mjs";
 
 const CLIENT_ID = "Iv1.b507a08c87ecfe98";
@@ -267,14 +270,45 @@ export async function authorizeClaudeProfile({
       throw new Error(`Claude profile is configured but invalid (${current.reason}); run ccdx auth login claude --reauth`);
     }
 
-    const githubToken = await requestDeviceFlowToken({
-      fetchImpl,
-      signal,
-      log,
-      openAndCopyFn,
-      sleepImpl,
-      now,
-    });
+    let githubToken = "";
+    if (!reauth) {
+      const codex = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
+      if (!codex.valid) {
+        throw new Error("The existing Codex GitHub account is not configured; refusing to create an unbound Claude profile");
+      }
+      const existingCodex = await codexIdentity({ home, fetchImpl, signal });
+      const pinnedLogin = String(expectedLogin || "").trim();
+      const discovered = await discoverGithubToken({
+        home,
+        env,
+        fetchImpl,
+        signal,
+        excludeTokens: [codex.token],
+        excludeIdentities: [existingCodex.identity],
+        expectedIdentity: pinnedLogin ? { login: pinnedLogin } : undefined,
+        strictExpectedIdentity: Boolean(pinnedLogin),
+      });
+      if (discovered.ambiguous) {
+        const accounts = [...new Set(discovered.candidates
+          .map((candidate) => candidate.login || candidate.id || "unknown"))];
+        throw new Error(`Multiple reusable GitHub Copilot accounts were found (${accounts.join(", ")}). Use --github-login or CCDX_GITHUB_TOKEN_PATH to select the Claude account.`);
+      }
+      if (discovered.ok) {
+        githubToken = discovered.token;
+        const login = discovered.validation?.login ? ` for ${discovered.validation.login}` : "";
+        log(status("info", `Reusing a local Copilot credential from ${sourceDescription(discovered.source)}${login}`));
+      }
+    }
+    if (!githubToken) {
+      githubToken = await requestDeviceFlowToken({
+        fetchImpl,
+        signal,
+        log,
+        openAndCopyFn,
+        sleepImpl,
+        now,
+      });
+    }
     const candidate = await validateClaudeCandidate(githubToken, {
       home,
       expectedLogin,
@@ -350,10 +384,7 @@ export function authStatus({ home = os.homedir() } = {}) {
       codex: publicProfile(codex, "legacy"),
       claude: publicProfile(claude, "isolated"),
     },
-    routing: {
-      responses: AUTH_PROFILE_CODEX,
-      messages: claude.configured ? AUTH_PROFILE_CLAUDE : AUTH_PROFILE_CODEX,
-    },
+    routing: profileRouting({ claudeConfigured: claude.configured }),
   };
 }