@yhong91/cpac 0.1.33 → 0.1.35

package/README.md

@@ -38,18 +38,18 @@ cpac status
 
 # 4a. 持久注入（长期生效，写入 agent 配置，可完整恢复）
 cpac install --all                     # 注入所有检测到的目标（codex/pi/kimi）
-cpac install --target codex            # 只注入 Codex（默认开启 multi-agent v2）
-cpac install --target codex --v2_models  # 先多选 spawn_agent 模型再注入
-cpac install --target codex --max_context  # 注入时把模型上下文提升到实测上限（opt-in，仅限 codex）
-cpac restore --target codex            # 撤掉注入；注入期间的用户改动会留下
+cpac install codex                     # 只注入 Codex（默认开启 multi-agent v2）
+cpac install codex --v2_models         # 先多选 spawn_agent 模型再注入
+cpac install codex --max_context       # 注入时把模型上下文提升到实测上限（opt-in，仅限 codex）
+cpac restore codex                     # 撤掉注入；注入期间的用户改动会留下
 
 # 4b. 临时接管（退出无痕，不写任何配置文件）
 cpac claude                            # Claude Code 走 CPA
 cpac opencode                          # opencode 走 CPA（模型选 cpac/<模型名>）
 
 # 5. 可选：Agent 配置向导与模型选择
-cpac codex --setup                     # Codex 配置向导 → 注入 → 启动
-cpac claude --setup                    # Claude 模型向导 → 启动
+cpac setup codex                       # Codex 配置向导 → 注入 → 启动
+cpac setup claude                      # Claude 模型向导 → 启动
 
 # 6. 升级（装上新版本后自动 sync 已接入的 agent）
 cpac upgrade
@@ -80,7 +80,7 @@ cpac status   # 验证：CPA_API_KEY 应显示 configured
 }
 ```
 
-   Claude 槽位（opus/sonnet/haiku）通常不用配：cpac 启动时自动选择——同家族 claude 模型优先，否则 gemini → grok → luna → 目录第一个；opus 无匹配则不设。这个链条在常见目录上正好给出理想结果：sonnet 落在 claude-sonnet-*（它同时充当 Auto mode 分类器的替身，避免分类请求失败后回退到昂贵的会话主模型），haiku 落在快的 gemini flash。只有目录奇怪时才用 `cpac claude --setup` 交互式配置。codex spawn subagent 取三个 GPT + gemini + grok 五席（顺序即优先级，Codex 只广告 catalog 前 5），可通过 `cpac codex --setup` 交互式配置。候选替换：`mimo-v2.5`（haiku）、`grok-4.5`（haiku）。若上述 slug 不在目录中（`curl -s -H "Authorization: Bearer $CPA_API_KEY" "$CPA_BASE_URL/v1/models"` 可查），按家族就近替换。分类器机制细节见 [docs/claude-auto-mode-classifier.md](docs/claude-auto-mode-classifier.md)。
+   Claude 槽位（opus/sonnet/haiku）通常不用配：cpac 启动时自动选择——同家族 claude 模型优先，否则 gemini → grok → luna → 目录第一个；opus 无匹配则不设。这个链条在常见目录上正好给出理想结果：sonnet 落在 claude-sonnet-*（它同时充当 Auto mode 分类器的替身，避免分类请求失败后回退到昂贵的会话主模型），haiku 落在快的 gemini flash。只有目录奇怪时才用 `cpac setup claude` 交互式配置。codex spawn subagent 取三个 GPT + gemini + grok 五席（顺序即优先级，Codex 只广告 catalog 前 5），可通过 `cpac setup codex` 交互式配置。候选替换：`mimo-v2.5`（haiku）、`grok-4.5`（haiku）。若上述 slug 不在目录中（`curl -s -H "Authorization: Bearer $CPA_API_KEY" "$CPA_BASE_URL/v1/models"` 可查），按家族就近替换。分类器机制细节见 [docs/claude-auto-mode-classifier.md](docs/claude-auto-mode-classifier.md)。
 
 1. **持久注入**（只对检测到的目标；codex 会应用步骤 3 的 spawn_models）：
 
@@ -91,12 +91,13 @@ cpac status   # 验证：各 target 显示 ready/injected
 
 1. **统一启动与配置**：
    - 启动：`cpac <codex|claude|kimi|grok|pi|opencode> [args...]`（所有原生参数如 `-c` 等原样透明传递）
-   - 配置并启动：`cpac <codex|claude> --setup`（向导结束后注入并拉起）
-   - 还原：`cpac <agent> clear`（还原或重置配置）
+     - `setup` / `--setup`：配置 Codex/Claude，然后启动
+     - `clear`：还原原生配置
+   - 查看当前设置：`cpac setup`
 
 2. **已安装后升级**：npm 发布新版本后，等 publish 成功再执行 `cpac upgrade`。它会按需 `npm install -g`，再对已接入的 Codex / Pi / Kimi / Grok 做 `sync`。不要拆成 `npm install -g @yhong91/cpac` 再手动 `cpac sync`。只刷新配置、不升 CLI 时才用 `cpac sync`。
 
-失败处理：任何一步报错时先跑 `cpac status`；密钥未配置回到步骤 2；注入后异常用 `cpac <agent> clear` 或 `cpac restore --target <id>` 恢复原配置。
+失败处理：任何一步报错时先跑 `cpac status`；密钥未配置回到步骤 2；注入后异常用 `cpac <agent> clear` 或 `cpac restore <id>` 恢复原配置。
 
 ## 首次引导
 
@@ -109,10 +110,10 @@ CPA: http://124.223.178.52:8317
 CPA_API_KEY: configured / not configured
 
 Commands:
-  cpac claude [args...]  Launch Claude Code through CPA
-  cpac inject            Inject CPA into Codex
-  cpac status            Show Codex injection status
-  cpac restore --target <id> | --all  Detach injected agents
+  cpac <agent> [args...] Launch an agent through CPA
+  cpac setup            Show current Codex/Claude setup
+  cpac status            Show agent support status
+  cpac restore <id> | --all  Detach injected agents
   cpac --help            Show command usage
 ```
 
