codex-copilot-dx 0.4.42 → 0.4.44

package/README.md

@@ -23,10 +23,13 @@ Codex Auto-review requests use the hidden `codex-auto-review` model ID. The adap
 ## Usage
 
 ```bash
-npx codex-copilot-dx@latest
+npm install -g codex-copilot-dx@latest
+ccdx
 ```
 
-> Tip: the `@latest` suffix forces `npx` to fetch the newest release instead of using a stale cached copy.
+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`.
 
 On first run, it will:
 1. Authenticate with GitHub via device flow (if needed), after first trying compatible local Copilot token sources
@@ -42,14 +45,14 @@ If an existing `codex-copilot-dx` adapter is already running on the configured h
 
 The running adapter reports its package and protocol versions. After upgrading `codex-copilot-dx`, stop the old process before starting the new version; the new CLI refuses to silently reuse an incompatible adapter.
 
-Do not set Claude Code by manually exporting `ANTHROPIC_BASE_URL` or `ANTHROPIC_AUTH_TOKEN` in your shell. Let `codex-copilot-dx` write the local config files instead. If you previously exported those variables, remove them from shell startup files and restart the terminal before launching Claude Code.
+Do not set Claude Code by manually exporting `ANTHROPIC_BASE_URL` or `ANTHROPIC_AUTH_TOKEN` in your shell. Let `ccdx` write the local config files instead. If you previously exported those variables, remove them from shell startup files and restart the terminal before launching Claude Code.
 
 ### Diagnostics
 
 Run a read-only config check without starting the adapter or changing files:
 
 ```bash
-codex-copilot-dx doctor
+ccdx doctor
 ```
 
 The command exits with status `1` when it finds an invalid configuration and `0` when checks contain only OK or warning results.
@@ -59,7 +62,7 @@ The doctor checks the GitHub token, Codex config, Claude Code settings, Claude A
 For a read-only live check of the saved GitHub token, Copilot entitlement, and models endpoint, run:
 
 ```bash
-codex-copilot-dx doctor --online
+ccdx doctor --online
 ```
 
 The online doctor never starts device flow, scans for replacement tokens, or changes the saved token.
@@ -67,7 +70,7 @@ The online doctor never starts device flow, scans for replacement tokens, or cha
 To actively verify the protocol path through an already-running adapter, run:
 
 ```bash
-codex-copilot-dx doctor --compat
+ccdx doctor --compat
 ```
 
 The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
@@ -78,19 +81,19 @@ For live runtime diagnostics, query the running adapter from the same machine:
 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, latency totals, admission pressure, memory use, response-history size, image queue state, model cache counts, and token expiry state. It never 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 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:
 
 ```bash
-codex-copilot-dx --show-request-id
+ccdx --show-request-id
 ```
 
-When the saved token is missing, `codex-copilot-dx` first looks for compatible local Copilot GitHub tokens, validates them with GitHub and Copilot, and imports a valid one before starting device login. It checks explicit token sources (`CCDX_GITHUB_TOKEN`, `CCDX_GITHUB_TOKEN_PATH`, `CCDX_GITHUB_TOKEN_PATHS`) plus common local `auth.json` layouts under application config directories. It does not rely on a specific app name. Generic discovery refuses to choose silently when valid tokens for multiple GitHub accounts are found. After an account is selected, automatic `401`/`403` recovery and in-process token rotation accept only the same GitHub account. Concurrent callers share token refresh work without sharing cancellation, and a still-valid Copilot token may be used briefly after a transient refresh failure. Explicit token variables remain the intentional way to switch accounts.
+When the saved token is missing, `ccdx` first looks for compatible local Copilot GitHub tokens, validates them with GitHub and Copilot, and imports a valid one before starting device login. It checks explicit token sources (`CCDX_GITHUB_TOKEN`, `CCDX_GITHUB_TOKEN_PATH`, `CCDX_GITHUB_TOKEN_PATHS`) plus common local `auth.json` layouts under application config directories. It does not rely on a specific app name. Generic discovery refuses to choose silently when valid tokens for multiple GitHub accounts are found. After an account is selected, automatic `401`/`403` recovery and in-process token rotation accept only the same GitHub account. Concurrent callers share token refresh work without sharing cancellation, and a still-valid Copilot token may be used briefly after a transient refresh failure. Explicit token variables remain the intentional way to switch accounts.
 
 If Copilot token refresh still fails with `401` or `403`, the saved GitHub token may be expired, revoked, or missing Copilot access. Delete the saved token and start the tool again to trigger GitHub device login:
 
 ```bash
 rm ~/.local/share/copilot-api/github_token
