codex-copilot-dx 0.5.0 → 0.5.3

package/README.md

@@ -12,7 +12,7 @@ A single in-process adapter (port `2026`) exposes both APIs over your Copilot su
 
 Supports both HTTP SSE streaming and non-streaming.
 
-Codex Auto-review requests use the hidden `codex-auto-review` model ID. The adapter maps it to Copilot's `gpt-5.5` Responses model by default and logs both model IDs when the mapping is used.
+Codex Auto-review requests use the hidden `codex-auto-review` model ID. The adapter maps it to Copilot's `gpt-5.5` Responses model by default and logs both model IDs when the mapping is used. The target can be changed interactively without reinstalling the package.
 
 ## Prerequisites
 
@@ -33,6 +33,42 @@ 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.
 
+To change the model used by Codex Auto-review, run:
+
+```bash
+ccdx auto-review-model
+```
+
+The selector reads the current adapter model list, falling back to the fresh local
+model cache, and offers only enabled models that advertise a Responses endpoint.
+It saves the selection in `~/.config/codex-copilot-dx/config.json` (or under
+`XDG_CONFIG_HOME` when set); choosing `gpt-5.5` clears the override and restores
+the package default. A running 0.5.1+
+adapter reads the setting on the next Auto-review request, so it does not need to
+be restarted. `codex-copilot-dx auto-review-model` is fully equivalent.
+
+To update the globally installed package, choose a source interactively:
+
+```bash
+ccdx update
+```
+
+For scripts or a direct choice, pass the source explicitly:
+
+```bash
+ccdx update npm
+ccdx update github
+```
+
+The npm source installs `codex-copilot-dx@latest` through the registry already
+configured for npm, including a company mirror. The GitHub source installs the
+latest commit from `DaleXiao/codex-copilot-dx` `main` and opts in to Git fetching
+for that command, as required by npm 12. It does not change npm's persistent
+`allow-git` setting. Both paths use npm's global installer without shell
+interpolation. A currently running adapter keeps its loaded version until it is
+stopped and started again. The
+`codex-copilot-dx update` compatibility command behaves identically.
+
 On first run, it will:
 1. Authenticate with GitHub via device flow (if needed), after first trying compatible local Copilot token sources
 2. Print the local package version and check for a newer npm release in the background
@@ -145,7 +181,7 @@ Environment variables:
 | `CCDX_STREAM_IDLE_TIMEOUT_MS` | `120000` | Maximum idle time between upstream streaming body chunks |
 | `CCDX_UPSTREAM_RETRIES` | `2` | Retries for safe requests and clearly pre-connect POST failures; capped at `5` |
 | `CCDX_UPSTREAM_RETRY_DELAY_MS` | `300` | Initial upstream retry backoff in milliseconds; capped at `5000` |