@@ -164,21 +165,21 @@ cpac --help
 
 ```bash
 cpac detect [--json] [--home PATH]
-cpac install [--target codex,pi,kimi] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context] [--home PATH]
-cpac sync [--target codex,pi,kimi] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context] [--home PATH]
-cpac restore --target <id> | --all [--dry-run] [--home PATH]
+cpac install [codex|pi|kimi|grok...] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context] [--home PATH]
+cpac sync [codex|pi|kimi|grok...] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context] [--home PATH]
+cpac restore <id...> | --all [--dry-run] [--home PATH]
 cpac uninstall [--dry-run]
 cpac upgrade [--check]
 cpac -v | --version
 ```
 
 - `detect` 列出每个目标是否被检测到、是否已接入 CPAC；`--json` 输出机器可读结果。
-- `install` 默认作用于检测到的目标；`--target` 指定目标、`--all` 全部。各目标映射到既有逻辑：`codex` → `cpac inject`，`pi` → `cpac pi install`，`kimi` → `cpac kimi install`。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
-- `sync` 按当前 `cpa_url` 和 CPA 目录强制刷新**已经接入**的目标（Codex 重新注入、Pi 确认 `npm:@yhong91/cpac` 并清理旧的 `extensions/pi-cpac.ts`、Kimi 配置重写），用来在 CPA 地址或模型目录变化后一次对齐本地配置。不带参数只动已安装目标；`--all` 会对检测到的目标做同样的强制刷新（尚未安装的会装上）。`--max_context` 仍只对 `--target codex` 有效。
-- Codex 注入默认开启 multi-agent v2（写入 `[features.multi_agent_v2] enabled = true`，catalog 行打 `multi_agent_version: "v2"`）；`install --target codex --v2_off` 关掉 toml 并去掉 catalog 戳。v2 开着时会剥掉 `[agents] max_threads`（Codex 否则拒启动）。`cpac status` 对照 config 里的 `v2_off` / `max_context` 和 live toml / catalog。服务端还需在 CPA 配置中开启 `codex.optimize-multi-agent-v2`。
+- `install` 默认作用于检测到的目标；后面直接写 agent 名（`cpac install codex pi`），`--all` 全部。`codex` 写入 catalog 并拉起 loopback 代理；`pi`/`kimi`/`grok` 写入各自配置。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
+- `sync` 按当前 `cpa_url` 和 CPA 目录强制刷新**已经接入**的目标（Codex 重新注入、Pi 确认 `npm:@yhong91/cpac` 并清理旧的 `extensions/pi-cpac.ts`、Kimi 配置重写），用来在 CPA 地址或模型目录变化后一次对齐本地配置。不带参数只动已安装目标；`--all` 会对检测到的目标做同样的强制刷新（尚未安装的会装上）。`--max_context` 仍只对 `cpac install codex` 有效。
+- Codex 注入默认开启 multi-agent v2（写入 `[features.multi_agent_v2] enabled = true`，catalog 行打 `multi_agent_version: "v2"`）；`install codex --v2_off` 关掉 toml 并去掉 catalog 戳。v2 开着时会剥掉 `[agents] max_threads`（Codex 否则拒启动）。`cpac status` 对照 config 里的 `v2_off` / `max_context` 和 live toml / catalog。服务端还需在 CPA 配置中开启 `codex.optimize-multi-agent-v2`。
 - `--v2_models` 进入 arrow-key 复选框选择最多 5 个 spawn_agent 模型（勾选顺序即推荐顺序），选择结果存入配置文件的 `spawn_models`，注入时把这些模型排到 `codex-models.json` 最前——Codex 客户端只把 catalog 前 5 个可见模型广告为 spawn 覆盖项。
