codex-copilot-dx 0.8.3 → 0.8.5

package/src/cli-options.mjs

@@ -20,6 +20,7 @@ const HELP_TOPICS = new Set([
   "status",
   "models",
   "usage",
+  "cache",
   "animation",
   "enable-image",
   "disable-image",
@@ -155,6 +156,37 @@ export function parseCliArgs(args = []) {
     const options = parseOptions(rest, new Map([["--format", "value"]]));
     return baseCommand("usage", outputFormatOption(options["--format"]));
   }
+  if (command === "cache") {
+    let cacheArgs = rest;
+    if (rest.length === 1 && /^-\d+$/.test(rest[0])) {
+      cacheArgs = ["--limit", rest[0].slice(1)];
+    } else if (rest[0] === "-clean") {
+      cacheArgs = ["--clean", ...rest.slice(1)];
+    }
+    const options = parseOptions(cacheArgs, new Map([
+      ["--limit", "value"],
+      ["--clean", "flag"],
+      ["--history", "flag"],
+      ["--yes", "flag"],
+    ]));
+    if (options["--limit"] && options["--clean"]) {
+      throw new Error("Use --limit or --clean in one cache command, not both");
+    }
+    if ((options["--history"] || options["--yes"]) && !options["--clean"]) {
+      throw new Error("--history and --yes require --clean");
+    }
+    const rawLimit = options["--limit"];
+    if (rawLimit && rawLimit !== "default" && !/^\d+$/.test(rawLimit)) {
+      throw new Error(`Cache limit must be an integer MiB value or default: ${rawLimit}`);
+    }
+    return baseCommand("cache", {
+      action: rawLimit ? "limit" : options["--clean"] ? "clean" : "status",
+      limitMib: rawLimit && rawLimit !== "default" ? Number(rawLimit) : undefined,
+      resetLimit: rawLimit === "default",
+      history: Boolean(options["--history"]),
+      yes: Boolean(options["--yes"]),
+    });
+  }
   if (PM_COMMANDS.has(command)) {
     return baseCommand("retired", { integration: "PM Studio" });
   }
@@ -301,8 +333,9 @@ function topicHelp(name, topic) {
     status: `Usage:\n  ${name} status\n\nShows bounded runtime, routing, performance, queue, and cache metrics from a running adapter.`,
     models: `Usage:\n  ${name} models [--format table|plain]\n\nPerforms a fresh, read-only Copilot model-directory lookup for the saved account. Interactive terminals use a table by default.`,
     usage: `Usage:\n  ${name} usage [--format table|plain]\n\nSummarizes local token usage metadata without reading prompt or completion content. Interactive terminals use a table by default.`,
+    cache: `Usage:\n  ${name} cache\n  ${name} cache --limit <MiB|default>\n  ${name} cache --clean [--history] [--yes]\n\nShows runtime cache use, saves and applies the shared response-history limit, or clears the rebuildable image-transform cache. --history also clears in-memory response history for all tasks and can make their next continuation fail, so interactive confirmation or --yes is required. Generated image files and saved Codex transcripts are never deleted. Short aliases: -128 sets 128 MiB and -clean equals --clean.`,
     animation: `Usage:\n  ${name} animation\n\nPreviews all terminal activity animations together and selects the theme used the next time the adapter starts.`,
-    "enable-image": `Usage:\n  ${name} enable-image\n\nInteractively configures an HTTPS image API endpoint (base URLs are also accepted) and API key, detects its supported image model and protocol, installs CCDX image guidance, and checks the local image tool for Codex App without generating an image.`,
+    "enable-image": `Usage:\n  ${name} enable-image\n\nInteractively configures an HTTPS image API endpoint (base URLs are also accepted) and API key, detects its supported image model and protocol, installs CCDX image guidance, and checks the local image tool for Codex App without generating an image. A blank key preserves the saved key only for the same origin; a new origin requires explicit key entry. Concurrent unrelated config edits are preserved.`,
     "disable-image": `Usage:\n  ${name} disable-image\n\nDisables the local CCDX image tool and removes its stored API credential and unmodified CCDX image guidance.`,
     "image-status": `Usage:\n  ${name} image-status\n\nShows provider configuration and probes local image-tool readiness without generating an image or exposing its API key.`,
     "auto-review-model": `Usage:\n  ${name} auto-review-model\n\nInteractively selects an advertised Responses model for Codex Auto-review.`,
@@ -324,6 +357,7 @@ export function cliHelp(commandName = "ccdx", topic = "") {
   ${name} status
   ${name} models [--format table|plain]
   ${name} usage [--format table|plain]
+  ${name} cache [--limit <MiB|default> | --clean [--history] [--yes]]
   ${name} animation
   ${name} enable-image
   ${name} disable-image
@@ -340,6 +374,7 @@ Commands:
   status             Show runtime routing, performance, queue, and cache health
   models             Query a saved account's live Copilot model catalog
   usage              Summarize locally recorded token usage
+  cache              Inspect, size, or clear bounded runtime caches
   animation          Select the terminal activity animation
   enable-image       Configure and enable the optional image provider
   disable-image      Disable the image provider and remove its credential

package/src/cli-status.mjs

@@ -158,6 +158,17 @@ export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", c
   if (imageHistory && typeof imageHistory === "object") {
     lines.push(status("info", `Visual history: ${count(imageHistory.active_recovery_trees)} recovery trees, ${count(imageHistory.adapted_requests)} adapted requests, ${count(imageHistory.historical_images_omitted)} older images omitted, ${count(imageHistory.timeouts_recorded)} timeouts`));
   }
+  if (data.image_generation) {
+    const generation = data.image_generation;
+    lines.push(status("info", `Image generation: ${count(generation.active)} active, ${count(generation.succeeded)} succeeded, ${count(generation.failed)} failed (${count(generation.busy)} busy), ${count(generation.cancelled)} cancelled, ${count(generation.delivery_failures)} delivery failures`));
+  }
+  if (data.logging) {
+    for (const [name, logging] of Object.entries(data.logging)) {
+      if (logging?.enabled === false) continue;
+      lines.push(status(logging.dropped_records || logging.write_failures ? "warn" : "info",
+        `${name === "usage" ? "Usage" : "Debug"} logging: ${count(logging.pending_records)} pending (${mebibytes(logging.pending_bytes)}), ${count(logging.dropped_records)} dropped, ${count(logging.write_failures)} write failures`));
+    }
+  }
   if (responseFailures && typeof responseFailures === "object") {
     lines.push(status("info", `Response failures: ${count(responseFailures.total)} observed, ${count(responseFailures.retried)} compatibility retries`));
     for (const failure of Array.isArray(responseFailures.recent) ? responseFailures.recent.slice(-3).reverse() : []) {

package/src/codex-model-catalog.mjs

@@ -4,6 +4,30 @@ import os from "node:os";
 import path from "node:path";
 import { CODEX_GPT6_MODEL } from "./models.mjs";
 
+// Compatibility metadata is derived from OpenAI Codex's public models catalog
+// at commit 0a2eb4696c26ac33204bcd255721ab30220a4774. The installed client's
+// GPT-6 Astra entry supplies its own schema and instructions; these overrides
+// describe only the two new model identities and capability differences.
+const GPT6_COMPATIBILITY_SPECS = new Map([
+  ["gpt-6-sol", Object.freeze({
+    display_name: "GPT-6-Sol",
+    description: "Workhorse model for coding and everyday work.",
+    default_reasoning_level: "medium",
+    shell_type: "shell_command",
+    priority: 2,
+    node_repl_auto_review_required: true,
+  })],
+  ["gpt-6-luna", Object.freeze({
+    display_name: "GPT-6-Luna",
+    description: "Fast and affordable model for easier tasks.",
+    default_reasoning_level: "medium",
+    shell_type: "shell_command",
+    priority: 3,
+    node_repl_auto_review_required: false,
+  })],
+]);
+const MANAGED_GPT6_MODELS = new Set([CODEX_GPT6_MODEL, ...GPT6_COMPATIBILITY_SPECS.keys()]);
+
 export { CODEX_GPT6_MODEL };
 
 export const CODEX_APP_BINARY_PATHS = [
@@ -50,29 +74,81 @@ function isEligibleOpenAIModel(model, id) {
     && supportsResponses(model);
 }
 
-export function isEligibleCopilotGpt6(copilotModels) {
+export function isEligibleCopilotGpt6(copilotModels, id = CODEX_GPT6_MODEL) {
   const data = copilotModelData(copilotModels);
   if (!data) return false;
-  const matches = data.filter((model) => String(model?.id || "").trim() === CODEX_GPT6_MODEL);
-  return matches.length === 1 && isEligibleOpenAIModel(matches[0], CODEX_GPT6_MODEL);
+  const matches = data.filter((model) => String(model?.id || "").trim() === id);
+  return matches.length === 1 && isEligibleOpenAIModel(matches[0], id);
+}
+
+function copilotModel(copilotModels, id) {
+  return copilotModelData(copilotModels)?.find((model) => String(model?.id || "").trim() === id);
+}
+
+function advertisedReasoningEfforts(model) {
+  const values = model?.capabilities?.supports?.reasoning_effort;
+  return new Set(Array.isArray(values) ? values.map((value) => String(value)) : []);
+}
+
+function catalogModelForCopilot(model, copilotModels, { filterReasoning = false } = {}) {
+  const upstream = copilotModel(copilotModels, model.slug);
+  const reasoning = advertisedReasoningEfforts(upstream);
+  const patched = {
+    ...structuredClone(model),
+    visibility: "list",
+    supported_reasoning_levels: filterReasoning && reasoning.size
+      ? model.supported_reasoning_levels.filter(({ effort }) => reasoning.has(effort))
+      : model.supported_reasoning_levels,
+  };
+  // The Codex catalog describes ChatGPT service tiers. Copilot must advertise
+  // an exact fast model before CCDX exposes the corresponding selector.
+  if (!isEligibleCopilotGpt6(copilotModels, `${model.slug}-fast`)) {
+    patched.additional_speed_tiers = [];
+    patched.service_tiers = [];
+    delete patched.default_service_tier;
+  }
+  return patched;
+}
+
+function compatibilityModel(codexCatalog, slug) {
+  const astra = codexCatalog.models.find((model) => model.slug === CODEX_GPT6_MODEL);
+  const spec = GPT6_COMPATIBILITY_SPECS.get(slug);
+  if (!astra || !spec) return null;
+  return {
+    ...structuredClone(astra),
+    ...spec,
+    slug,
+    supports_parallel_tool_calls: true,
+    multi_agent_reasoning_effort: null,
+    supports_experimental_context: false,
+    minimal_client_version: "0.155.0",
+  };
+}
+
+function insertByPriority(models, model) {
+  const priority = Number(model.priority);
+  const index = models.findIndex((candidate) => Number.isFinite(priority)
+    && Number.isFinite(Number(candidate.priority))
+    && Number(candidate.priority) > priority);
+  if (index < 0) models.push(model);
+  else models.splice(index, 0, model);
 }
 
 export function buildCodexModelResponse({ copilotModels, codexCatalog } = {}) {
   if (!copilotModelData(copilotModels) || !codexCatalogIsValid(codexCatalog)) return null;
 
-  const exposeGpt6 = isEligibleCopilotGpt6(copilotModels);
+  const bundledSlugs = new Set(codexCatalog.models.map(({ slug }) => slug));
   const models = codexCatalog.models.map((model) => {
-    if (model.slug !== CODEX_GPT6_MODEL) return model;
-    if (!exposeGpt6) return { ...model, visibility: "hide" };
-    const patched = {
-      ...model,
-      visibility: "list",
-      additional_speed_tiers: [],
-      service_tiers: [],
-    };
-    delete patched.default_service_tier;
-    return patched;
+    if (!MANAGED_GPT6_MODELS.has(model.slug)) return model;
+    if (!isEligibleCopilotGpt6(copilotModels, model.slug)) return { ...model, visibility: "hide" };
+    return catalogModelForCopilot(model, copilotModels);
   });
+  for (const slug of GPT6_COMPATIBILITY_SPECS.keys()) {
+    if (bundledSlugs.has(slug) || !isEligibleCopilotGpt6(copilotModels, slug)) continue;
+    const model = compatibilityModel(codexCatalog, slug);
+    if (!model) continue;
+    insertByPriority(models, catalogModelForCopilot(model, copilotModels, { filterReasoning: true }));
+  }
 
   return { ...copilotModels, object: copilotModels.object || "list", models };
 }

package/src/diagnostic-text.mjs

@@ -0,0 +1,11 @@
+// Diagnostics are not a copy of the upstream payload. Keep useful error text,
+// but remove common credential forms and explicitly labelled content echoes.
+export function redactDiagnosticText(value) {
+  return String(value ?? "")
+    .replace(/\bBearer\s+[^\s,;"'<>]+/gi, "Bearer [redacted]")
+    .replace(/\b(?:github_pat_|gh[pousr]_|sk-|copilot_)[A-Za-z0-9._-]+/gi, "[redacted]")
+    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|cookie)["']?\s*[:=]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;]+)/gi, "$1[redacted]")
+    .replace(/((?:prompt|input|completion|tool_arguments|arguments|content)["']?\s*[:=]\s*)[^\n]+/gi, "$1[redacted]")
+    .replace(/(encrypted(?: function output)? content\s+)[A-Za-z0-9+/_=-]{24,}/gi, "$1[redacted]")
+    .replace(/\b[A-Za-z0-9+/_=-]{96,}\b/g, "[redacted]");
+}

package/src/file-rotation.mjs

@@ -28,3 +28,37 @@ export function rotateFileIfNeededSync(filePath, incomingBytes, maxBytes) {
   fs.renameSync(filePath, backupPath);
   return true;
 }
+
+// Callers serialize writers (usage also holds its cross-process file lock).
+// Group adjacent lines without changing the existing per-record rotation rule.
+export async function appendRotatingLines(filePath, lines, maxBytes) {
+  let size = 0;
+  try {
+    const stat = await fs.promises.stat(filePath);
+    if (!stat.isFile()) throw new Error("Log destination is not a regular file");
+    size = stat.size;
+  }
+  catch (error) { if (error?.code !== "ENOENT") throw error; }
+  let group = [];
+  let bytes = 0;
+  const flush = async () => {
+    if (!group.length) return;
+    await fs.promises.appendFile(filePath, group.join(""), { encoding: "utf8", mode: 0o600 });
+    group = [];
+    bytes = 0;
+  };
+  for (const line of lines) {
+    const length = Buffer.byteLength(line);
+    if (maxBytes > 0 && size > 0 && size + length > maxBytes) {
+      await flush();
+      await fs.promises.rm(rotatedFilePath(filePath), { force: true });
+      await fs.promises.rename(filePath, rotatedFilePath(filePath));
+      size = 0;
+    }
+    group.push(line);
+    size += length;
+    bytes += length;
+    if (bytes >= 256 * 1024) await flush();
+  }
+  await flush();
+}

package/src/http-transport.mjs

@@ -3,6 +3,7 @@ import * as zlib from "node:zlib";
 import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
+import { redactDiagnosticText } from "./diagnostic-text.mjs";
 
 const COMPRESSED_BODY_WEIGHT_MULTIPLIER = 4;
 const gunzipAsync = promisify(zlib.gunzip);
@@ -730,21 +731,29 @@ export function sendUpstreamError(res, response, text) {
   res.end(text || JSON.stringify({ error: "Upstream request failed" }));
 }
 
-export function writeOrDrain(res, chunk) {
+export function writeOrDrain(res, chunk, { signal } = {}) {
   if (res.destroyed || res.writableEnded) return Promise.resolve(false);
+  if (signal?.aborted) {
+    res.destroy?.();
+    return Promise.resolve(false);
+  }
   if (res.write(chunk)) return Promise.resolve(true);
   return new Promise((resolve, reject) => {
     const cleanup = () => {
       res.off("drain", onDrain);
       res.off("error", onError);
       res.off("close", onClose);
+      signal?.removeEventListener("abort", onAbort);
     };
     const onDrain = () => { cleanup(); resolve(true); };
     const onClose = () => { cleanup(); resolve(false); };
     const onError = (err) => { cleanup(); reject(err); };
+    const onAbort = () => { cleanup(); res.destroy?.(); resolve(false); };
     res.once("drain", onDrain);
     res.once("close", onClose);
     res.once("error", onError);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
   });
 }
 
@@ -800,7 +809,7 @@ export function createRequestAbort(req, res) {
 
 export function logRequestFailure(label, err, abort) {
   if (!isAbortLikeError(err)) {
-    console.error(status("err", `${label} request failed: ${err.message}`));
+    console.error(status("err", `${label} request failed: ${redactDiagnosticText(err.message)}`));
     return;
   }
 

package/src/image-mcp.mjs

@@ -138,7 +138,8 @@ export function createImageMcpHandler({
   imageDirectory = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "images"),
 } = {}) {
   let active = 0;
-  return async function imageMcpHandler(req, res) {
+  const metrics = { total: 0, succeeded: 0, failed: 0, busy: 0, cancelled: 0, delivery_failures: 0 };
+  const handler = async function imageMcpHandler(req, res) {
     if (!isLoopbackAddress(req.socket?.remoteAddress) && !sameHostSocket(req.socket)) {
       writeJson(res, 403, jsonRpcError(null, -32001, "Image MCP is available only on this device"));
       return;
@@ -207,18 +208,23 @@ export function createImageMcpHandler({
       writeJson(res, 200, jsonRpcError(request.id, -32602, "Unknown image tool"));
       return;
     }
+    metrics.total += 1;
     const config = configLoader();
     if (!config) {
+      metrics.failed += 1;
       imageReferences.clear();
       reply({ content: [{ type: "text", text: "Image generation is disabled. Run ccdx enable-image first." }], isError: true });
       return;
     }
     const editing = request.params.name === EDIT_TOOL_NAME;
     if (editing && !supportsImageEditing(config)) {
+      metrics.failed += 1;
       reply({ content: [{ type: "text", text: "The configured image provider does not support CCDX editing. No edit was submitted." }], isError: true });
       return;
     }
     if (active >= maxConcurrent) {
+      metrics.busy += 1;
+      metrics.failed += 1;
       reply({ content: [{ type: "text", text: "Image generation is busy. Try again after the current request finishes." }], isError: true });
       return;
     }
@@ -234,6 +240,7 @@ export function createImageMcpHandler({
       const parameters = { prompt: args.prompt, size: args.size ?? source?.size ?? "1024x1024" };
       if (source) parameters.image = source.image;
       const image = await generateImageFn(config, parameters, { signal: abort.signal });
+      abort.signal.throwIfAborted();
       let imageId = null;
       if (supportsImageEditing(config)) {
         try { imageId = imageReferences.remember(config, { ...image, size: parameters.size }); } catch {}
@@ -250,9 +257,12 @@ export function createImageMcpHandler({
           saved = await saveChatImage(image, imageDirectory, abort.signal);
           delivery = `\nInclude this image Markdown in your final chat reply to show its thumbnail:\n${saved.markdown}\nTo display this same image again, reuse this Markdown; do not call generate_image or edit_image.`;
         } catch {
+          if (abort.signal.aborted) throw abort.signal.reason;
+          metrics.delivery_failures += 1;
           delivery = "\nThe image was generated, but its chat-preview file could not be saved. Image content is still returned. Do not claim it was displayed, invent a file path, or generate/edit again to retry delivery.";
         }
       }
+      abort.signal.throwIfAborted();
       reply({
         // Codex prioritizes structuredContent over image blocks. Keep IDs in metadata/text.
         ...(imageId || saved ? { _meta: { ...(imageId ? { "ccdx/image_id": imageId } : {}), ...(saved ? { "ccdx/image_path": saved.filePath } : {}) } } : {}),
@@ -261,7 +271,10 @@ export function createImageMcpHandler({
           { type: "text", text: `${editing ? "Edited" : "Generated"} ${image.width || ""}${image.width && image.height ? "×" : ""}${image.height || image.size} image with ${image.model}.${note}${delivery}` },
         ],
       });
+      metrics.succeeded += 1;
     } catch (error) {
+      if (abort.signal.aborted) metrics.cancelled += 1;
+      else metrics.failed += 1;
       if (!res.destroyed && !res.writableEnded) {
         reply({ content: [{ type: "text", text: safeToolError(error, config.api_key) }], isError: true });
       }
@@ -271,4 +284,7 @@ export function createImageMcpHandler({
       res.off?.("close", cancel);
     }
   };
+  // Status never reads credentials, loads image guidance, or probes a provider.
+  handler.stats = () => ({ ...metrics, active, max_concurrent: maxConcurrent });
+  return handler;
 }

package/src/image-optimization.mjs

@@ -159,6 +159,18 @@ export function imageOptimizationStats() {
   };
 }
 
+export function clearImageOptimizationCache() {
+  const stats = imageOptimizationStats();
+  if (stats.active > 0 || stats.queued > 0 || stats.cache_inflight > 0) {
+    const error = new Error("Image optimization is active; retry cache cleanup after current requests finish");
+    error.code = "ccdx_cache_busy";
+    throw error;
+  }
+  const removed = { entries: stats.cache_entries, bytes: stats.cache_bytes };
+  imageResultCache.clear();
+  return removed;
+}
+
 export function resetImageOptimizationCacheForTests() {
   imageResultCache.clear();
 }

package/src/image-provider.mjs

@@ -179,11 +179,16 @@ function publicAddress(address) {
   const family = net.isIP(address);
   if (family === 4) return ipv4Public(address);
   if (family !== 6) return false;
-  const lower = address.toLowerCase();
+  let lower;
+  try { lower = new URL(`https://[${address}]/`).hostname.slice(1, -1); }
+  catch { return false; }
   if (lower === "::" || lower === "::1" || lower.startsWith("fc") || lower.startsWith("fd")
     || /^fe[89ab]/.test(lower) || lower.startsWith("ff") || lower.startsWith("2001:db8:")) return false;
-  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
-  return mapped ? ipv4Public(mapped[1]) : true;
+  const mapped = /^::ffff:([a-f0-9]{1,4}):([a-f0-9]{1,4})$/.exec(lower);
+  if (!mapped) return true;
+  const high = Number.parseInt(mapped[1], 16);
+  const low = Number.parseInt(mapped[2], 16);
+  return ipv4Public([high >> 8, high & 255, low >> 8, low & 255].join("."));
 }
 
 export async function downloadPublicImage(urlValue, {
@@ -217,7 +222,8 @@ export async function downloadPublicImage(urlValue, {
     if (signal?.aborted) { onAbort(); return; }
     signal?.addEventListener("abort", onAbort, { once: true });
     // DNS and transfer share one deadline; a late lookup cannot start a cancelled download.
-    Promise.resolve().then(() => settled ? undefined : lookup(url.hostname, { all: true, verbatim: true })).then((addresses) => {
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    Promise.resolve().then(() => settled ? undefined : lookup(hostname, { all: true, verbatim: true })).then((addresses) => {
       if (settled) return;
       if (!Array.isArray(addresses) || !addresses.length || addresses.some(({ address }) => !publicAddress(address))) {
         finish(providerError("Image API returned a non-public image URL", "ccdx_image_url_unsafe"));

package/src/log.mjs

@@ -3,10 +3,17 @@ import os from "node:os";
 import path from "node:path";
 import { format } from "node:util";
 import { status } from "./status.mjs";
-import { parseByteLimit, rotateFileIfNeededSync } from "./file-rotation.mjs";
+import { appendRotatingLines, parseByteLimit } from "./file-rotation.mjs";
+import { redactDiagnosticText } from "./diagnostic-text.mjs";
 
 let globalInstall = null;
 const DEFAULT_LOG_MAX_BYTES = 16 * 1024 * 1024;
+const LOG_QUEUE_MAX_BYTES = 2 * 1024 * 1024;
+const LOG_QUEUE_MAX_RECORDS = 4096;
+
+export function debugLoggingStats() {
+  return globalInstall?.stats() || { enabled: false };
+}
 
 export function normalizeLogLevel(value) {
   return String(value || "info").trim().toLowerCase() === "debug" ? "debug" : "info";
@@ -35,7 +42,7 @@ export function debugLogMaxBytes(env = process.env) {
 
 function renderLogPayload(args) {
   const stamp = new Date().toISOString();
-  const text = format(...args);
+  const text = redactDiagnosticText(format(...args));
   return `${text.split(/\r?\n/).map((line) => `${stamp} ${line}`).join("\n")}\n`;
 }
 
@@ -43,12 +50,13 @@ export function configureLogging({
   env = process.env,
   consoleObj = console,
   home = os.homedir(),
+  appendLines = appendRotatingLines,
 } = {}) {
   const level = normalizeLogLevel(env.CCDX_LOG_LEVEL);
   const filePath = resolveLogPath(env.CCDX_LOG_PATH, { home });
   if (!filePath) return { level, filePath: null, cleanup: () => {} };
   if (consoleObj === console && globalInstall) {
-    return { level, filePath: globalInstall.filePath, cleanup: globalInstall.cleanup };
+    return { level, ...globalInstall };
   }
 
   fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
@@ -59,16 +67,52 @@ export function configureLogging({
     typeof consoleObj[method] === "function" ? consoleObj[method].bind(consoleObj) : () => {},
   ]));
   let writeFailed = false;
+  const pending = [];
+  let drain = null;
+  let pendingBytes = 0;
+  let pendingRecords = 0;
+  let droppedRecords = 0;
+  let writeFailures = 0;
+  const stats = () => ({ enabled: true, pending_bytes: pendingBytes, pending_records: pendingRecords,
+    dropped_records: droppedRecords, write_failures: writeFailures,
+    max_bytes: LOG_QUEUE_MAX_BYTES, max_records: LOG_QUEUE_MAX_RECORDS });
+
+  function scheduleDrain() {
+    if (drain) return;
+    drain = Promise.resolve().then(async () => {
+      while (pending.length) {
+        const batch = pending.splice(0);
+        try {
+          await appendLines(filePath, batch.map(({ payload }) => payload), debugLogMaxBytes(env));
+        } catch (error) {
+          writeFailures += 1;
+          if (!writeFailed) originals.error(`codex-copilot-dx log write failed: ${redactDiagnosticText(error.message)}`);
+          writeFailed = true;
+        } finally {
+          pendingRecords -= batch.length;
+          pendingBytes -= batch.reduce((sum, entry) => sum + entry.bytes, 0);
+        }
+      }
+    }).finally(() => { drain = null; if (pending.length) scheduleDrain(); });
+  }
 
   function append(args) {
     try {
       const payload = renderLogPayload(args);
-      rotateFileIfNeededSync(filePath, Buffer.byteLength(payload), debugLogMaxBytes(env));
-      fs.appendFileSync(filePath, payload, { encoding: "utf8", mode: 0o600 });
+      const bytes = Buffer.byteLength(payload);
+      if (pendingRecords >= LOG_QUEUE_MAX_RECORDS || pendingBytes + bytes > LOG_QUEUE_MAX_BYTES) {
+        droppedRecords += 1;
+        if (droppedRecords === 1) originals.error("codex-copilot-dx log queue is full; excess file records are dropped, terminal output is unchanged (see ccdx status)");
+        return;
+      }
+      pending.push({ payload, bytes });
+      pendingRecords += 1;
+      pendingBytes += bytes;
+      scheduleDrain();
     } catch (e) {
       if (writeFailed) return;
       writeFailed = true;
-      originals.error(`codex-copilot-dx log write failed: ${e.message}`);
+      originals.error(`codex-copilot-dx log write failed: ${redactDiagnosticText(e.message)}`);
     }
   }
 
@@ -79,13 +123,23 @@ export function configureLogging({
     };
   }
 
+  const flush = async ({ timeoutMs = 1500 } = {}) => {
+    let timer;
+    const completed = await Promise.race([
+      (async () => { while (drain) await drain; return true; })(),
+      new Promise((resolve) => { timer = setTimeout(() => resolve(false), timeoutMs); }),
+    ]);
+    clearTimeout(timer);
+    if (!completed) originals.error(`codex-copilot-dx log flush timed out after ${timeoutMs}ms`);
+  };
   const cleanup = () => {
     for (const method of methods) consoleObj[method] = originals[method];
     if (consoleObj === console && globalInstall?.cleanup === cleanup) globalInstall = null;
+    return flush();
   };
 
-  if (consoleObj === console) globalInstall = { filePath, cleanup };
-  return { level, filePath, cleanup };
+  if (consoleObj === console) globalInstall = { filePath, cleanup, flush, stats };
+  return { level, filePath, cleanup, flush, stats };
 }
 
 export function debugLog(message, env = process.env) {

package/src/models.mjs

@@ -26,8 +26,8 @@ export function modelIsResponsesOnly(model) {
 
 export function resolveCopilotPriorityTierModel(model, serviceTier, models) {
   const baseModel = String(model || "").trim();
-  if (baseModel !== "gpt-5.6-sol" || serviceTier !== "priority") return null;
-  const fastModelId = "gpt-5.6-sol-fast";
+  if (!baseModel.startsWith("gpt-") || serviceTier !== "priority") return null;
+  const fastModelId = `${baseModel}-fast`;
   const fastModel = copilotModelData(models)
     .find((entry) => String(entry?.id || "").trim() === fastModelId);
   const vendor = String(fastModel?.vendor || fastModel?.owned_by || "").trim().toLowerCase();

package/src/observability.mjs

@@ -5,6 +5,8 @@ import { imageOptimizationStats } from "./image-optimization.mjs";
 import { responseHistoryStats } from "./response-history.mjs";
 import { loadRuntimeConfig } from "./runtime-config.mjs";
 import { profileRouting } from "./profile-routing.mjs";
+import { usageLoggingStats } from "./usage.mjs";
+import { debugLoggingStats } from "./log.mjs";
 
 export { ADAPTER_STATUS_PATH };
 const OBSERVABILITY_RUNTIME_CONFIG = loadRuntimeConfig();
@@ -13,6 +15,7 @@ const ROUTE_NAMES = Object.freeze([
   "responses",
   "responses_compact",
   "models",
+  "image_mcp",
   "not_found",
 ]);
 
@@ -94,6 +97,7 @@ export function classifyAdapterRoute(method, pathname) {
   if (method === "POST" && pathname === "/v1/responses") return "responses";
   if (method === "POST" && pathname === "/v1/responses/compact") return "responses_compact";
   if (method === "GET" && pathname === "/v1/models") return "models";
+  if (pathname === "/mcp/image") return "image_mcp";
   return "not_found";
 }
 
@@ -155,6 +159,7 @@ export function runtimeStatusPayload({
   admission,
   imagePressure,
   responseFailures,
+  imageGeneration,
   modelRegistry,
   codexClient,
   codexModelRegistry,
@@ -162,6 +167,7 @@ export function runtimeStatusPayload({
   const memory = process.memoryUsage();
   const codexRuntime = safeClientRuntimeStatus(codexClient);
   const codexModels = modelRegistryStatus(codexModelRegistry || modelRegistry);
+  const history = responseHistoryStats();
   return {
     ...adapterHealthPayload(),
     uptime_ms: Math.round(process.uptime() * 1000),
@@ -175,8 +181,10 @@ export function runtimeStatusPayload({
     requests: metrics?.snapshot?.() || createRequestMetrics().snapshot(),
     stream_performance: streamPerformance?.snapshot?.() || null,
     admission: admission?.diagnostics?.() || admission?.stats?.() || null,
-    response_history: responseHistoryStats(),
+    response_history: history,
     image_optimization: imageOptimizationStats(),
+    image_generation: imageGeneration || null,
+    logging: { usage: usageLoggingStats(), debug: debugLoggingStats() },
     image_history_pressure: imagePressure?.snapshot?.() || null,
     response_failures: responseFailures?.snapshot?.() || null,
     copilot: codexRuntime,
@@ -189,8 +197,8 @@ export function runtimeStatusPayload({
       max_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxBodyBytes,
       max_decoded_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxDecodedBodyBytes,
       max_sse_buffer_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxSseBufferBytes,
-      response_history_max_bytes: OBSERVABILITY_RUNTIME_CONFIG.responseHistoryMaxBytes,
-      response_history_max_entries: OBSERVABILITY_RUNTIME_CONFIG.responseHistoryMaxEntries,
+      response_history_max_bytes: history.maxBytes,
+      response_history_max_entries: history.maxEntries,
     },
   };
 }

package/src/response-failures.mjs

@@ -1,17 +1,16 @@
 import { terminalCell } from "./cli-table.mjs";
+import { redactDiagnosticText } from "./diagnostic-text.mjs";
 
 const DEFAULT_RECENT_FAILURES = 10;
 
 function safeIdentifier(value, fallback = "unknown") {
-  const text = terminalCell(value, { fallback });
+  const text = redactDiagnosticText(terminalCell(value, { fallback }));
   return text.slice(0, 200);
 }
 
 function safeFailureMessage(value) {
   let text = terminalCell(value, { fallback: "Response failed without an error message" });
-  text = text
-    .replace(/(encrypted(?: function output)? content\s+)[A-Za-z0-9+/_=-]{24,}/gi, "$1[redacted]")
-    .replace(/\b[A-Za-z0-9+/_=-]{96,}\b/g, "[redacted]");
+  text = redactDiagnosticText(text);
   return text.slice(0, 500);
 }