-| `CCDX_AUTO_REVIEW_MODEL` | `gpt-5.5` | Copilot Responses model used for Codex Auto-review requests |
+| `CCDX_AUTO_REVIEW_MODEL` | saved selection or `gpt-5.5` | Copilot Responses model used for Codex Auto-review requests; overrides the interactive selection |
 | `CCDX_LOG_PATH` | unset | Mirror terminal logs to a file; set to `1` for `~/.local/share/codex-copilot-dx/debug.log` |
 | `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 |

package/bin/cli.mjs

@@ -19,6 +19,8 @@ import { initializeModelRegistry, runInBackground } from "../src/startup.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";
+import { runAutoReviewModelCommand } from "../src/auto-review-model.mjs";
+import { autoReviewModelPreference } from "../src/user-settings.mjs";
 
 const LOCAL_VERSION = localPackageVersion();
 const CLI_NAME = cliCommandName();
@@ -66,6 +68,25 @@ if (CLI.command === "status") {
     process.exit(1);
   }
 }
+if (CLI.command === "auto-review-model") {
+  try {
+    await runAutoReviewModelCommand({ commandName: CLI_NAME });
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
+if (CLI.command === "update") {
+  try {
+    const { runPackageUpdateCommand } = await import("../src/package-update.mjs");
+    await runPackageUpdateCommand({ commandName: CLI_NAME, source: CLI.updateSource });
+    process.exit(0);
+  } catch (e) {
+    console.error(status("err", e.message));
+    process.exit(1);
+  }
+}
 
 let RUNTIME;
 try {
@@ -128,7 +149,9 @@ async function refreshClaudeDesktopModelDefs() {
       throw new Error(`Copilot models returned HTTP ${httpStatus}`);
     }
     const models = JSON.parse(body);
-    const autoReview = codexAutoReviewModelStatus(models);
+    const autoReview = codexAutoReviewModelStatus(models, process.env, {
+      autoReviewModel: autoReviewModelPreference().model,
+    });
     if (!autoReview.available) {
       console.log(status("warn", `Auto-review target ${autoReview.upstreamModel} is unavailable: ${autoReview.reason}. Run ${CLI_NAME} doctor --compat to verify the live path.`));
     }
@@ -292,6 +315,7 @@ try {
   activeServer = await startAdapter(ADAPTER_PORT, ADAPTER_HOST, {
     claudeDesktopApiKey,
     claudeDesktopModelDefs,
+    autoReviewModelResolver: () => autoReviewModelPreference().model,
     modelRegistry: MODEL_REGISTRY,
     showRequestId: CLI.showRequestId,
     upstreamTimeoutMs: RUNTIME.upstreamTimeoutMs,

package/package.json

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

package/src/adapter.mjs

@@ -106,6 +106,7 @@ export function createAdapterHandler(options = {}) {
   };
   const responsesHandler = createResponsesHandler({
     acquireRequest,
+    autoReviewModelResolver: options.autoReviewModelResolver,
     chatCompletionsFn,
     openAIModelEnv,
     responsesPayloadOptions: options.responsesPayloadOptions,
@@ -116,6 +117,7 @@ export function createAdapterHandler(options = {}) {
   });
   const responsesCompactHandler = createResponsesCompactHandler({
     acquireRequest,
+    autoReviewModelResolver: options.autoReviewModelResolver,
     openAIModelEnv,
     responsesCompactFn,
     streamHandshakeTimeoutMs,

package/src/auto-review-model.mjs

@@ -0,0 +1,141 @@
+import os from "node:os";
+import { createInterface } from "node:readline/promises";
+import { loadModelCache } from "./model-cache.mjs";
+import {
+  DEFAULT_CODEX_AUTO_REVIEW_MODEL,
+  responsesModelIdsFromCopilotModels,
+} from "./models.mjs";
+import { parseAdapterProbeOptions } from "./cli-options.mjs";
+import { adapterBaseUrl } from "./running-adapter.mjs";
+import {
+  autoReviewModelPreference,
+  readUserSettings,
+  writeAutoReviewModel,
+} from "./user-settings.mjs";
+
+const DEFAULT_MODEL_FETCH_TIMEOUT_MS = 5000;
+
+function modelFetchTimeout(env) {
+  const value = Number(env.CCDX_MODEL_REFRESH_TIMEOUT_MS);
+  return Number.isSafeInteger(value) && value > 0 ? value : DEFAULT_MODEL_FETCH_TIMEOUT_MS;
+}
+
+function sortedModelIds(modelIds, currentModel) {
+  return [...modelIds].sort((left, right) => {
+    const leftRank = left === currentModel ? 0 : left === DEFAULT_CODEX_AUTO_REVIEW_MODEL ? 1 : 2;
+    const rightRank = right === currentModel ? 0 : right === DEFAULT_CODEX_AUTO_REVIEW_MODEL ? 1 : 2;
+    return leftRank - rightRank || left.localeCompare(right);
+  });
+}
+
+export async function loadAutoReviewModelCatalog({
+  env = process.env,
+  fetchImpl = fetch,
+  home = os.homedir(),
+  loadModelCacheFn = loadModelCache,
+} = {}) {
+  const { adapterHost, adapterPort } = parseAdapterProbeOptions(env);
+  const url = `${adapterBaseUrl(adapterHost, adapterPort)}/v1/models`;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), modelFetchTimeout(env));
+  let liveError = "adapter is not running";
+  try {
+    const response = await fetchImpl(url, {
+      headers: { Accept: "application/json" },
+      redirect: "error",
+      signal: ctrl.signal,
+    });
+    if (!response.ok) {
+      liveError = `adapter returned HTTP ${response.status}`;
+    } else {
+      const models = await response.json();
+      const modelIds = responsesModelIdsFromCopilotModels(models);
+      if (modelIds.length) {
+        const fallback = response.headers.get("X-CCDX-Model-Source") === "last-known-good";
+        return { modelIds, source: fallback ? "running adapter cache" : "running adapter" };
+      }
+      liveError = "adapter returned no selectable Responses models";
+    }
+  } catch (error) {
+    liveError = ctrl.signal.aborted
+      ? `adapter model lookup timed out after ${modelFetchTimeout(env)}ms`
+      : error?.message || String(error);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  const cached = loadModelCacheFn({ home });
+  const modelIds = responsesModelIdsFromCopilotModels(cached);
+  if (modelIds.length) return { modelIds, source: "local model cache" };
+  throw new Error(`No selectable Responses models are available (${liveError}). Start ccdx once to refresh the model list.`);
+}
+
+export async function runAutoReviewModelCommand({
+  commandName = "ccdx",
+  env = process.env,
+  fetchImpl = fetch,
+  home = os.homedir(),
+  input = process.stdin,
+  loadCatalog = loadAutoReviewModelCatalog,
+  output = process.stdout,
+  prompt,
+} = {}) {
+  if (!prompt && (!input.isTTY || !output.isTTY)) {
+    throw new Error(`${commandName} auto-review-model requires an interactive terminal`);
+  }
+
+  readUserSettings({ env, home, strict: true });
+  const current = autoReviewModelPreference({ env, home });
+  const catalog = await loadCatalog({ env, fetchImpl, home });
+  const modelIds = sortedModelIds(catalog.modelIds, current.model);
+  if (!modelIds.length) throw new Error("No selectable Responses models are available");
+
+  output.write(`${commandName} auto-review-model\n`);
+  output.write(`Current: ${current.model} (${current.source})\n`);
+  output.write(`Responses models from ${catalog.source}:\n`);
+  modelIds.forEach((model, index) => {
+    const markers = [];
+    if (model === current.model) markers.push("current");
+    if (model === DEFAULT_CODEX_AUTO_REVIEW_MODEL) markers.push("default");
+    output.write(`  ${index + 1}. ${model}${markers.length ? ` [${markers.join(", ")}]` : ""}\n`);
+  });
+
+  let defaultIndex = modelIds.indexOf(current.model);
+  if (defaultIndex < 0) defaultIndex = modelIds.indexOf(DEFAULT_CODEX_AUTO_REVIEW_MODEL);
+  if (defaultIndex < 0) defaultIndex = 0;
+
+  let readline;
+  const ask = prompt || (async (question) => {
+    readline ||= createInterface({ input, output });
+    return readline.question(question);
+  });
+
+  let selectedModel;
+  try {
+    while (!selectedModel) {
+      const answer = String(await ask(`Select a model [${defaultIndex + 1}], or q to cancel: `) || "").trim();
+      if (answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") {
+        output.write("No changes made.\n");
+        return { changed: false, cancelled: true, model: current.model };
+      }
+      const selectedIndex = answer === "" ? defaultIndex : Number(answer) - 1;
+      if (Number.isInteger(selectedIndex) && selectedIndex >= 0 && selectedIndex < modelIds.length) {
+        selectedModel = modelIds[selectedIndex];
+      } else {
+        output.write(`Enter a number from 1 to ${modelIds.length}, or q to cancel.\n`);
+      }
+    }
+  } finally {
+    readline?.close();
+  }
+
+  const savedModel = selectedModel === DEFAULT_CODEX_AUTO_REVIEW_MODEL ? "" : selectedModel;
+  const result = writeAutoReviewModel(savedModel, { env, home });
+  output.write(`${result.changed ? "Saved" : "Kept"} Auto Review model: ${selectedModel}\n`);
+  if (String(env.CCDX_AUTO_REVIEW_MODEL || "").trim()) {
+    output.write(`CCDX_AUTO_REVIEW_MODEL=${current.model} remains the effective override until it is unset.\n`);
+  } else {
+    output.write("The running 0.5.1+ adapter will use this model on the next Auto Review request.\n");
+  }
+  return { ...result, cancelled: false, model: selectedModel };
+}

package/src/cli-options.mjs

@@ -26,6 +26,25 @@ export function parseCliArgs(args = []) {
     if (rest.length) unexpectedArgs(rest);
     return { command: "usage", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
   }
+  if (command === "auto-review-model") {
+    if (rest.length) unexpectedArgs(rest);
+    return { command: "auto-review-model", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
+  }
+  if (command === "update") {
+    if (rest.length > 1) unexpectedArgs(rest.slice(1));
+    const source = rest[0];
+    if (source && !new Set(["npm", "github", "gh"]).has(source)) {
+      throw new Error(`Update source must be npm or github: ${source}`);
+    }
+    return {
+      command: "update",
+      configureClaudeDesktop: false,
+      showRequestId: false,
+      online: false,
+      compat: false,
+      updateSource: source === "gh" ? "github" : source,
+    };
+  }
   if (command === "doctor" || command === "--doctor") {
     const supported = new Set(["--online", "--compat"]);
     const invalid = rest.filter((arg) => !supported.has(arg));
@@ -107,6 +126,8 @@ export function cliHelp(commandName = "ccdx") {
   ${name} doctor [--online] [--compat]
   ${name} status
   ${name} usage
+  ${name} auto-review-model
+  ${name} update [npm|github]
   ${name} --version
   ${name} --help
 

package/src/models.mjs

@@ -158,6 +158,17 @@ export function gptModelIdsFromCopilotModels(models) {
   });
 }
 
+export function responsesModelIdsFromCopilotModels(models) {
+  return uniqueIds(copilotModelData(models), (model) => {
+    const id = String(model?.id || "").trim();
+    const endpoints = modelEndpoints(model);
+    return id !== CODEX_AUTO_REVIEW_MODEL
+      && /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/.test(id)
+      && model?.model_picker_enabled !== false
+      && (endpoints.includes("/responses") || endpoints.includes("/v1/responses"));
+  });
+}
+
 export function claudeDesktopModelDefsFromCopilotModels(models) {
   const data = copilotModelData(models);
 
@@ -212,21 +223,21 @@ export function resolveAnthropicModel(model, env = process.env, options = {}) {
   };
 }
 
-export function resolveOpenAIModel(model, env = process.env) {
+export function resolveOpenAIModel(model, env = process.env, options = {}) {
   const requestedModel = String(model || "");
   if (requestedModel !== CODEX_AUTO_REVIEW_MODEL) {
     return { requestedModel, upstreamModel: requestedModel };
   }
 
-  const configuredModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
+  const configuredModel = String(env.CCDX_AUTO_REVIEW_MODEL || options.autoReviewModel || "").trim();
   return {
     requestedModel,
     upstreamModel: configuredModel || DEFAULT_CODEX_AUTO_REVIEW_MODEL,
   };
 }
 
-export function codexAutoReviewModelStatus(models, env = process.env) {
-  const { upstreamModel } = resolveOpenAIModel(CODEX_AUTO_REVIEW_MODEL, env);
+export function codexAutoReviewModelStatus(models, env = process.env, options = {}) {
+  const { upstreamModel } = resolveOpenAIModel(CODEX_AUTO_REVIEW_MODEL, env, options);
   const model = copilotModelData(models).find((entry) => String(entry?.id || "").trim() === upstreamModel);
   if (!model) return { available: false, upstreamModel, reason: "model is not advertised" };
   const endpoints = modelEndpoints(model);

package/src/package-update.mjs

@@ -0,0 +1,100 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+
+const PACKAGE_NAME = "codex-copilot-dx";
+const UPDATE_SPECS = {
+  npm: `${PACKAGE_NAME}@latest`,
+  github: "github:DaleXiao/codex-copilot-dx#main",
+};
+
+export function normalizeUpdateSource(value) {
+  const source = String(value || "").trim().toLowerCase();
+  if (source === "gh") return "github";
+  return Object.hasOwn(UPDATE_SPECS, source) ? source : "";
+}
+
+export function globalUpdateCommand(source, { platform = process.platform } = {}) {
+  const normalized = normalizeUpdateSource(source);
+  if (!normalized) throw new Error(`Update source must be npm or github: ${source}`);
+  const args = ["install", "--global"];
+  if (normalized === "github") args.push("--allow-git=all");
+  args.push(UPDATE_SPECS[normalized]);
+  return {
+    command: platform === "win32" ? "npm.cmd" : "npm",
+    args,
+    source: normalized,
+  };
+}
+
+function waitForExit(child) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (handler, value) => {
+      if (settled) return;
+      settled = true;
+      handler(value);
+    };
+    child.once("error", (error) => finish(reject, error));
+    child.once("exit", (code, signal) => {
+      if (signal) finish(reject, new Error(`npm update was interrupted by ${signal}`));
+      else if (code !== 0) finish(reject, new Error(`npm update exited with status ${code}`));
+      else finish(resolve);
+    });
+  });
+}
+
+export async function runPackageUpdateCommand({
+  commandName = "ccdx",
+  env = process.env,
+  input = process.stdin,
+  output = process.stdout,
+  platform = process.platform,
+  prompt,
+  source,
+  spawnImpl = spawn,
+} = {}) {
+  let selectedSource = normalizeUpdateSource(source);
+  if (source && !selectedSource) throw new Error(`Update source must be npm or github: ${source}`);
+
+  if (!selectedSource) {
+    if (!prompt && (!input.isTTY || !output.isTTY)) {
+      throw new Error(`Choose a source with ${commandName} update npm or ${commandName} update github`);
+    }
+
+    output.write(`${commandName} update\n`);
+    output.write("  1. npm registry [default]\n");
+    output.write("  2. GitHub main\n");
+
+    let readline;
+    const ask = prompt || (async (question) => {
+      readline ||= createInterface({ input, output });
+      return readline.question(question);
+    });
+    try {
+      while (!selectedSource) {
+        const answer = String(await ask("Select update source [1], or q to cancel: ") || "").trim().toLowerCase();
+        if (answer === "q" || answer === "quit") {
+          output.write("No changes made.\n");
+          return { cancelled: true, source: "" };
+        }
+        if (answer === "" || answer === "1" || answer === "npm") selectedSource = "npm";
+        else if (answer === "2" || answer === "github" || answer === "gh") selectedSource = "github";
+        else output.write("Enter 1 for npm, 2 for GitHub, or q to cancel.\n");
+      }
+    } finally {
+      readline?.close();
+    }
+  }
+
+  const update = globalUpdateCommand(selectedSource, { platform });
+  const sourceLabel = selectedSource === "npm" ? "npm registry" : "GitHub main";
+  output.write(`Updating ${PACKAGE_NAME} from ${sourceLabel}...\n`);
+  const child = spawnImpl(update.command, update.args, {
+    env,
+    shell: false,
+    stdio: "inherit",
+  });
+  await waitForExit(child);
+  output.write(`Updated ${PACKAGE_NAME} from ${sourceLabel}. Restart the running adapter to use the new version.\n`);
+  return { cancelled: false, source: selectedSource };
+}

package/src/responses-handler.mjs

@@ -66,9 +66,17 @@ function unsupportedCustomToolsError(model) {
   return error;
 }
 
+function resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver) {
+  const options = model === CODEX_AUTO_REVIEW_MODEL && typeof autoReviewModelResolver === "function"
+    ? { autoReviewModel: autoReviewModelResolver() }
+    : {};
+  return resolveOpenAIModel(model, openAIModelEnv, options);
+}
+
 export function createResponsesHandler(options) {
   const {
     acquireRequest,
+    autoReviewModelResolver,
     chatCompletionsFn,
     openAIModelEnv,
     responsesPayloadOptions,
@@ -91,7 +99,7 @@ export function createResponsesHandler(options) {
       const prepared = prepareResponsesRequest(parsed, { mutate: true });
       prepared.surface = "responses";
       const model = parsed.model || "unknown";
-      const { requestedModel, upstreamModel } = resolveOpenAIModel(model, openAIModelEnv);
+      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
@@ -186,6 +194,7 @@ export function createResponsesHandler(options) {
 export function createResponsesCompactHandler(options) {
   const {
     acquireRequest,
+    autoReviewModelResolver,
     openAIModelEnv,
     responsesCompactFn,
     upstreamTimeoutMs,
@@ -203,7 +212,7 @@ export function createResponsesCompactHandler(options) {
       );
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
-      const { requestedModel, upstreamModel } = resolveOpenAIModel(model, openAIModelEnv);
+      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));

package/src/user-settings.mjs

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
+
+const AUTO_REVIEW_MODEL_KEY = "auto_review_model";
+
+export function userSettingsPath({ env = process.env, home = os.homedir() } = {}) {
+  const xdgConfigHome = String(env.XDG_CONFIG_HOME || "").trim();
+  const configRoot = xdgConfigHome || path.join(home, ".config");
+  return path.join(configRoot, "codex-copilot-dx", "config.json");
+}
+
+function invalidSettings(filePath, reason) {
+  return new Error(`Invalid ccdx settings at ${filePath}: ${reason}`);
+}
+
+export function readUserSettings({ env = process.env, home = os.homedir(), strict = false } = {}) {
+  const filePath = userSettingsPath({ env, home });
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw invalidSettings(filePath, "expected a JSON object");
+    }
+    if (Object.hasOwn(parsed, AUTO_REVIEW_MODEL_KEY)) {
+      const value = parsed[AUTO_REVIEW_MODEL_KEY];
+      if (typeof value !== "string" || !value.trim()) {
+        throw invalidSettings(filePath, `${AUTO_REVIEW_MODEL_KEY} must be a non-empty string`);
+      }
+    }
+    return parsed;
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    if (strict) {
+      if (String(error?.message || "").startsWith("Invalid ccdx settings")) throw error;
+      throw invalidSettings(filePath, error?.message || String(error));
+    }
+    return {};
+  }
+}
+
+export function savedAutoReviewModel(options = {}) {
+  const settings = readUserSettings(options);
+  return String(settings[AUTO_REVIEW_MODEL_KEY] || "").trim();
+}
+
+export function autoReviewModelPreference({ env = process.env, home = os.homedir() } = {}) {
+  const environmentModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
+  if (environmentModel) return { model: environmentModel, source: "environment" };
+
+  const savedModel = savedAutoReviewModel({ env, home });
+  if (savedModel) return { model: savedModel, source: "settings" };
+  return { model: DEFAULT_CODEX_AUTO_REVIEW_MODEL, source: "default" };
+}
+
+export function writeAutoReviewModel(model, { env = process.env, home = os.homedir() } = {}) {
+  const filePath = userSettingsPath({ env, home });
+  const settings = readUserSettings({ env, home, strict: true });
+  const value = String(model || "").trim();
+  const next = { ...settings };
+  if (value) next[AUTO_REVIEW_MODEL_KEY] = value;
+  else delete next[AUTO_REVIEW_MODEL_KEY];
+
+  const changed = atomicWriteFileIfChangedSync(filePath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  return { changed, filePath, model: value || DEFAULT_CODEX_AUTO_REVIEW_MODEL };
+}