-- `restore` 必须带 `--target` 或 `--all`，卸掉指定（或全部）已注入目标。`--all` 时未安装的目标静默跳过。
-- `uninstall` 先用和 `cpac codex --setup` 相同的方向键选择器确认（默认 Cancel），再 `restore --all`，最后 `npm uninstall -g @yhong91/cpac`。不要用 `--target`。非终端取消。`--dry-run` 跳过确认。
+- `restore` 必须带 agent 名或 `--all`，卸掉指定（或全部）已注入目标。`--all` 时未安装的目标静默跳过。
+- `uninstall` 先用和 `cpac setup codex` 相同的方向键选择器确认（默认 Cancel），再 `restore --all`，最后 `npm uninstall -g @yhong91/cpac`。不要跟 agent 名；卸载的是 cpac 包本身。非终端取消。`--dry-run` 跳过确认。
 - `--home PATH` 临时把 `HOME` 指向给定目录，便于在隔离环境中试验。
 - `upgrade` 是发布后更新本机的一次性入口：查 npm → 需要时 `npm install -g` → 对**已接入**的 Codex / Pi / Kimi 执行 `sync`。已是最新也会 sync。不要先手动 `npm install -g` 再 `cpac sync`。`--check` 只报告版本，不安装也不 sync。没有已安装目标时跳过 sync，不报错。只刷新配置、不升 CLI 时用 `cpac sync`。
 
@@ -196,7 +197,7 @@ cpac claude -- -p "检查当前项目"
 #### 配置与清除
 
 ```bash
-cpac claude --setup                    # 交互式依次配置 Sonnet / Haiku / Opus，然后启动
+cpac setup claude                      # 交互式依次配置 Sonnet / Haiku / Opus，然后启动
 cpac claude clear                      # 重置所有覆盖，恢复自动选择
 ```
 
@@ -225,18 +226,18 @@ cpac codex exec "帮我写一个测试"
 #### 配置与清除
 
 ```bash
-cpac codex --setup                     # 交互式配置后注入并启动 Codex
+cpac setup codex                       # 交互式配置后注入并启动 Codex
 cpac codex clear                       # 还原 Codex 原生配置并关闭代理
 ```
 
-#### 传统注入命令
+#### 注入（`cpac install codex`）
 
 ```bash
-cpac inject [--v2_off] [--v2_models] [--max_context] [--config PATH]
-cpac restore --target codex
+cpac install codex [--v2_off] [--v2_models] [--max_context] [--config PATH]
+cpac restore codex
 ```
 
