@yhong91/cpac 0.1.7 → 0.1.9

package/README.md

@@ -97,7 +97,7 @@ cpac --help
 
 ```bash
 cpac detect [--json] [--home PATH]
-cpac install [--target codex,claude,pi,kimi] [--all] [--dry-run] [--force] [--home PATH]
+cpac install [--target codex,claude,pi,kimi] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--home PATH]
 cpac uninstall [--target codex,claude,pi,kimi] [--all] [--dry-run] [--home PATH]
 cpac upgrade [--check]
 cpac version
@@ -105,6 +105,8 @@ cpac version
 
 - `detect` 列出每个目标是否被检测到、是否已接入 CPAC；`--json` 输出机器可读结果。
 - `install` 默认作用于检测到的目标；`--target` 指定目标、`--all` 全部。各目标映射到既有逻辑：`codex` → `cpac inject`，`pi` → `cpac pi install`，`kimi` → `cpac kimi install`；`claude` 无持久化安装（用 `cpac claude` 启动）。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
+- Codex 注入默认开启 multi-agent v2（写入 `[features.multi_agent_v2] enabled = true`）；`install --target codex --v2_off` 写入 `enabled = false`。服务端还需在 CPA 配置中开启 `codex.optimize-multi-agent-v2`。
+- `--v2_models` 进入 arrow-key 复选框选择最多 5 个 spawn_agent 模型（勾选顺序即推荐顺序），选择结果存入配置文件的 `spawn_models`，注入时把这些模型排到 `codex-models.json` 最前——Codex 客户端只把 catalog 前 5 个可见模型广告为 spawn 覆盖项。
 - `uninstall` 默认作用于已安装目标，映射到 `cpac restore` / `cpac pi uninstall` / `cpac kimi uninstall`。
 - `--home PATH` 临时把 `HOME` 指向给定目录，便于在隔离环境中试验。
 - `upgrade` 检查 npm 上是否有新版本，`--check` 只报告不提示安装命令。
@@ -132,7 +134,21 @@ CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST=1
 
 代理开启 Claude Code 的 gateway model discovery：`/model` 选择器会列出 CPA 目录里的全部模型。claude 系模型直接使用原 id；其它模型以 `claude-cpac--<模型名>` 别名出现（例如 `claude-cpac--gpt-5.6-sol`），请求发出时由代理还原为真实模型名。
 
-Claude Code 的发现协议不携带 context 信息，未知模型默认按 200K 处理。`cpac claude` 启动时会从 CPA 目录取最大 `context_window`，通过 `CLAUDE_CODE_MAX_CONTEXT_TOKENS` 告知 Claude Code（对非 claude 名称的模型生效）；你自己 export 该变量时以你为准。claude 系模型如需 1M 窗口，在模型名后加 `[1m]`（如 `cpac claude --model claude-sonnet-4-6[1m]`）。
+启动时还会把模型槽位（`ANTHROPIC_DEFAULT_OPUS/SONNET/HAIKU_MODEL` 及 `ANTHROPIC_SMALL_FAST_MODEL`）指向目录里的模型，避免 haiku/subagent 任务打到网关不认识的默认 id。默认自动选择（claude 系优先：按家族名匹配 opus/sonnet/haiku，否则最大窗口给 opus/sonnet、最小窗口给 haiku），可用命令覆盖：
+
+```sh
+cpac claude-models                                            # 查看当前覆盖
+cpac claude-models --opus claude-opus-4-8 --haiku glm-5.3     # 设置/合并
+cpac claude-models --haiku                                    # 不带值：arrow-key 下拉选择
+cpac claude-models --classifier claude-sonnet-4-6             # Auto mode 审批分类器模型
+cpac claude-models --reset                                    # 恢复自动选择
+```
+
+所有设定写入配置文件持久缓存，每次 `cpac claude` 启动自动生效。`--classifier` 对应 `CLAUDE_CODE_AUTO_MODE_MODEL`（Auto mode 的审批分类器，默认跟随 Claude Code 内置选择）；不设置则不注入。
+
+你自己 export 同名环境变量时以你为准。
+
+Claude Code 的发现协议不携带 context 信息，claude 前缀的未知模型默认按 200K 记账，且 `CLAUDE_CODE_MAX_CONTEXT_TOKENS` 对 claude 前缀的名字不生效。cpac 采用与 opencodex 相同的机制：目录里窗口足够大的别名模型会带 `[1m]` 标记出现在选择器中（Claude Code 按 1M 记账，发请求前自己剥掉标记），同时 `cpac claude` 注入 `CLAUDE_CODE_AUTO_COMPACT_WINDOW`（默认 350K，与 opencodex 一致，接受范围 100K–1M）作为压缩阈值。你自己 export 该变量时以你为准。claude 系模型如需 1M 窗口，在模型名后加 `[1m]`（如 `cpac claude --model claude-sonnet-4-6[1m]`）。
 
 > CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。
 

package/cpac.example.json

@@ -1,5 +1,12 @@
 {
   "cpa_url": "https://cpa.example.com",
   "api_key_env": "CPA_API_KEY",
-  "codex_proxy_port": 10101
+  "codex_proxy_port": 10101,
+  "claude_models": {
+    "opus": "claude-opus-4-8",
+    "sonnet": "claude-sonnet-4-6",
+    "haiku": "glm-5.3",
+    "classifier": "claude-sonnet-4-6"
+  },
+  "spawn_models": ["gpt-5.5", "claude-opus-4-8"]
 }

package/dist/cpac.js

@@ -19,7 +19,13 @@ const CONFIG_KEYS = new Set([
     "codex_config",
     "codex_proxy_port",
     "state_dir",
+    "claude_models",
+    "spawn_models",
 ]);
+// Codex advertises only the first 5 picker-visible catalog models as
+// spawn_agent overrides (codex-rs MAX_SPAWN_AGENT_MODEL_OVERRIDES).
+const MAX_SPAWN_MODELS = 5;
+const CLAUDE_SLOT_KEYS = ["opus", "sonnet", "haiku", "classifier"];
 const REQUIRED_STATE_KEYS = new Set([
     "config_path",
     "config_existed",
@@ -119,6 +125,39 @@ export function loadConfig(path, useDefaultsIfMissing = false) {
         codexProxyPort > 65535) {
         throw new CPACError("codex_proxy_port must be an integer from 0 to 65535");
     }
+    const claudeModelsRaw = value.claude_models;
+    let claudeModels;
+    if (claudeModelsRaw !== undefined) {
+        if (!objectValue(claudeModelsRaw))
+            throw new CPACError("claude_models must be an object");
+        const unknownSlots = Object.keys(claudeModelsRaw)
+            .filter((key) => !CLAUDE_SLOT_KEYS.includes(key))
+            .sort();
+        if (unknownSlots.length)
+            throw new CPACError(`unknown claude_models slots: ${unknownSlots.join(", ")}`);
+        claudeModels = {};
+        for (const slot of CLAUDE_SLOT_KEYS) {
+            const model = claudeModelsRaw[slot];
+            if (model === undefined)
+                continue;
+            if (typeof model !== "string" || !model.trim())
+                throw new CPACError(`claude_models.${slot} must be a non-empty string`);
+            claudeModels[slot] = model.trim();
+        }
+    }
+    const spawnModelsRaw = value.spawn_models;
+    let spawnModels;
+    if (spawnModelsRaw !== undefined) {
+        if (!Array.isArray(spawnModelsRaw))
+            throw new CPACError("spawn_models must be an array of model slugs");
+        if (spawnModelsRaw.length > MAX_SPAWN_MODELS)
+            throw new CPACError(`spawn_models accepts at most ${MAX_SPAWN_MODELS} models`);
+        spawnModels = spawnModelsRaw.map((model, index) => {
+            if (typeof model !== "string" || !model.trim())
+                throw new CPACError(`spawn_models[${index}] must be a non-empty string`);
+            return model.trim();
+        });
+    }
     const codexHome = expandUserPath(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
     const codexConfig = resolve(expandUserPath(value.codex_config ||
         join(codexHome, "config.toml")));
@@ -135,6 +174,8 @@ export function loadConfig(path, useDefaultsIfMissing = false) {
         codex_config: codexConfig,
         codex_proxy_port: codexProxyPort,
         state_dir: stateDir,
+        claude_models: claudeModels,
+        spawn_models: spawnModels,
     };
 }
 export function apiBase(cpaUrl) {
@@ -215,6 +256,124 @@ export async function fetchCatalog(cpaUrl, apiKey) {
         modelCount: models.length,
     };
 }
+// Move `order` slugs to the front of the rich catalog (stable for the rest),
+// so the Codex client's first-5 spawn_agent advertisement picks them.
+export function reorderCatalog(bytes, order) {
+    const document = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    const rank = new Map(order.map((slug, index) => [slug, index]));
+    const models = document.models.map((model, index) => ({ model, index }));
+    models.sort((left, right) => {
+        const leftRank = rank.get(String(left.model.slug));
+        const rightRank = rank.get(String(right.model.slug));
+        if (leftRank === undefined && rightRank === undefined)
+            return left.index - right.index;
+        if (leftRank === undefined)
+            return 1;
+        if (rightRank === undefined)
+            return -1;
+        return leftRank - rightRank;
+    });
+    document.models = models.map((entry) => entry.model);
+    return Buffer.from(`${JSON.stringify(document, null, 2)}\n`);
+}
+export function saveSpawnModels(configPath, models) {
+    let document = {};
+    if (existsSync(configPath)) {
+        const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+        if (!objectValue(parsed))
+            throw new CPACError("config must be a JSON object");
+        document = parsed;
+    }
+    document.spawn_models = models;
+    atomicWrite(configPath, Buffer.from(`${JSON.stringify(document, null, 2)}\n`));
+}
+// Arrow-key checkbox picker on raw stdin; resolves with the checked labels in
+// check order (which becomes the spawn advertisement ranking).
+async function checkboxPicker(title, items, max) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        throw new CPACError("model selection requires an interactive terminal");
+    }
+    const stdin = process.stdin;
+    const out = process.stderr;
+    const selected = new Set();
+    let cursor = 0;
+    const lines = items.length + 1;
+    const render = () => {
+        out.write(`${title} [space: toggle, up/down: move, enter: confirm, q: cancel, max ${max}]\n`);
+        items.forEach((item, index) => {
+            const box = selected.has(index) ? "[x]" : "[ ]";
+            out.write(`${index === cursor ? ">" : " "} ${box} ${item}\n`);
+        });
+    };
+    const redraw = () => {
+        out.write(`\x1b[${lines}F`);
+        for (let line = 0; line < lines; line += 1)
+            out.write("\x1b[2K\x1b[1E");
+        out.write(`\x1b[${lines}F`);
+        render();
+    };
+    return await new Promise((resolvePromise, rejectPromise) => {
+        const finish = (error) => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(false);
+            }
+            catch {
+                // Terminal already gone; nothing to restore.
+            }
+            stdin.pause();
+            out.write("\n");
+            if (error)
+                rejectPromise(error);
+            else
+                resolvePromise([...selected].map((index) => items[index]));
+        };
+        const onData = (chunk) => {
+            const key = chunk.toString("utf8");
+            if (key === "\x03" || key === "q" || key === "\x1b") {
+                finish(new CPACError("model selection cancelled"));
+                return;
+            }
+            if (key === "\r" || key === "\n") {
+                finish();
+                return;
+            }
+            if (key === "\x1b[A")
+                cursor = (cursor + items.length - 1) % items.length;
+            else if (key === "\x1b[B")
+                cursor = (cursor + 1) % items.length;
+            else if (key === " ") {
+                if (max === 1) {
+                    selected.clear();
+                    selected.add(cursor);
+                    finish();
+                    return;
+                }
+                if (selected.has(cursor))
+                    selected.delete(cursor);
+                else if (selected.size < max)
+                    selected.add(cursor);
+            }
+            redraw();
+        };
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        render();
+    });
+}
+export async function pickSpawnModels(config) {
+    const apiKey = process.env[config.api_key_env]?.trim();
+    if (!apiKey)
+        throw new CPACError(`environment variable ${config.api_key_env} is not set`);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    const document = JSON.parse(new TextDecoder().decode(catalog.bytes));
+    const slugs = document.models.map((model) => model.slug);
+    const picked = await checkboxPicker("Select spawn_agent models", slugs, MAX_SPAWN_MODELS);
+    if (picked.length === 0)
+        throw new CPACError("no models selected");
+    return picked;
+}
 export function tomlString(value) {
     return JSON.stringify(value);
 }
@@ -341,6 +500,94 @@ export function buildCodexConfig(original, proxyPort, catalogPath) {
     const output = root + body;
     return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
 }
+// Codex multi-agent v2 (features.multi_agent_v2). Accepts the same TOML
+// shapes codex-rs does: a [features.multi_agent_v2] table, an inline
+// `multi_agent_v2 = ...` under [features], or dotted root keys.
+const V2_TABLE_HEADER = /^\s*\[\s*(?:features|"features"|'features')\s*\.\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')\s*\]\s*(?:#.*)?$/;
+const FEATURES_TABLE_HEADER = /^\s*\[\s*(?:features|"features"|'features')\s*\]\s*(?:#.*)?$/;
+const V2_KEY = /^\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')\s*=/;
+const V2_DOTTED_KEY = /^\s*(?:features|"features"|'features')\s*\.\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')(?:\s*\.\s*(?:enabled|"enabled"|'enabled'))?\s*=/;
+function v2LineValue(line) {
+    const inline = line.match(/\{[^}]*\benabled\s*=\s*(true|false)/);
+    if (inline)
+        return inline[1] === "true";
+    const plain = line.match(/=\s*(true|false)(?![A-Za-z0-9_])/);
+    if (plain)
+        return plain[1] === "true";
+    return undefined;
+}
+export function multiAgentV2Enabled(content) {
+    let table = "root";
+    for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+        if (V2_TABLE_HEADER.test(line)) {
+            table = "v2";
+            continue;
+        }
+        if (FEATURES_TABLE_HEADER.test(line)) {
+            table = "features";
+            continue;
+        }
+        if (/^\s*\[/.test(line)) {
+            table = "other";
+            continue;
+        }
+        if (table === "v2" && /^\s*(?:enabled|"enabled"|'enabled')\s*=/.test(line)) {
+            return v2LineValue(line) ?? false;
+        }
+        if (table === "features" && V2_KEY.test(line))
+            return v2LineValue(line) ?? false;
+        if (table === "root" && V2_DOTTED_KEY.test(line))
+            return v2LineValue(line) ?? false;
+    }
+    return false;
+}
+function stripMultiAgentV2(content) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    const kept = [];
+    let skipTable = false;
+    let table = "root";
+    for (const line of lines) {
+        if (/^\s*\[/.test(line)) {
+            skipTable = V2_TABLE_HEADER.test(line);
+            if (skipTable) {
+                table = "other";
+                continue;
+            }
+            table = FEATURES_TABLE_HEADER.test(line) ? "features" : "other";
+        }
+        if (skipTable)
+            continue;
+        if (table === "features" && V2_KEY.test(line))
+            continue;
+        if (table === "root" && V2_DOTTED_KEY.test(line))
+            continue;
+        kept.push(line);
+    }
+    return kept.join("\n");
+}
+function hasAgentsMaxThreads(content) {
+    let table = "root";
+    for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+        if (/^\s*\[/.test(line)) {
+            table = /^\s*\[\s*(?:agents|"agents"|'agents')\s*\]\s*(?:#.*)?$/.test(line)
+                ? "agents"
+                : "other";
+            continue;
+        }
+        if (table === "agents" && /^\s*max_threads\s*=/.test(line))
+            return true;
+        if (table === "root" && /^\s*(?:agents|"agents"|'agents')\s*\.\s*max_threads\s*=/.test(line))
+            return true;
+    }
+    return false;
+}
+export function withMultiAgentV2(content, enabled, eol) {
+    let body = stripMultiAgentV2(content);
+    if (body && !body.endsWith("\n"))
+        body += "\n";
+    const output = body + `\n[features.multi_agent_v2]\nenabled = ${enabled}\n`;
+    return eol === "\n" ? output : output.replace(/\n/g, "\r\n");
+}
 export function atomicWrite(path, data, mode = 0o600) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.cpac.${process.pid}.${Date.now()}.${++atomicSequence}.tmp`;
@@ -508,6 +755,63 @@ export async function createLoopbackProxy(cpaUrl, apiKey, proxyId, port) {
     return { server, port: address.port };
 }
 const CLAUDE_ALIAS_PREFIX = "claude-cpac--";
+// Claude Code accepts CLAUDE_CODE_AUTO_COMPACT_WINDOW in 100K–1M (binary-verified).
+// A single global window cannot be per-model; 350K is opencodex's user-approved
+// default — high enough to mark mid-size models (372K/500K), low enough that
+// marking never outgrows a model's real window.
+const ONE_MILLION = 1_000_000;
+const COMPACT_WINDOW_DEFAULT = 350_000;
+function claudeCompactWindow(maxContext) {
+    return maxContext > 200_000 ? COMPACT_WINDOW_DEFAULT : undefined;
+}
+// [1m] marking predicate (opencodex rule): native claude models manage their own
+// marker; aliases mark when the real window is >= 1M, or when it clears 200K and
+// can host the compact window (marking below it would trip API limits mid-session).
+function shouldMarkOneMillion(id, window, compactWindow) {
+    if (id.startsWith("claude"))
+        return false;
+    if (window >= ONE_MILLION)
+        return true;
+    return compactWindow !== undefined && window > 200_000 && window >= compactWindow;
+}
+// Auto tier defaults: prefer claude-family models; within the pool match by
+// family keyword first (opus/sonnet/haiku) so equal context windows don't
+// collapse every slot onto the first catalog entry, then fall back to
+// biggest-window (opus/sonnet) and smallest-window (haiku).
+function defaultClaudeSlots(models) {
+    if (!models.length)
+        return undefined;
+    const claudeRows = models.filter((model) => model.id.startsWith("claude"));
+    const pool = claudeRows.length ? claudeRows : models;
+    const biggest = [...pool].sort((a, b) => b.window - a.window)[0];
+    const smallest = pool
+        .filter((model) => model.window > 0)
+        .sort((a, b) => a.window - b.window)[0];
+    const family = (keyword) => pool.find((model) => model.id.includes(keyword));
+    return {
+        opus: (family("opus") ?? biggest).id,
+        sonnet: (family("sonnet") ?? biggest).id,
+        haiku: (family("haiku") ?? smallest ?? biggest).id,
+    };
+}
+// Resolve the tier-model env values: config overrides win over catalog
+// defaults; values are [1m]-marked per the predicate above (Claude Code
+// strips the marker before the request leaves).
+export function claudeTierSlots(override, models, compactWindow) {
+    const defaults = defaultClaudeSlots(models);
+    if (!defaults)
+        return undefined;
+    const windowById = new Map(models.map((model) => [model.id, model.window]));
+    const mark = (id) => !/\[1m\]$/i.test(id) &&
+        shouldMarkOneMillion(id, windowById.get(id) ?? 0, compactWindow)
+        ? `${id}[1m]`
+        : id;
+    return {
+        opus: mark(override?.opus ?? defaults.opus),
+        sonnet: mark(override?.sonnet ?? defaults.sonnet),
+        haiku: mark(override?.haiku ?? defaults.haiku),
+    };
+}
 function catalogModelRows(document) {
     if (!objectValue(document))
         return undefined;
@@ -546,21 +850,38 @@ async function claudeModelList(cpaUrl, apiKey, response) {
         return;
     }
     // Claude Code's /model picker only lists ids starting with claude/anthropic;
-    // expose every other catalog model as claude-cpac--<id>.
-    const data = [];
+    // expose every other catalog model as claude-cpac--<id>. Append the [1m]
+    // marker when the model can host the auto-compact window — that marker is
+    // the only signal that lifts context accounting above the 200K default
+    // (Claude Code strips it before the request reaches the proxy).
+    const rowsWithWindow = [];
+    let maxContext = 0;
     for (const model of rows) {
         const id = catalogModelId(model);
         if (!id)
             continue;
-        const alias = id.startsWith("claude") ? id : `${CLAUDE_ALIAS_PREFIX}${id}`;
-        data.push({
-            type: "model",
-            id: alias,
-            display_name: typeof model.display_name === "string" && model.display_name.trim()
+        const window = typeof model.context_window === "number" && model.context_window > 0
+            ? Math.floor(model.context_window)
+            : 0;
+        if (window > maxContext)
+            maxContext = window;
+        rowsWithWindow.push({
+            id,
+            window,
+            alias: id.startsWith("claude") ? id : `${CLAUDE_ALIAS_PREFIX}${id}`,
+            display: typeof model.display_name === "string" && model.display_name.trim()
                 ? model.display_name
                 : id,
         });
     }
+    const compactWindow = claudeCompactWindow(maxContext);
+    const data = rowsWithWindow.map((row) => ({
+        type: "model",
+        id: shouldMarkOneMillion(row.id, row.window, compactWindow)
+            ? `${row.alias}[1m]`
+            : row.alias,
+        display_name: row.display,
+    }));
     response.writeHead(200, { "content-type": "application/json" });
     response.end(JSON.stringify({
         data,
@@ -595,7 +916,10 @@ export async function createClaudeProxy(cpaUrl, apiKey) {
                     if (objectValue(parsed) &&
                         typeof parsed.model === "string" &&
                         parsed.model.startsWith(CLAUDE_ALIAS_PREFIX)) {
-                        parsed.model = parsed.model.slice(CLAUDE_ALIAS_PREFIX.length);
+                        // Claude Code strips [1m] itself; keep the strip as a guard.
+                        parsed.model = parsed.model
+                            .slice(CLAUDE_ALIAS_PREFIX.length)
+                            .replace(/\[(1|2)m\]$/i, "");
                         body = Buffer.from(JSON.stringify(parsed));
                     }
                 }
@@ -831,7 +1155,7 @@ function proxyFingerprint(config, apiKey) {
         .update(apiKey)
         .digest("hex");
 }
-export async function inject(config) {
+export async function inject(config, v2Off = false) {
     const apiKey = process.env[config.api_key_env]?.trim();
     if (!apiKey)
         throw new CPACError(`environment variable ${config.api_key_env} is not set`);
@@ -867,6 +1191,8 @@ export async function inject(config) {
         }
     }
     const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    if (config.spawn_models?.length)
+        catalog.bytes = reorderCatalog(catalog.bytes, config.spawn_models);
     const stateDirExisted = existsSync(config.state_dir);
     if (!state &&
         STATE_FILES.some((name) => existsSync(join(config.state_dir, name)))) {
@@ -898,6 +1224,11 @@ export async function inject(config) {
     let injected;
     try {
         injected = buildCodexConfig(original, proxy.port, catalogPath);
+        const injectedText = new TextDecoder("utf-8").decode(injected);
+        injected = Buffer.from(withMultiAgentV2(injectedText, !v2Off, dominantEol(injectedText)));
+        if (!v2Off && hasAgentsMaxThreads(injectedText)) {
+            console.warn("warning: [agents] max_threads is set; codex refuses to start with multi_agent_v2 enabled, remove it");
+        }
     }
     catch (error) {
         if (startedProxy)
@@ -964,7 +1295,7 @@ export async function inject(config) {
     catch {
         console.warn("CPAC could not invalidate Codex models_cache.json; restart Codex App if its model list is stale.");
     }
-    console.log(`Injected ${catalog.modelCount} CPA models into ${config.codex_config} via http://127.0.0.1:${proxy.port}/v1`);
+    console.log(`Injected ${catalog.modelCount} CPA models into ${config.codex_config} via http://127.0.0.1:${proxy.port}/v1 (multi-agent v2: ${v2Off ? "off" : "on"})`);
     console.log("Restart Codex App if its running app-server still shows the old model list.");
 }
 export async function restore(config) {
@@ -1011,6 +1342,12 @@ export async function status(config) {
                     .slice(0, 12);
                 console.log(`codex: injected proxy=http://127.0.0.1:${proxy.port}/v1 sha256=${digest}`);
             }
+            try {
+                console.log(`codex multi-agent v2: ${multiAgentV2Enabled(readFileSync(config.codex_config, "utf8")) ? "on" : "off"}`);
+            }
+            catch {
+                // Unreadable config: the injected line above already reports it.
+            }
         }
     }
     console.log(`claude: ${keyConfigured ? "ready" : "not configured"}`);
@@ -1090,6 +1427,60 @@ async function guide(config) {
     console.log(`\nSaved ${config.api_key_env} to ${profile}. Open a new terminal or run:\n  source ${profile}`);
     return 0;
 }
+export async function runClaudeModels(parsed) {
+    if (parsed.pick.length) {
+        const config = loadConfig(parsed.configPath);
+        const apiKey = process.env[config.api_key_env]?.trim();
+        if (!apiKey)
+            throw new CPACError(`environment variable ${config.api_key_env} is not set`);
+        const catalog = await fetchCatalog(config.cpa_url, apiKey);
+        const document = JSON.parse(new TextDecoder().decode(catalog.bytes));
+        const slugs = document.models.map((model) => model.slug);
+        for (const slot of parsed.pick) {
+            const [picked] = await checkboxPicker(`Select ${slot} model`, slugs, 1);
+            if (!picked)
+                throw new CPACError("no model selected");
+            parsed.models[slot] = picked;
+        }
+    }
+    if (!parsed.reset && !Object.keys(parsed.models).length) {
+        const config = loadConfig(parsed.configPath);
+        console.log(config.claude_models
+            ? JSON.stringify(config.claude_models, null, 2)
+            : "claude_models not set; cpac claude auto-picks tier models from the CPA catalog");
+        return 0;
+    }
+    let raw = {};
+    try {
+        const file = JSON.parse(readFileSync(parsed.configPath, "utf8"));
+        if (!objectValue(file))
+            throw new CPACError("config must be a JSON object");
+        raw = file;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            if (error instanceof CPACError)
+                throw error;
+            throw new CPACError(`cannot read config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (parsed.reset) {
+        delete raw.claude_models;
+    }
+    else {
+        const existing = objectValue(raw.claude_models)
+            ? { ...raw.claude_models }
+            : {};
+        Object.assign(existing, parsed.models);
+        raw.claude_models = existing;
+    }
+    atomicWrite(parsed.configPath, Buffer.from(`${JSON.stringify(raw, null, 2)}\n`));
+    loadConfig(parsed.configPath);
+    console.log(parsed.reset
+        ? "claude_models cleared"
+        : `claude_models updated: ${JSON.stringify(raw.claude_models)}`);
+    return 0;
+}
 export async function runClaude(config, args, executable = "claude") {
     const apiKey = await resolveApiKey(config.api_key_env);
     const proxy = await createClaudeProxy(config.cpa_url, apiKey);
@@ -1097,22 +1488,31 @@ export async function runClaude(config, args, executable = "claude") {
         proxy.server.closeAllConnections?.();
         proxy.server.close();
     };
-    // Gateway discovery only carries {id, display_name}; Claude Code defaults
-    // unknown models to 200K. CLAUDE_CODE_MAX_CONTEXT_TOKENS applies to
-    // non-claude model names, so feed it the largest catalog window.
+    // Gateway discovery only carries {id, display_name}; Claude Code accounts
+    // claude-prefixed unknown models at 200K and ignores MAX_CONTEXT_TOKENS for
+    // them. The [1m] marker on the alias (added by the models listing) plus the
+    // auto-compact window is opencodex's working mechanism for bigger windows.
     let maxContext = 0;
+    const catalogWindows = [];
     try {
         const catalog = await fetchCatalog(config.cpa_url, apiKey);
         const rows = catalogModelRows(JSON.parse(new TextDecoder("utf-8").decode(catalog.bytes))) ?? [];
         for (const row of rows) {
-            if (typeof row.context_window === "number" && row.context_window > maxContext) {
-                maxContext = row.context_window;
-            }
+            const id = catalogModelId(row);
+            const window = typeof row.context_window === "number" && row.context_window > 0
+                ? Math.floor(row.context_window)
+                : 0;
+            if (id)
+                catalogWindows.push({ id, window });
+            if (window > maxContext)
+                maxContext = window;
         }
     }
     catch {
         // keep the default window when the catalog is unreachable
     }
+    const compactWindow = claudeCompactWindow(maxContext);
+    const slots = claudeTierSlots(config.claude_models, catalogWindows, compactWindow);
     const env = {
         ...process.env,
         ANTHROPIC_BASE_URL: `http://127.0.0.1:${proxy.port}`,
@@ -1120,9 +1520,23 @@ export async function runClaude(config, args, executable = "claude") {
         CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
         CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1",
     };
-    if (maxContext > 0 && !(Number(process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS) > 0)) {
-        env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(maxContext);
+    if (compactWindow !== undefined && !(Number(process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW) > 0)) {
+        env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(compactWindow);
     }
+    const setSlot = (name, value) => {
+        if (process.env[name] === undefined)
+            env[name] = value;
+    };
+    if (slots) {
+        // Route haiku/subagent tier traffic at catalog models instead of the
+        // stock claude-haiku-* ids the gateway does not carry.
+        setSlot("ANTHROPIC_DEFAULT_OPUS_MODEL", slots.opus);
+        setSlot("ANTHROPIC_DEFAULT_SONNET_MODEL", slots.sonnet);
+        setSlot("ANTHROPIC_DEFAULT_HAIKU_MODEL", slots.haiku);
+        setSlot("ANTHROPIC_SMALL_FAST_MODEL", slots.haiku);
+    }
+    if (config.claude_models?.classifier)
+        setSlot("CLAUDE_CODE_AUTO_MODE_MODEL", config.claude_models.classifier);
     delete env.ANTHROPIC_API_KEY;
     delete env.CLAUDE_CODE_USE_ANTHROPIC_AWS;
     delete env.CLAUDE_CODE_USE_BEDROCK;
@@ -1348,18 +1762,18 @@ const TARGETS = [
         },
         installed: (config) => {
             try {
-                return hasProviderTable(readFileSync(config.codex_config, "utf8"));
+                return readFileSync(config.codex_config, "utf8").includes(MANAGED_MARKER);
             }
             catch {
                 return false;
             }
         },
-        install: async (config, dryRun) => {
+        install: async (config, dryRun, v2Off) => {
             if (dryRun) {
                 console.log("would inject CPA catalog and loopback proxy into Codex");
                 return;
             }
-            await inject(config);
+            await inject(config, v2Off);
         },
         uninstall: async (config, dryRun) => {
             if (dryRun) {
@@ -1462,7 +1876,7 @@ export async function runInstall(config, requested, options) {
             console.log(`${target.id}: already installed; use --force to reinstall`);
             continue;
         }
-        await target.install(config, options.dryRun);
+        await target.install(config, options.dryRun, options.v2Off);
     }
     return 0;
 }
@@ -1531,10 +1945,11 @@ function usage() {
         "       cpac <inject|status|restore> [--config PATH]",
         "       cpac proxy [--config PATH]",
         "       cpac claude [--config PATH] [--] [claude args...]",
+        "       cpac claude-models [--opus [M]] [--sonnet [M]] [--haiku [M]] [--classifier [M]] [--reset] [--config PATH]",
         "       cpac pi <install|uninstall|status> [--config PATH]",
         "       cpac kimi <install|uninstall|status> [--config PATH]",
         "       cpac detect [--json] [--home PATH]",
-        "       cpac install [--target codex,claude,pi,kimi] [--all] [--dry-run] [--force] [--home PATH]",
+        "       cpac install [--target codex,claude,pi,kimi] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--home PATH]",
         "       cpac uninstall [--target codex,claude,pi,kimi] [--all] [--dry-run] [--home PATH]",
         "       cpac upgrade [--check]",
         "       cpac version",
@@ -1558,6 +1973,8 @@ function parseArgs(args) {
             dryRun: false,
             force: false,
             check: false,
+            v2Off: false,
+            v2Models: false,
         };
         for (let index = 1; index < args.length; index++) {
             const arg = args[index];
@@ -1592,6 +2009,12 @@ function parseArgs(args) {
                     throw new CPACError("--config requires a path");
                 parsed.configPath = resolve(expandUserPath(value));
             }
+            else if (arg === "--v2_off" || arg === "--v2-off") {
+                parsed.v2Off = true;
+            }
+            else if (arg === "--v2_models" || arg === "--v2-models") {
+                parsed.v2Models = true;
+            }
             else {
                 throw new CPACError(`unknown option: ${arg}`);
             }
@@ -1611,6 +2034,62 @@ function parseArgs(args) {
         const action = args[index] || "status";
         return { command: args[0], configPath, action };
     }
+    if (args[0] === "claude-models") {
+        if (args.includes("-h") || args.includes("--help")) {
+            console.log([
+                "Usage: cpac claude-models [--opus [M]] [--sonnet [M]] [--haiku [M]] [--classifier [M]] [--reset] [--config PATH]",
+                "",
+                "Sets the model Claude Code uses per task tier. Saved to the config file",
+                "and applied on every `cpac claude` launch:",
+                "  --opus        heavy reasoning / planning fallback tier (ANTHROPIC_DEFAULT_OPUS_MODEL)",
+                "  --sonnet      main conversation default tier (ANTHROPIC_DEFAULT_SONNET_MODEL)",
+                "  --haiku       high-frequency small tasks: titles, summaries, background",
+                "                (ANTHROPIC_DEFAULT_HAIKU_MODEL + ANTHROPIC_SMALL_FAST_MODEL)",
+                "  --classifier  auto-mode approval classifier (CLAUDE_CODE_AUTO_MODE_MODEL);",
+                "                unset follows Claude Code's built-in default",
+                "",
+                "A slot without a value opens an arrow-key picker over the CPA catalog;",
+                "--reset clears all overrides back to catalog auto-selection.",
+            ].join("\n"));
+            return null;
+        }
+        let configPath = defaultConfigPath();
+        const models = {};
+        const pick = [];
+        let reset = false;
+        for (let index = 1; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--config") {
+                const value = args[++index];
+                if (!value)
+                    throw new CPACError("--config requires a path");
+                configPath = resolve(expandUserPath(value));
+            }
+            else if (arg === "--reset") {
+                reset = true;
+            }
+            else if (arg === "--opus" ||
+                arg === "--sonnet" ||
+                arg === "--haiku" ||
+                arg === "--classifier") {
+                const slot = arg.slice(2);
+                const value = args[index + 1];
+                if (value !== undefined && !value.startsWith("-")) {
+                    index += 1;
+                    if (!value.trim())
+                        throw new CPACError(`${arg} requires a model id`);
+                    models[slot] = value.trim();
+                }
+                else {
+                    pick.push(slot);
+                }
+            }
+            else {
+                throw new CPACError(`unknown option: ${arg}`);
+            }
+        }
+        return { command: "claude-models", configPath, models, pick, reset };
+    }
     if (args[0] === "claude") {
         let configPath = defaultConfigPath();
         let index = 1;
@@ -1671,12 +2150,21 @@ export async function main(args = process.argv.slice(2)) {
             return await guide(config);
         if (parsed.command === "detect")
             return await runDetect(config, parsed.json);
-        if (parsed.command === "install")
-            return await runInstall(config, parsed.targets, {
+        if (parsed.command === "install") {
+            let installConfig = config;
+            if (parsed.v2Models) {
+                const picked = await pickSpawnModels(config);
+                saveSpawnModels(parsed.configPath, picked);
+                console.log(`spawn_models saved to ${parsed.configPath}: ${picked.join(", ")}`);
+                installConfig = { ...config, spawn_models: picked };
+            }
+            return await runInstall(installConfig, parsed.targets, {
                 all: parsed.all,
                 dryRun: parsed.dryRun,
                 force: parsed.force,
+                v2Off: parsed.v2Off,
             });
+        }
         if (parsed.command === "uninstall")
             return await runUninstall(config, parsed.targets, {
                 all: parsed.all,
@@ -1690,6 +2178,8 @@ export async function main(args = process.argv.slice(2)) {
         }
         if (parsed.command === "claude")
             return await runClaude(config, parsed.args);
+        if (parsed.command === "claude-models")
+            return await runClaudeModels(parsed);
         if (parsed.command === "proxy")
             return await runProxy(config);
         if (parsed.command === "pi")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yhong91/cpac",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Connect Codex and Claude Code to a remote CLIProxyAPI gateway",
   "type": "module",
   "bin": {