codex-copilot-dx 0.4.43 → 0.5.0

package/README.md

@@ -23,10 +23,15 @@ 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`.
+Both installed commands expose the same options and subcommands; help, version,
+doctor, status, and argument-error output use the command name that was invoked.
 
 On first run, it will:
 1. Authenticate with GitHub via device flow (if needed), after first trying compatible local Copilot token sources
@@ -42,14 +47,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 +64,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,30 +72,38 @@ 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.
 
-For live runtime diagnostics, query the running adapter from the same machine:
+For a read-only summary of the running adapter, use:
+
+```bash
+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:
 
 ```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, 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
@@ -141,6 +154,7 @@ Environment variables:
 | `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,7 +184,7 @@ 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
@@ -181,9 +195,13 @@ The adapter automatically downsamples embedded screenshots to model-appropriate
 
 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.
 
-After a successful `/v1/responses/compact` result containing a compaction item, the compact output becomes a new local history root. Later turns continue from that snapshot without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
+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.
 

package/bin/cli.mjs

@@ -16,23 +16,25 @@ import { adapterBaseUrl, checkRunningAdapter } from "../src/running-adapter.mjs"
 import { assertSafeAdapterHost, isLoopbackHost } from "../src/security.mjs";
 import { isValidModelList, loadModelCache, saveModelCache } from "../src/model-cache.mjs";
 import { initializeModelRegistry, runInBackground } from "../src/startup.mjs";
-import { cliHelp, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
+import { cliCommandName, cliHelp, parseAdapterProbeOptions, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
+import { formatAdapterStatus, readAdapterStatus } from "../src/cli-status.mjs";
 import { closeHttpServer } from "../src/shutdown.mjs";
 
 const LOCAL_VERSION = localPackageVersion();
-const CLI_BANNER = `codex-copilot-dx v${LOCAL_VERSION} by Dale Xiao`;
+const CLI_NAME = cliCommandName();
+const CLI_BANNER = `${CLI_NAME} v${LOCAL_VERSION} by Dale Xiao`;
 
 let CLI;
 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 ${CLI_NAME} --help for usage.`);
   process.exit(2);
 }
 
 if (CLI.command === "help") {
-  console.log(cliHelp());
+  console.log(cliHelp(CLI_NAME));
   process.exit(0);
 }
 if (CLI.command === "version") {
@@ -43,6 +45,27 @@ if (CLI.command === "usage") {
   await printUsageSummary();
   process.exit(0);
 }
+if (CLI.command === "status") {
+  let probe;
+  try {
+    probe = parseAdapterProbeOptions(process.env);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(2);
+  }
+  try {
+    const snapshot = await readAdapterStatus({
+      host: probe.adapterHost,
+      port: probe.adapterPort,
+      timeoutMs: probe.existingAdapterTimeoutMs,
+    });
+    console.log(formatAdapterStatus(snapshot, { commandName: CLI_NAME, cliVersion: LOCAL_VERSION }));
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
 
 let RUNTIME;
 try {
@@ -107,7 +130,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 ${CLI_NAME} doctor --compat to verify the live path.`));
     }
     const gptModelIds = gptModelIdsFromCopilotModels(models);
     if (gptModelIds.length) {
@@ -169,7 +192,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 ${CLI_NAME} again.`);
   }
   if (!running.ok) return false;
 
@@ -197,7 +220,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}
 `);
@@ -206,6 +229,7 @@ async function reuseRunningAdapterIfAvailable() {
 
 if (CLI.command === "doctor") {
   const checks = await runDoctor({
+    commandName: CLI_NAME,
     port: ADAPTER_PORT,
     host: ADAPTER_HOST,
     online: CLI.online,

package/bin/codex-copilot-dx.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./cli.mjs";

package/package.json

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

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 } : {};
@@ -141,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,
       })));
@@ -224,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,
       }));
@@ -240,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;
     }
   };
@@ -273,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;
   }