-`inject` 从远端 `/v1/models?client_version=1` 获取 Codex rich catalog，并启动只监听 `127.0.0.1` 的轻量转发代理。Codex 配置保留内置 `openai` provider，只写入根级 `model_catalog_json` 和：
+`install codex` 从远端 `/v1/models?client_version=1` 获取 Codex rich catalog，并启动只监听 `127.0.0.1` 的轻量转发代理。Codex 配置保留内置 `openai` provider，只写入根级 `model_catalog_json` 和：
 
 ```toml
 openai_base_url = "http://127.0.0.1:10101/v1"
@@ -244,21 +245,13 @@ openai_base_url = "http://127.0.0.1:10101/v1"
 
 Codex App/CLI 发给本地代理的 ChatGPT bearer 不会转发到 CPA；代理会改用 `CPA_API_KEY`，并将请求和流式响应原样转发到远端 CPA。这保留了 Codex App 的原生 `openai` provider 身份、历史和账号相关界面。已有用户自定义根级 `openai_base_url` 或非 `openai` 的活动 `model_provider` 时，CPAC 会拒绝覆盖。
 
-Codex App 的长驻 `app-server` 可能缓存旧目录。`inject` 会删除 `models_cache.json`；如果选择器仍未更新，请重启 Codex App。
+Codex App 的长驻 `app-server` 可能缓存旧目录。注入会删除 `models_cache.json`；如果选择器仍未更新，请重启 Codex App。
 
-注入命令可选 `--max_context`（`cpac inject --max_context` 或 `cpac install --target codex --max_context`，默认不带）：把 catalog 中 `max_context_window` 高于 `context_window` 的模型提升到上限，并把 `auto_compact_token_limit` 设为上限的 90%。Codex 把 `context_window` 当输入预算而非展示标签，上游默认保留保守运营值（如 GPT-5.6 家族 272k），带上该参数后可用到实测上限（约 921k，opencodex 实测）；90% 压缩线确保在硬上限前触发 auto-compact。不带参数注入的仍是原本上下文的目录。该参数仅限 codex，与其他 target 组合使用会直接报错。
+注入命令可选 `--max_context`（`cpac install codex --max_context`，默认不带）：把 catalog 中 `max_context_window` 高于 `context_window` 的模型提升到上限，并把 `auto_compact_token_limit` 设为上限的 90%。Codex 把 `context_window` 当输入预算而非展示标签，上游默认保留保守运营值（如 GPT-5.6 家族 272k），带上该参数后可用到实测上限（约 921k，opencodex 实测）；90% 压缩线确保在硬上限前触发 auto-compact。不带参数注入的仍是原本上下文的目录。该参数仅限 codex，与其他 target 组合使用会直接报错。
 
-`config.toml` 不存在时拒绝注入。当前是 native 时把原文件备份到 `state_dir/codex/config.toml`（覆盖更旧的 native 快照）；已注入后再 inject 不覆盖备份。kimi/grok 同样：没有旧配置不写空备份，native 覆盖旧快照，已接入则保留。Pi 只改 `settings.json` 的 `packages`，不备份。`restore --target codex`：若 `config.toml` 相对注入未改，按原 mode 逐字节还原备份；若用户在注入期间改过文件，只撤掉 CPAC 写入的 catalog、url 和标记。没有其它需要代理的 agent 时才关闭代理。
+`config.toml` 不存在时拒绝注入。当前是 native 时把原文件备份到 `state_dir/codex/config.toml`（覆盖更旧的 native 快照）；已注入后再装不覆盖备份。kimi/grok 同样：没有旧配置不写空备份，native 覆盖旧快照，已接入则保留。Pi 只改 `settings.json` 的 `packages`，不备份。`restore codex`：若 `config.toml` 相对注入未改，按原 mode 逐字节还原备份；若用户在注入期间改过文件，只撤掉 CPAC 写入的 catalog、url 和标记。没有其它需要代理的 agent 时才关闭代理。
 
-loopback 代理是 detached 用户进程，不安装系统服务。机器重启或进程意外退出后，`cpac status` 会报告 `loopback proxy stopped`；重新执行 `cpac inject` 或 `cpac kimi` / `cpac grok` 即可恢复。
-
-需要由现有进程管理器监督时，可使用前台入口：
-
-```bash
-cpac proxy
-```
-
-它复用 `state.json` 里记录的端口和实例身份；没有 loopback 记录时会拒绝启动。
+loopback 代理是 detached 用户进程，不安装系统服务。机器重启或进程意外退出后，`cpac status` 会报告 `loopback proxy stopped`；重新执行 `cpac install codex` 或 `cpac kimi` / `cpac grok` 即可恢复。
 
 默认路径：
 
@@ -293,7 +286,7 @@ cpac pi install
 在 `~/.pi/agent/settings.json` 的 `packages` 中加入 `npm:@yhong91/cpac`。Pi 启动时按 npm 包加载 `extensions/pi-cpac.ts`，从 CPA 动态注册模型。旧版写入的 `~/.pi/agent/extensions/pi-cpac.ts` 会在 install / restore 时删掉。卸载：
 
 ```bash
-cpac restore --target pi
+cpac restore pi
 ```
 
 尊重 `PI_CODING_AGENT_DIR`。扩展代码随 npm 包更新，已装过的副本用 `pi update npm:@yhong91/cpac`（或 `pi update --extensions`）。
@@ -306,10 +299,10 @@ cpac restore --target pi
 cpac kimi install
 ```
 