-codex-copilot-dx
+ccdx
 ```
 
 ### Claude App opt-in
@@ -125,7 +128,7 @@ Environment variables:
 | `CCDX_MAX_INFLIGHT_BODY_BYTES` | `33554432` | Shared byte budget for admitted request bodies; a larger single request runs exclusively |
 | `CCDX_MAX_QUEUED_REQUESTS` | `16` | Maximum body requests waiting for the shared byte budget |
 | `CCDX_REQUEST_QUEUE_TIMEOUT_MS` | `120000` | Maximum wait for request-body admission before returning `503` |
-| `CCDX_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Responses body target; larger image payloads are compressed more aggressively before forwarding |
+| `CCDX_MAX_UPSTREAM_BODY_BYTES` | `31457280` | Strict maximum forwarded Responses body size; larger payloads are adapted locally or rejected with `413` |
 | `CCDX_MAX_SSE_BUFFER_BYTES` | `8388608` | Maximum buffered bytes for one unterminated upstream SSE line/event |
 | `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Timeout for non-streaming upstream Copilot requests |
 | `CCDX_STREAM_HANDSHAKE_TIMEOUT_MS` | `120000` | Timeout while waiting for upstream streaming response headers |
@@ -137,10 +140,11 @@ Environment variables:
 | `CCDX_LOG_LEVEL` | `info` | Set to `debug` to include upstream request attempts, status codes, retry causes, and timings |
 | `CCDX_LOG_MAX_BYTES` | `16777216` | Rotate the debug log at this size, retaining one `.1` backup; set to `0` to disable rotation |
 | `CCDX_IMG_MAX_DIM` | `2048` | Max long edge in pixels for image downscaling |
-| `CCDX_IMG_QUALITY` | `85` | WebP quality used when re-encoding images |
-| `CCDX_IMG_MIN_BYTES` | `100000` | Images smaller than this are left untouched |
+| `CCDX_IMG_QUALITY` | `82` | Initial WebP quality used when re-encoding images |
+| `CCDX_IMG_MIN_BYTES` | `100000` | In-bounds images smaller than this are left untouched; oversized images are still downscaled |
 | `CCDX_IMG_CONCURRENCY` | `2` | Global concurrent image optimization tasks; values above `12` are capped at `12` |
 | `CCDX_IMG_MAX_INPUT_PIXELS` | `40000000` | Maximum decoded pixels accepted by `sharp` for one image |
+| `CCDX_IMG_CACHE_MAX_BYTES` | `67108864` | Process-local byte ceiling for cached image optimization results; set to `0` to disable result caching |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
 | `CCDX_CONFIGURE_CLAUDE_DESKTOP` | unset | Set to `1` to write the Claude App 3P gateway profile during startup |
 | `CCDX_CLAUDE_DESKTOP_API_KEY` | managed profile or generated for opt-in setup | Explicit bearer key written into the Claude App profile and recognized by the adapter for model discovery |
@@ -170,17 +174,25 @@ The adapter records token usage metadata to `~/.local/share/codex-copilot-dx/usa
 Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-dx/debug.log`, or set `CCDX_LOG_PATH` to a custom file. Add `CCDX_LOG_LEVEL=debug` to include upstream request attempts, retry causes, status codes, and timings. Debug logs do not include prompts, completions, request bodies, or authorization tokens.
 
 ```bash
-codex-copilot-dx usage
+ccdx usage
 ```
 
 ### 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 `413 Payload Too Large`.
+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`.
 
-The adapter automatically downsamples embedded screenshots to long-edge <= 2048 px and re-encodes them as WebP before forwarding `/v1/responses`. It keeps an existing in-bounds WebP unchanged, never replaces an image with a larger encoding, and applies one global concurrency limit across direct and tool-output images.
+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.
+
+The final serialized UTF-8 request body is measured before forwarding. Above the configured byte limit, unique source images are processed largest-first from their originals at quality 75 / 1600 px and then quality 65 / 1280 px, stopping as soon as the body fits. If necessary, the forwarded view omits older duplicate images, historical tool images, other historical images, and finally old tool outputs while preserving current input and tool-call skeletons. A request that still cannot fit is rejected locally with a structured `413` instead of sending an oversized body upstream.
+
+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.
 
 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.