-它在 `~/.kimi-code/config.toml` 追加一个由 CPAC 管理的块，注册 `cpac` OpenAI 兼容 provider，并把 CPA 目录里的每个模型映射为一个 `cpac/<模型名>` 条目。带 `supported_reasoning_levels` 的模型会写入 `capabilities`、`support_efforts` 和 `default_effort`，否则 Kimi 只给 Claude 名套内置 thinking profile，其它模型会停在 thinking off 且无法改 effort。`base_url` 指向共享 loopback 代理，因此密钥不落盘。install 会写入 `state.json` 并在需要时启动代理，不必先 `cpac inject`。卸载与状态：
+它在 `~/.kimi-code/config.toml` 追加一个由 CPAC 管理的块，注册 `cpac` OpenAI 兼容 provider，并把 CPA 目录里的每个模型映射为一个 `cpac/<模型名>` 条目。带 `supported_reasoning_levels` 的模型会写入 `capabilities`、`support_efforts` 和 `default_effort`，否则 Kimi 只给 Claude 名套内置 thinking profile，其它模型会停在 thinking off 且无法改 effort。`base_url` 指向共享 loopback 代理，因此密钥不落盘。install 会写入 `state.json` 并在需要时启动代理，不必先单独注入 Codex。卸载与状态：
 
 ```bash
-cpac restore --target kimi
+cpac restore kimi
 ```
 
 Kimi Code 配置目录尊重 `KIMI_CODE_HOME` 环境变量。首次写入前若 `config.toml` 已存在，会在 `state_dir/kimi/config.toml` 保留一份原始快照（只存最早版本），万一文件损坏可手动复制回去。
@@ -358,7 +351,7 @@ Pi 扩展只从进程环境读取 `CPA_BASE_URL`（默认内置地址）和 `CPA
 使用自定义配置：
 
 ```bash
-cpac inject --config ./cpac.json
+cpac install codex --config ./cpac.json
 cpac claude --config ./cpac.json -- --model claude-sonnet-4-5
 ```
 

package/dist/agents.js

@@ -313,12 +313,12 @@ export async function runInstall(config, requested, options) {
     const eligible = TARGETS.filter((target) => target.detected()).map((target) => target.id);
     const selected = selectTargets(requested, options.all, eligible);
     if (selected.length === 0) {
-        throw new CPACError(`no supported targets detected; use --target ${TARGETS.map((target) => target.id).join(",")} or --all`);
+        throw new CPACError(`no supported targets detected; use: cpac install ${TARGETS.map((target) => target.id).join(" ")} or --all`);
     }
     // Catalog context lifting is Codex-specific; refuse to silently skip it on
     // other targets so the flag never gains cross-agent meaning.
     if (options.maxContext && selected.some((target) => target.id !== "codex")) {
-        throw new CPACError("--max_context is only valid with --target codex");
+        throw new CPACError("--max_context is only valid with codex");
     }
     for (const target of selected) {
         if (target.installed(config) && !options.force) {
@@ -353,7 +353,7 @@ export async function runSync(config, requested, options) {
 }
 export async function runRestore(config, requested, options) {
     if (requested.length === 0 && !options.all) {
-        throw new CPACError("restore requires --target <id> or --all");
+        throw new CPACError("restore requires an agent name or --all");
     }
     const eligible = TARGETS.filter((target) => target.installed(config)).map((target) => target.id);
     const selected = selectTargets(requested, options.all, eligible);

package/dist/cpac.js

@@ -4,14 +4,14 @@ import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { CPAC_VERSION, runCodexConfig, runDetect, runInstall, runRestore, runSync, runTargetLauncher, runUninstall, runUpgrade, } from "./agents.js";
-import { runClaude, runClaudeConfig, runClaudeModels, } from "./targets/claude.js";
-import { inject, multiAgentV2Enabled } from "./targets/codex.js";
+import { runClaude, runClaudeConfig } from "./targets/claude.js";
+import { multiAgentV2Enabled } from "./targets/codex.js";
 import { isGrokConfigInstalled } from "./targets/grok.js";
 import { isKimiConfigInstalled } from "./targets/kimi.js";
 import { runOpencode } from "./targets/opencode.js";
 import { isPiExtensionInstalled } from "./targets/pi.js";
 import { defaultConfigPath, loadConfig, originalBytes, pickSpawnModels, readState, saveSpawnModels, stateProxy, catalogMaxContextLive, } from "./config.js";
-import { proxyIsHealthy, runProxy, runProxyChild } from "./proxy.js";
+import { proxyIsHealthy, runProxyChild } from "./proxy.js";
 import { CPACError, expandUserPath, promptSecret, saveApiKeyExport, shellProfile, } from "./util.js";
 export { PROVIDER, loadConfig, saveSpawnModels, saveCodexSetup, liftContextWindows, reorderCatalog, sanitizeCatalogModalities, stampMultiAgentVersion, catalogMaxContextLive, readState, stateProxy, } from "./config.js";
 export { saveApiKeyExport } from "./util.js";
@@ -69,11 +69,11 @@ export async function status(config) {
     }
     console.log(`claude: ${keyConfigured ? "ready" : "not configured"}`);
     const piInstalled = isPiExtensionInstalled();
-    console.log(`pi: ${keyConfigured ? (piInstalled ? "ready" : "extension not installed; run: cpac install --target pi") : "not configured"}`);
+    console.log(`pi: ${keyConfigured ? (piInstalled ? "ready" : "extension not installed; run: cpac install pi") : "not configured"}`);
     const kimiInstalled = isKimiConfigInstalled();
-    console.log(`kimi: ${keyConfigured ? (kimiInstalled ? "ready" : "config not installed; run: cpac install --target kimi") : "not configured"}`);
+    console.log(`kimi: ${keyConfigured ? (kimiInstalled ? "ready" : "config not installed; run: cpac install kimi") : "not configured"}`);
     const grokInstalled = isGrokConfigInstalled();
-    console.log(`grok: ${keyConfigured ? (grokInstalled ? "ready" : "config not installed; run: cpac install --target grok") : "not configured"}`);
+    console.log(`grok: ${keyConfigured ? (grokInstalled ? "ready" : "config not installed; run: cpac install grok") : "not configured"}`);
     if (!state)
         return 1;
     const proxy = stateProxy(state);
@@ -82,9 +82,9 @@ export async function status(config) {
     return 0;
 }
 async function guide(config) {
-    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac <agent> [args...] Launch an agent (codex, kimi, grok, pi, claude, opencode) through CPA\n  cpac inject            Inject CPA into Codex and start its loopback proxy\n  cpac proxy             Run the injected loopback proxy in the foreground\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi, Grok)\n  cpac restore --target <id> | --all  Detach injected agents
+    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac <agent> [args...] Launch an agent (codex, kimi, grok, pi, claude, opencode) through CPA\n  cpac setup            Show current Codex/Claude setup; cpac setup <codex|claude> to change\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi, Grok)\n  cpac restore <id> | --all  Detach injected agents
   cpac detect            Show supported targets and install status
-  cpac install           Install CPA integration into detected targets
+  cpac install [ids...]  Install CPA into detected targets, or named agents
   cpac sync              Refresh installed Codex/Pi/Kimi/Grok injections from CPA
   cpac uninstall         Detach all agents, then remove the cpac package (confirms first)\n  cpac upgrade           Update cpac from npm and sync installed agents\n  cpac --help            Show command usage`);
     if (process.env[config.api_key_env]?.trim())
@@ -102,23 +102,52 @@ function usage() {
     return [
         "Usage: cpac",
         "       cpac <codex|kimi|grok|pi|claude|opencode> [args...]",
-        "       cpac <codex|claude> --setup [args...]",
-        "       cpac <codex|claude|kimi|grok|pi> clear",
-        "       cpac inject [--v2_off] [--v2_models] [--max_context] [--config PATH]",
-        "       cpac restore --target <id> | --all [--dry-run] [--config PATH]",
+        "              setup|--setup     configure Codex/Claude, then launch",
+        "              clear             restore native config",
+        "       cpac setup [--config PATH]     Show current Codex/Claude setup",
+        "              claude [--opus [M]] [--sonnet [M]] [--haiku [M]] [--reset]",
+        "              codex  [--v2_off] [--v2_models] [--max_context]",
+        "       cpac restore <id...> | --all [--dry-run] [--config PATH]",
         "       cpac status [--config PATH]",
-        "       cpac proxy [--config PATH]",
         "       cpac detect [--json] [--home PATH]",
-        "       cpac install [--target codex,pi,kimi,grok] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context] [--home PATH]",
-        "       cpac sync [--target codex,pi,kimi,grok] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context] [--home PATH]",
+        "       cpac install [codex|pi|kimi|grok...] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context] [--home PATH]",
+        "       cpac sync [codex|pi|kimi|grok...] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context] [--home PATH]",
         "       cpac uninstall [--dry-run]",
         "       cpac upgrade [--check]",
         "       cpac -v | --version",
         "",
-        "launch an agent directly with `cpac <agent> [args...]` (all args forwarded).",
-        "configure then launch with `cpac <codex|claude> --setup`; restore with `cpac <agent> clear`.",
+        "launch an agent with `cpac <agent> [args...]` (remaining args forwarded).",
+        "`setup`/`clear` hang off the agent; `cpac setup` with no agent prints current settings.",
     ].join("\n");
 }