+
+Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
+
 Newer ChatGPT/Codex clients can advertise an `image_gen` namespace that already exists upstream. The adapter removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image inputs and screenshot optimization remain enabled.
 
 ## License

package/bin/cli.mjs

@@ -27,7 +27,7 @@ try {
   CLI = parseCliArgs(process.argv.slice(2));
 } catch (e) {
   console.error(e.message);
-  console.error("Run codex-copilot-dx --help for usage.");
+  console.error("Run ccdx --help for usage.");
   process.exit(2);
 }
 
@@ -107,7 +107,7 @@ async function refreshClaudeDesktopModelDefs() {
     const models = JSON.parse(body);
     const autoReview = codexAutoReviewModelStatus(models);
     if (!autoReview.available) {
-      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run codex-copilot-dx doctor --compat to verify the live path.`));
+      console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run ccdx doctor --compat to verify the live path.`));
     }
     const gptModelIds = gptModelIdsFromCopilotModels(models);
     if (gptModelIds.length) {
@@ -169,7 +169,7 @@ async function reuseRunningAdapterIfAvailable() {
   });
   if (running.incompatible) {
     const found = running.data?.version || "unknown";
-    throw new Error(`Adapter ${found} is already running at ${running.baseUrl}, but this CLI is ${LOCAL_VERSION}. Stop the existing process and run codex-copilot-dx again.`);
+    throw new Error(`Adapter ${found} is already running at ${running.baseUrl}, but this CLI is ${LOCAL_VERSION}. Stop the existing process and run ccdx again.`);
   }
   if (!running.ok) return false;
 