+function setupUsage() {
+    return [
+        "Usage: cpac setup [--config PATH]     Show current Codex/Claude setup",
+        "              claude [--opus [M]] [--sonnet [M]] [--haiku [M]] [--reset]",
+        "              codex  [--v2_off] [--v2_models] [--max_context]",
+        "",
+        "Claude slots (saved to config, applied on every `cpac claude`):",
+        "  --opus        heavy reasoning / planning fallback (ANTHROPIC_DEFAULT_OPUS_MODEL)",
+        "  --sonnet      main conversation default (ANTHROPIC_DEFAULT_SONNET_MODEL)",
+        "  --haiku       high-frequency small tasks (ANTHROPIC_DEFAULT_HAIKU_MODEL)",
+        "",
+        "A slot without a value opens an arrow-key picker; --reset clears overrides.",
+        "No flags on a TTY opens the wizard, then launches.",
+    ].join("\n");
+}
+function printSetup(config, configPath) {
+    const claude = config.claude_models ?? {};
+    const auto = (value) => typeof value === "string" && value.trim() ? value.trim() : "(auto)";
+    console.log(`config  ${configPath}`);
+    console.log(`codex   spawn_models  ${(config.spawn_models ?? []).join(", ") || "(catalog order)"}`);
+    console.log(`codex   max_context   ${config.max_context ? "on" : "off"}`);
+    console.log(`codex   v2            ${config.v2_off ? "off" : "on"}`);
+    console.log(`claude  opus          ${auto(claude.opus)}`);
+    console.log(`claude  sonnet        ${auto(claude.sonnet)}`);
+    console.log(`claude  haiku         ${auto(claude.haiku)}`);
+    console.log("");
+    console.log(setupUsage());
+}
 function parseArgs(args) {
     if (args.length === 0) {
         return { command: "guide", configPath: defaultConfigPath() };
@@ -184,6 +213,12 @@ function parseArgs(args) {
             else if (arg === "--max_context" || arg === "--max-context") {
                 parsed.maxContext = true;
             }
+            else if (!arg.startsWith("-")) {
+                parsed.targets.push(...arg
+                    .split(",")
+                    .map((entry) => entry.trim())
+                    .filter(Boolean));
+            }
             else {
                 throw new CPACError(`unknown option: ${arg}`);
             }
@@ -297,7 +332,7 @@ function parseArgs(args) {
                     args: launchArgs,
                 };
             }
-            throw new CPACError(`${targetId} does not require setup (all CPA models are auto-synced). Run 'cpac ${targetId}' or 'cpac install --target ${targetId}'.`);
+            throw new CPACError(`${targetId} does not require setup (all CPA models are auto-synced). Run 'cpac ${targetId}' or 'cpac install ${targetId}'.`);
         }
         const passArgs = rest;
         if (targetId === "codex") {
@@ -323,31 +358,75 @@ function parseArgs(args) {
             args: passArgs,
         };
     }
-    if (args[0] === "claude-models") {
+    if (args[0] === "setup") {
         if (args.includes("-h") || args.includes("--help")) {
-            console.log([
-                "Usage: cpac claude --config [--opus [M]] [--sonnet [M]] [--haiku [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)",
-                "",
-                "Unset slots auto-select from the catalog: same-family claude model first,",
-                "then gemini → grok → luna → first model (opus stays unset without a match).",
-                "",
-                "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"));
+            console.log(setupUsage());
             return null;
         }
         let configPath = defaultConfigPath();
+        let agent;
+        const flags = [];
+        for (let index = 1; index < args.length; index++) {
+            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.startsWith("-") && agent === undefined) {
+                agent = arg;
+            }
+            else {
+                flags.push(arg);
+            }
+        }
+        if (agent === undefined) {
+            if (flags.length > 0)
+                throw new CPACError(`unknown option: ${flags[0]}`);
+            return { command: "setup-show", configPath };
+        }
+        if (agent !== "claude" && agent !== "codex") {
+            throw new CPACError("setup requires claude or codex");
+        }
+        args = ["setup", agent, ...flags];
+        if (agent === "codex") {
+            let v2Off = false;
+            let v2Models = false;
+            let maxContext = false;
+            for (let index = 2; index < args.length; index++) {
+                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 === "--v2_off" || arg === "--v2-off")
+                    v2Off = true;
+                else if (arg === "--v2_models" || arg === "--v2-models")
+                    v2Models = true;
+                else if (arg === "--max_context" || arg === "--max-context")
+                    maxContext = true;
+                else
+                    throw new CPACError(`unknown option: ${arg}`);
+            }
+            return {
+                command: "codex-config",
+                configPath,
+                v2Off,
+                v2Models,
+                maxContext,
+                reset: false,
+                interactive: true,
+                launch: true,
+                args: [],
+            };
+        }
         const models = {};
         const pick = [];
         let reset = false;
-        for (let index = 1; index < args.length; index += 1) {
+        for (let index = 2; index < args.length; index += 1) {
             const arg = args[index];
             if (arg === "--config") {
                 const value = args[++index];
@@ -375,15 +454,20 @@ function parseArgs(args) {
                 throw new CPACError(`unknown option: ${arg}`);
             }
         }
+        const interactive = !reset && Object.keys(models).length === 0 && pick.length === 0;
         return {
             command: "claude-config",
             configPath,
             models,
             pick,
             reset,
-            interactive: !reset && Object.keys(models).length === 0 && pick.length === 0,
+            interactive,
+            launch: interactive && !reset,
         };
     }
+    if (args[0] === "claude-models") {
+        throw new CPACError("claude-models was removed; use: cpac setup claude");
+    }
     if (args.includes("-h") || args.includes("--help")) {
         console.log(usage());
         return null;
@@ -416,20 +500,19 @@ function parseArgs(args) {
         else
             positional.push(args[index]);
     }
-    if (positional.length !== 1 ||
-        !["inject", "status", "proxy"].includes(positional[0])) {
-        throw new CPACError(usage());
+    if (positional.length === 1 && positional[0] === "inject") {
+        throw new CPACError("inject was removed; use: cpac install codex");
     }
-    if (positional[0] !== "inject" && (v2Off || v2Models || maxContext)) {
-        throw new CPACError("--v2_off / --v2_models / --max_context is only valid with inject or install");
+    if (positional.length === 1 && positional[0] === "proxy") {
+        throw new CPACError("proxy was removed; restart with: cpac install codex (or kimi / grok)");
     }
-    if (positional[0] === "inject") {
-        return { command: "inject", configPath, v2Off, v2Models, maxContext };
+    if (positional.length !== 1 || positional[0] !== "status") {
+        throw new CPACError(usage());
     }
-    return {
-        command: positional[0],
-        configPath,
-    };
+    if (v2Off || v2Models || maxContext) {
+        throw new CPACError("--v2_off / --v2_models / --max_context is only valid with install or setup");
+    }
+    return { command: "status", configPath };
 }
 export async function main(args = process.argv.slice(2)) {
     try {
@@ -491,10 +574,14 @@ export async function main(args = process.argv.slice(2)) {
             });
         if (parsed.command === "uninstall") {
             if (parsed.targets.length || parsed.all) {
-                throw new CPACError("uninstall removes the cpac package; detach agents with: cpac restore --target <id> | --all");
+                throw new CPACError("uninstall removes the cpac package; detach agents with: cpac restore <id> | --all");
             }
             return await runUninstall(config, { dryRun: parsed.dryRun });
         }
+        if (parsed.command === "setup-show") {
+            printSetup(config, parsed.configPath);
+            return 0;
+        }
         if (parsed.command === "upgrade")
             return await runUpgrade(config, parsed.check);
         if (parsed.command === "claude")
@@ -543,23 +630,7 @@ export async function main(args = process.argv.slice(2)) {
             parsed.command === "pi") {
             return await runTargetLauncher(config, parsed.command, parsed.args);
         }
-        if (parsed.command === "claude-models")
-            return await runClaudeModels(parsed);
-        if (parsed.command === "proxy")
-            return await runProxy(config);
-        if (parsed.command === "inject") {
-            let injectConfig = config;
-            if (parsed.v2Models) {
-                const picked = await pickSpawnModels(config);
-                saveSpawnModels(parsed.configPath, picked);
-                console.log(`spawn_models saved to ${parsed.configPath}: ${picked.join(", ")}`);
-                injectConfig = { ...config, spawn_models: picked };
-            }
-            await inject(injectConfig, parsed.v2Off, parsed.maxContext);
-        }
-        else
-            return await status(config);
-        return 0;
+        return await status(config);
     }
     catch (error) {
         console.error(`cpac: ${error instanceof Error ? error.message : String(error)}`);

package/package.json

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