@@ -197,7 +197,7 @@ async function reuseRunningAdapterIfAvailable() {
 
   await openCodex();
   console.log(`
-  ${status("ok", "Ready, using the existing codex-copilot-dx adapter")}
+  ${status("ok", "Ready, using the existing ccdx adapter")}
 
   Adapter: ${running.baseUrl}
 `);

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.42",
+  "version": "0.4.44",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
   "bin": {
+    "ccdx": "bin/cli.mjs",
     "codex-copilot-dx": "bin/cli.mjs"
   },
   "files": [

package/src/adapter.mjs

@@ -11,6 +11,7 @@ import {
   runtimeStatusPayload,
 } from "./observability.mjs";
 import { createRequestId, runWithRequestContext } from "./request-context.mjs";
+import { createStreamPerformanceMetrics } from "./stream-performance.mjs";
 import { status } from "./status.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 import { createResponsesCompactHandler, createResponsesHandler } from "./responses-handler.mjs";
@@ -98,6 +99,7 @@ export function createAdapterHandler(options = {}) {
   const streamIdleTimeoutMs = parsePositiveInteger(options.streamIdleTimeoutMs, ADAPTER_RUNTIME_CONFIG.streamIdleTimeoutMs);
   const acquireRequest = options.acquireRequest || createRequestAdmission();
   const requestMetrics = options.requestMetrics || createRequestMetrics();
+  const streamPerformanceMetrics = options.streamPerformanceMetrics || createStreamPerformanceMetrics();
   const claudeDesktopModelOptions = () => {
     const modelDefs = options.modelRegistry?.modelDefs || options.claudeDesktopModelDefs;
     return Array.isArray(modelDefs) ? { modelDefs } : {};
@@ -106,6 +108,7 @@ export function createAdapterHandler(options = {}) {
     acquireRequest,
     chatCompletionsFn,
     openAIModelEnv,
+    responsesPayloadOptions: options.responsesPayloadOptions,
     responsesFn,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
@@ -140,6 +143,7 @@ export function createAdapterHandler(options = {}) {
       res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
       res.end(JSON.stringify(runtimeStatusPayload({
         metrics: requestMetrics,
+        streamPerformance: streamPerformanceMetrics,
         admission: acquireRequest,
         modelRegistry: options.modelRegistry,
       })));
@@ -223,12 +227,16 @@ export function createAdapterHandler(options = {}) {
     }
 
     const trackRequest = pathname !== ADAPTER_HEALTH_PATH && pathname !== ADAPTER_STATUS_PATH;
-    const complete = trackRequest
-      ? requestMetrics.begin(classifyAdapterRoute(req.method, pathname))
-      : () => {};
+    const routeName = classifyAdapterRoute(req.method, pathname);
+    const complete = trackRequest ? requestMetrics.begin(routeName) : () => {};
+    const streamPerformance = trackRequest ? streamPerformanceMetrics.begin(routeName) : null;
+    const finishRequest = ({ statusCode = 0, aborted = false } = {}) => {
+      complete({ statusCode, aborted });
+      streamPerformance?.finish({ failed: aborted || statusCode >= 400 });
+    };
     if (trackRequest && typeof res.once === "function") {
-      res.once("finish", () => complete({ statusCode: res.statusCode }));
-      res.once("close", () => complete({
+      res.once("finish", () => finishRequest({ statusCode: res.statusCode }));
+      res.once("close", () => finishRequest({
         statusCode: res.statusCode,
         aborted: !res.writableFinished && !res.writableEnded,
       }));
@@ -239,16 +247,17 @@ export function createAdapterHandler(options = {}) {
         requestId,
         pathname,
         showRequestId: options.showRequestId === true,
+        streamPerformance,
       }, () => dispatch(req, res, pathname));
       if (result && typeof result.then === "function") {
         return result.catch((error) => {
-          complete({ statusCode: res.statusCode >= 400 ? res.statusCode : 500 });
+          finishRequest({ statusCode: res.statusCode >= 400 ? res.statusCode : 500 });
           throw error;
         });
       }
       return result;
     } catch (error) {
-      complete({ statusCode: res.statusCode >= 400 ? res.statusCode : 500 });
+      finishRequest({ statusCode: res.statusCode >= 400 ? res.statusCode : 500 });
       throw error;
     }
   };
@@ -272,7 +281,7 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
   return new Promise((resolve, reject) => {
     const onListenError = (e) => {
       if (e?.code === "EADDRINUSE") {
-        reject(new Error(`Adapter address http://${host}:${port} is already in use. Stop the existing codex-copilot-dx process or set ADAPTER_PORT to another port.`));
+        reject(new Error(`Adapter address http://${host}:${port} is already in use. Stop the existing ccdx process or set ADAPTER_PORT to another port.`));
         return;
       }
       reject(e);

package/src/anthropic-handler.mjs

@@ -16,6 +16,8 @@ import { resolveAnthropicModel } from "./models.mjs";
 import { status } from "./status.mjs";
 import { webStreamLines } from "./stream.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
+import { requireUpstreamEventStream, withChatStreamUsage } from "./stream-contract.mjs";
+import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordAnthropicUsage } from "./usage.mjs";
 
 export function createAnthropicCountTokensHandler(options) {
@@ -67,15 +69,19 @@ export function createAnthropicMessagesHandler(options) {
       const chatReq = anthropicToChat(parsed, { upstreamModel });
       const forceRequestedModel = upstreamModel !== requestedModel;
       if (parsed.stream) {
-        const upstream = await chatCompletionsFn({ ...chatReq, stream: true }, { signal: abort.signal });
+        const upstream = await chatCompletionsFn(withChatStreamUsage(chatReq), { signal: abort.signal });
         releaseRequest();
         if (!upstream.ok) {
-          if (!res.headersSent) res.writeHead(upstream.status);
-          res.end(await upstream.text());
+          sendUpstreamError(res, upstream, await upstream.text());
           return;
         }
+        await requireUpstreamEventStream(upstream);
         abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
-        res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+        res.writeHead(200, {
+          ...safeUpstreamResponseHeaders(upstream.headers, { contentType: "text/event-stream" }),
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+        });
         let messageId;
         let usage;
         try {
@@ -114,7 +120,9 @@ export function createAnthropicMessagesHandler(options) {
           responseId: anthropicMessage.id,
           usage: anthropicMessage.usage,
         });
-        res.writeHead(200, { "Content-Type": "application/json" });
+        res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
+          contentType: "application/json",
+        }));
         res.end(JSON.stringify(anthropicMessage));
       }
     } catch (error) {

package/src/anthropic.mjs

@@ -1,4 +1,11 @@
 import { randomUUID } from "node:crypto";
+import {
+  incompleteUpstreamStream,
+  invalidUpstreamStream,
+  ToolArgumentDeltaGuard,
+  upstreamChatStreamError,
+} from "./stream-contract.mjs";
+import { isChatOutputDelta, markFirstOutput, markOutputTokens } from "./stream-performance.mjs";
 
 let tokenizerModulePromise = null;
 
@@ -169,6 +176,14 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   let sawToolUse = false;
   const trailingTextChunks = [];
   let outputTokens = 0;
+  let sawDone = false;
+  const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  let performanceOutputSeen = false;
+  const markPerformanceOutput = () => {
+    if (performanceOutputSeen) return;
+    performanceOutputSeen = true;
+    markFirstOutput();
+  };
 
   const ensureStart = async () => {
     if (started) return;
@@ -196,14 +211,30 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   for await (const line of lineIterator) {
     if (!line.startsWith("data: ")) continue;
     const data = line.slice(6).trim();
-    if (data === "[DONE]") break;
+    if (data === "[DONE]") {
+      sawDone = true;
+      break;
+    }
     let parsed;
-    try { parsed = JSON.parse(data); } catch { continue; }
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      throw invalidUpstreamStream(
+        "Upstream Chat Completions SSE event contained invalid JSON",
+        "upstream_stream_json_invalid",
+      );
+    }
+    const upstreamError = upstreamChatStreamError(parsed);
+    if (upstreamError) throw upstreamError;
     if (!options.forceModel && parsed.model) actualModel = parsed.model;
-    if (parsed.usage?.completion_tokens != null) outputTokens = parsed.usage.completion_tokens;
+    if (parsed.usage?.completion_tokens != null) {
+      outputTokens = parsed.usage.completion_tokens;
+      markOutputTokens(outputTokens);
+    }
     const choice = parsed.choices?.[0];
     if (!choice) continue;
     const delta = choice.delta || {};
+    if (isChatOutputDelta(delta)) markPerformanceOutput();
     await ensureStart();
 
     if (delta.content) {
@@ -227,9 +258,11 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
           await emit("content_block_start", { type: "content_block_start", index: blockIndex,
             content_block: { type: "tool_use", id: tc.id || `tu_${uid()}`, name: tc.function?.name || "", input: {} } });
         }
-        if (tc.function?.arguments) {
+        const argumentDelta = tc.function?.arguments;
+        toolArgumentGuard.observe(oi, argumentDelta);
+        if (argumentDelta) {
           await emit("content_block_delta", { type: "content_block_delta", index: toolBlocks[oi].anthropicIndex,
-            delta: { type: "input_json_delta", partial_json: tc.function.arguments } });
+            delta: { type: "input_json_delta", partial_json: argumentDelta } });
         }
       }
     }
@@ -237,6 +270,8 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
     if (choice.finish_reason) finishReason = choice.finish_reason;
   }
 
+  if (!sawDone) throw incompleteUpstreamStream("[DONE]");
+
   await ensureStart();
   if (textOpen) await closeText();
   for (const oi of Object.keys(toolBlocks)) {

package/src/auth.mjs

@@ -33,9 +33,9 @@ export function githubTokenMetadataPath(home = os.homedir()) {
 export function githubReauthMessage(reason, home = os.homedir()) {
   const tokenPath = githubTokenPath(home);
   return `${reason}
-Delete the saved GitHub token, then run codex-copilot-dx again to log in:
+Delete the saved GitHub token, then run ccdx again to log in:
   rm '${tokenPath}'
-  codex-copilot-dx`;
+  ccdx`;
 }
 
 // Map GitHub polling responses to a small local state machine.

package/src/bounded-result-cache.mjs

@@ -0,0 +1,180 @@
+function byteLength(value) {
+  return Buffer.byteLength(String(value));
+}
+
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortError(signal);
+}
+
+export function createByteLruCache({ maxBytes }) {
+  const limit = Math.max(0, Number.parseInt(maxBytes, 10) || 0);
+  const entries = new Map();
+  let bytes = 0;
+  let hits = 0;
+  let misses = 0;
+  let evictions = 0;
+
+  const remove = (key) => {
+    const entry = entries.get(key);
+    if (!entry) return false;
+    entries.delete(key);
+    bytes -= entry.bytes;
+    return true;
+  };
+
+  return {
+    get(key) {
+      const entry = entries.get(key);
+      if (!entry) {
+        misses += 1;
+        return undefined;
+      }
+      hits += 1;
+      entries.delete(key);
+      entries.set(key, entry);
+      return entry.value;
+    },
+    set(key, value) {
+      if (typeof key !== "string" || typeof value !== "string") return false;
+      const entry = { value, bytes: byteLength(key) + byteLength(value) };
+      if (entry.bytes > limit) return false;
+      remove(key);
+      entries.set(key, entry);
+      bytes += entry.bytes;
+      while (bytes > limit && entries.size) {
+        remove(entries.keys().next().value);
+        evictions += 1;
+      }
+      return entries.has(key);
+    },
+    clear() {
+      entries.clear();
+      bytes = 0;
+      hits = 0;
+      misses = 0;
+      evictions = 0;
+    },
+    stats() {
+      return {
+        entries: entries.size,
+        bytes,
+        max_bytes: limit,
+        hits,
+        misses,
+        evictions,
+      };
+    },
+  };
+}
+
+export function createAbortAwareSingleflight() {
+  const flights = new Map();
+
+  const createFlight = (key, task) => {
+    const controller = new AbortController();
+    const flight = {
+      controller,
+      settled: false,
+      waiters: 0,
+      promise: null,
+    };
+    flight.promise = Promise.resolve()
+      .then(() => task(controller.signal))
+      .finally(() => {
+        flight.settled = true;
+        if (flights.get(key) === flight) flights.delete(key);
+      });
+    // The shared task can outlive every cancelled waiter. Keep its eventual
+    // rejection observed even when no caller remains to await it.
+    flight.promise.catch(() => {});
+    flights.set(key, flight);
+    return flight;
+  };
+
+  const waitForFlight = (key, flight, signal) => new Promise((resolve, reject) => {
+    let done = false;
+    flight.waiters += 1;
+
+    const finish = () => {
+      if (done) return false;
+      done = true;
+      signal?.removeEventListener("abort", onAbort);
+      flight.waiters -= 1;
+      if (flight.waiters === 0 && !flight.settled) {
+        if (flights.get(key) === flight) flights.delete(key);
+        flight.controller.abort(abortError());
+      }
+      return true;
+    };
+    const onAbort = () => {
+      if (!finish()) return;
+      reject(abortError(signal));
+    };
+
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    flight.promise.then(
+      (value) => {
+        if (!finish()) return;
+        resolve(value);
+      },
+      (error) => {
+        if (!finish()) return;
+        reject(error);
+      },
+    );
+  });
+
+  return {
+    run(key, task, { signal } = {}) {
+      try {
+        throwIfAborted(signal);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      const flight = flights.get(key) || createFlight(key, task);
+      return waitForFlight(key, flight, signal);
+    },
+    stats() {
+      return { inflight: flights.size };
+    },
+  };
+}
+
+export function createBoundedResultCache({ maxBytes }) {
+  const cache = createByteLruCache({ maxBytes });
+  const singleflight = createAbortAwareSingleflight();
+
+  return {
+    async getOrCreate(key, createValue, { signal } = {}) {
+      throwIfAborted(signal);
+      const cached = cache.get(key);
+      if (cached !== undefined) return cached;
+      return singleflight.run(key, async (sharedSignal) => {
+        const value = await createValue(sharedSignal);
+        throwIfAborted(sharedSignal);
+        if (typeof value === "string") cache.set(key, value);
+        return value;
+      }, { signal });
+    },
+    set(key, value) {
+      return cache.set(key, value);
+    },
+    clear() {
+      cache.clear();
+    },
+    stats() {
+      return { ...cache.stats(), ...singleflight.stats() };
+    },
+  };
+}

package/src/claude-config.mjs

@@ -41,7 +41,7 @@ export function ensureClaudeConfig(port = 2026, { filePath = SETTINGS_PATH, host
     settings = JSON.parse(raw);
   } catch (e) {
     console.log(status("warn", `Could not parse ~/.claude/settings.json: ${e.message}`));
-    console.log(status("info", "Fix the JSON file and rerun codex-copilot-dx to configure Claude Code automatically."));
+    console.log(status("info", "Fix the JSON file and rerun ccdx to configure Claude Code automatically."));
     return;
   }
 

package/src/cli-options.mjs

@@ -82,9 +82,11 @@ export function parseRuntimeOptions(env = process.env) {
 
 export function cliHelp() {
   return `Usage:
-  codex-copilot-dx [--configure-claude-desktop] [--show-request-id]
-  codex-copilot-dx doctor [--online] [--compat]
-  codex-copilot-dx usage
-  codex-copilot-dx --version
-  codex-copilot-dx --help`;
+  ccdx [--configure-claude-desktop] [--show-request-id]
+  ccdx doctor [--online] [--compat]
+  ccdx usage
+  ccdx --version
+  ccdx --help
+
+Compatibility alias: codex-copilot-dx`;
 }