oh-my-agent-web 0.7.0 → 1.0.2

package/dist/server/approval/rules.js

@@ -11,9 +11,9 @@
  */
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-export const RULES_FILE = "approval-rules.json";
-export const RULES_VERSION = 1;
-export function rulesPath(dataDir) {
+const RULES_FILE = "approval-rules.json";
+const RULES_VERSION = 1;
+function rulesPath(dataDir) {
     return join(dataDir, RULES_FILE);
 }
 function isRule(value) {
@@ -23,7 +23,7 @@ function isRule(value) {
     return typeof candidate.scopeKey === "string" && candidate.scopeKey !== "";
 }
 /** 纯函数：解析规则文件；坏内容一律返回空规则（不抛错） */
-export function parseRules(text) {
+function parseRules(text) {
     let parsed;
     try {
         parsed = JSON.parse(text);
@@ -71,15 +71,3 @@ export function createFileRuleStore(dataDir) {
         },
     };
 }
-/** 内存版（单测 / 不落盘运行） */
-export function createMemoryRuleStore(seed = []) {
-    let rules = [...seed];
-    return {
-        async load() {
-            return [...rules];
-        },
-        async save(next) {
-            rules = [...next];
-        },
-    };
-}

package/dist/server/approval/scope.js

@@ -12,7 +12,7 @@
 import { isAbsolute, join, resolve } from "node:path";
 import { isReadOnlyCommand } from "./read-only.js";
 /** 不问的工具：只读类 */
-export const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]);
+const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]);
 const SUMMARY_CHARS = 200;
 const RISK_NOTES = {
     bash: "跑命令会修改你的机器（装包、删文件、改配置都算），确认后才能执行",
@@ -48,7 +48,7 @@ const ENV_ASSIGNMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
  * 以及路径前缀。
  * 例：`FOO=1 npm run build` → `npm`；`sudo -u root npm ci` → `npm`；`/usr/bin/git push -f` → `git`
  */
-export function commandExecutable(command) {
+function commandExecutable(command) {
     const tokens = command.trim().split(/\s+/).filter(Boolean);
     let index = 0;
     skipLeading: for (;;) {
@@ -81,7 +81,7 @@ export function commandExecutable(command) {
     return base === "" ? "(空命令)" : base;
 }
 /** 目标路径所在目录（相对路径按工作区根解析） */
-export function targetDirectory(path, workspace) {
+function targetDirectory(path, workspace) {
     if (path === "")
         return workspace;
     const absolute = isAbsolute(path) ? path : resolve(join(workspace, path));

package/dist/server/cli-config.js

@@ -9,8 +9,8 @@
  */
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-export const PASSWORD_FILE = "password";
-export const ALLOWED_HOSTS_FILE = "allowed-hosts";
+const PASSWORD_FILE = "password";
+const ALLOWED_HOSTS_FILE = "allowed-hosts";
 const readTrimmed = async (path) => {
     try {
         const text = await readFile(path, "utf8");
@@ -23,7 +23,7 @@ const readTrimmed = async (path) => {
     }
 };
 /** 纯读取：把两个文件都试一遍（不存在就给空值） */
-export async function readStoredOptions(dataDir) {
+async function readStoredOptions(dataDir) {
     const password = await readTrimmed(join(dataDir, PASSWORD_FILE));
     const rawHosts = await readFile(join(dataDir, ALLOWED_HOSTS_FILE), "utf8").catch(() => "");
     const allowedHosts = rawHosts

package/dist/server/cli-info.js

@@ -1,5 +1,5 @@
 /**
- * `omaw` 的「查询类命令」：status / version / upgrade。
+ * `aw` 的「查询类命令」：status / version / upgrade。
  *
  * 为什么单独成文件：cli.ts 已经要管参数解析、前后台切换、停止/重启，
  * 再加状态查询就过 400 行护栏了（ADR-0010：一个文件只干一件事）。
@@ -35,14 +35,14 @@ function formatUptime(ms) {
         return `${minutes} 分 ${total % 60} 秒`;
     return `${total} 秒`;
 }
-/** `omaw status`：进程状态 + 服务端自报的事实（引擎 / 会话数 / 工作区） */
+/** `aw status`：进程状态 + 服务端自报的事实（引擎 / 会话数 / 工作区） */
 export async function showStatus(options) {
     const { dataDir, probeHost } = options;
     const lock = await readLock(dataDir);
     console.log(`oh-my-agent-web v${packageMeta().version}  ·  数据目录 ${dataDir}`);
     if (!lock) {
         console.log("状态：未运行（没有 server.lock）");
-        console.log("  启动：omaw -d");
+        console.log("  启动：aw -d");
         return;
     }
     if (!defaultIsAlive(lock.pid)) {
@@ -55,7 +55,7 @@ export async function showStatus(options) {
     console.log(`  地址 http://${probeHost}:${lock.port}`);
     if (health) {
         const running = health.version ?? "unknown";
-        console.log(`  版本 v${running}（磁盘上是 v${onDisk}${running === onDisk ? "" : "，重启后生效：omaw restart -d"}）`);
+        console.log(`  版本 v${running}（磁盘上是 v${onDisk}${running === onDisk ? "" : "，重启后生效：aw restart -d"}）`);
         console.log(`  引擎 ${health.engine} · 协议 v${health.protocolVersion} · 会话 ${health.sessions} · 对话 ${health.conversations}`);
         console.log(`  工作区 ${health.workspace}`);
     }
@@ -63,12 +63,12 @@ export async function showStatus(options) {
         console.log("  ⚠ 进程在，但 /api/health 没通（可能还在启动，或端口没监听成功）");
     }
 }
-/** `omaw version` */
+/** `aw version` */
 export function showVersion() {
     console.log(`oh-my-agent-web v${packageMeta().version}（node ${process.version} · ${process.platform}/${process.arch}）`);
 }
 /**
- * `omaw upgrade`：升级**全局安装**的这个包。
+ * `aw upgrade`：升级**全局安装**的这个包。
  *
  * 三条底线：
  *   1. 只跑 `npm i -g <包名>@latest`，不做别的（不替你重启，重启会打断正在跑的回合）；
@@ -80,8 +80,8 @@ export async function upgrade() {
     const meta = packageMeta();
     if (meta.private) {
         console.error(`这个包是 private（${meta.name}@${meta.version}），没有发布到 npm，无法从 npm 升级。`);
-        console.error("  · 本地 / git 安装：回到源码目录重新 `npm i -g .`，然后 `omaw restart -d`");
-        console.error("  · 想用 npm 升级：先把 package.json 的 name 改成自己 scope 下的名字（如 @you/omaw）并发布");
+        console.error("  · 本地 / git 安装：回到源码目录重新 `npm i -g .`，然后 `aw restart -d`");
+        console.error("  · 想用 npm 升级：先把 package.json 的 name 改成自己 scope 下的名字（如 @you/aw）并发布");
         return 1;
     }
     console.log(`当前 v${meta.version}，正在安装 npm 上的最新版 ${meta.name} …`);
@@ -99,6 +99,6 @@ export async function upgrade() {
         console.error("升级失败（网络 / 权限 / 包名不存在都可能）。");
         return code;
     }
-    console.log(`已升级到 v${packageMeta().version}（新进程才用新版：omaw restart -d）`);
+    console.log(`已升级到 v${packageMeta().version}（新进程才用新版：aw restart -d）`);
     return 0;
 }

package/dist/server/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * 命令行入口（ADR-0031）：`oh-my-agent-web` / 简写 **`omaw`** / **`agent-web`** [命令] [选项]。
+ * 命令行入口（ADR-0031）：`oh-my-agent-web` / 简写 **`aw`** / **`agent-web`** [命令] [选项]。
  * 三个 bin 指向同一个文件，完全等价（`agent-web` 给不想记缩写的人用）。
  *
  * 命令：start（默认）/ stop / restart / status / version / upgrade / help
@@ -15,8 +15,11 @@
  *   -P, --password <pwd>  AGENT_WEB_PASSWORD   非本机访问时的登录密码
  *       --allow-host <h>  AGENT_WEB_ALLOWED_HOSTS  额外允许的域名（可重复）
  *       --data-dir <dir>  AGENT_WEB_DATA_DIR   默认 ~/.oh-my-agent-web
- *   -d, --detach          启动后转入后台（关掉终端也继续跑）
+ *   -f, --foreground      前台运行（日志直接在终端，Ctrl-C 退出）
+ *   -d, --detach          后台运行（**现在就是默认**，留着给老脚本）
+ *       --no-open         不要在浏览器里打开页面
  *
+ * 默认行为：**后台起来 + 打开浏览器**（终端立刻还给你）；`-f` 才留在前台。
  * 后台模式只是「spawn 一个脱离终端的自己 + 等它写好 server.lock」：
  * 真正的事实源仍然是锁文件，所以 stop / restart 对前台、后台一视同仁。
  *
@@ -34,13 +37,13 @@ import { migrateLegacyDataDir } from "./util/data-dir.js";
 import { DEFAULT_DATA_DIR_NAME } from "./util/env.js";
 import { fetchHealth, showStatus, showVersion, upgrade } from "./cli-info.js";
 import { defaultIsAlive, readLock } from "./session/lock.js";
-const USAGE = `用法: agent-web [命令] [选项]        （agent-web / omaw / oh-my-agent-web 三个命令完全等价）
+const USAGE = `用法: agent-web [命令] [选项]        （agent-web / aw / oh-my-agent-web 三个命令完全等价）
 
 命令:
-  start              启动（默认；前台运行，Ctrl-C 退出）
-  start -d           启动并转入后台（关掉终端也继续跑，日志写到 <dataDir>/daemon.log）
+  start              启动（默认；后台运行并打开页面，终端立刻还给你）
+  start -f           前台运行（日志直接打在终端，Ctrl-C 退出）
   stop               停止正在跑的实例（读 dataDir/server.lock 里的 pid）
-  restart            先停再起（带 -d 则后台起）
+  restart            先停再起（默认仍后台；带 -f 则前台）
   status             看状态：pid / 端口 / 已运行多久 / 引擎 / 会话数 / 工作区
   version            看版本号（-v / --version 同义）
   upgrade            升级全局安装（npm i -g <包名>@latest；private 包会拒绝并提示怎么做）
@@ -52,20 +55,25 @@ const USAGE = `用法: agent-web [命令] [选项]        （agent-web / omaw /
   -P, --password <pwd> 访问密码            AGENT_WEB_PASSWORD
       --allow-host <h> 额外允许的域名      AGENT_WEB_ALLOWED_HOSTS（可多次 / 逗号分隔）
       --data-dir <dir> 数据目录            AGENT_WEB_DATA_DIR（默认 ~/.oh-my-agent-web）
-  -d, --detach         启动后转入后台（日志写到 <dataDir>/daemon.log）
+  -f, --foreground     前台运行（Ctrl-C 退出）
+  -d, --detach         后台运行（现在就是默认，留着给老脚本）
+      --no-open        不要在浏览器里打开页面
 
 没给 --password / --allow-host 时，会读数据目录里的 password / allowed-hosts 兜底
-（设一次就一直在，重启不必重复输入）。
+（设一次就一直在，重启不必重复输入）。远程第一次打开时若还没设密码，页面会让你先设一个。
 
 例：
-  omaw -d -H 0.0.0.0 -P 你的密码 --allow-host agent.example.com   # 后台起，供外网访问
-  omaw status && omaw restart -d                                  # 看完状态再重启
-  omaw stop                                                       # 停掉（前台/后台都行）`;
-export function parseArgs(argv) {
+  aw                                                    # 后台起 + 打开页面
+  aw -f                                                 # 前台起（Ctrl-C 退出）
+  aw -H 0.0.0.0 --allow-host agent.example.com           # 后台起，供外网访问（首次打开会先让你设密码）
+  aw status && aw restart                               # 看完状态再重启
+  aw stop                                               # 停掉（前台/后台都行）`;
+function parseArgs(argv) {
     const env = {};
     let command = "start";
     let help = false;
-    let detach = false;
+    let foreground = false;
+    let open = true;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i] ?? "";
         const takeValue = () => {
@@ -86,7 +94,13 @@ export function parseArgs(argv) {
         else if (arg === "-h" || arg === "--help" || arg === "help")
             help = true;
         else if (arg === "-d" || arg === "--detach" || arg === "--daemon")
-            detach = true;
+            foreground = false;
+        else if (arg === "-f" || arg === "--foreground" || arg === "--fg")
+            foreground = true;
+        else if (arg === "--no-open")
+            open = false;
+        else if (arg === "--open")
+            open = true;
         else if (arg === "-p" || arg === "--port")
             env.AGENT_WEB_PORT = takeValue();
         else if (arg === "-H" || arg === "--host")
@@ -104,7 +118,7 @@ export function parseArgs(argv) {
         else
             throw new Error(`未知命令：${arg}`);
     }
-    return { command, env, help, detach };
+    return { command, env, help, foreground, open };
 }
 function dataDir() {
     const fromEnv = process.env.AGENT_WEB_DATA_DIR;
@@ -223,12 +237,24 @@ async function waitForHttp(host, port, deadline) {
     }
     return false;
 }
-/** 拼出「停止」的准确命令：沿用本次参数（去掉 -d 与命令词），密码一律打成 *** */
+/** 拼出「停止」的准确命令：沿用本次参数（去掉前后台/开页开关与命令词），密码一律打成 *** */
 function stopHint(rawArgv) {
     const rest = [];
+    const IGNORED = new Set([
+        "-d",
+        "--detach",
+        "--daemon",
+        "-f",
+        "--foreground",
+        "--fg",
+        "--open",
+        "--no-open",
+        "start",
+        "restart",
+    ]);
     for (let i = 0; i < rawArgv.length; i += 1) {
         const arg = rawArgv[i] ?? "";
-        if (["-d", "--detach", "--daemon", "start", "restart"].includes(arg))
+        if (IGNORED.has(arg))
             continue;
         // 行命令会留在终端滚动区和 shell 历史里，密码不能跟着回显
         if (arg === "-P" || arg === "--password") {
@@ -243,10 +269,65 @@ function stopHint(rawArgv) {
     const prefix = base === "cli.js" ? `node ${entry}` : base;
     return [prefix, "stop", ...rest].join(" ");
 }
-async function startDetached(rawArgv) {
+/** 后台子进程要带上的开关（它自己不能再往后台上套娃，也不要再开一次浏览器） */
+const CHILD_FLAGS = ["-f", "--no-open"];
+/** 子进程要把这些去掉：前后台/开页开关 + 命令词（它只需要「起」，不需要再重启一次） */
+const PROCESS_FLAGS = new Set([
+    "-d",
+    "--detach",
+    "--daemon",
+    "-f",
+    "--foreground",
+    "--fg",
+    "--open",
+    "--no-open",
+    "start",
+    "restart",
+]);
+/**
+ * 打开系统浏览器。
+ *
+ * 什么时候**不**开：`--no-open`、没有终端（CI / 被别的程序拉起）、Linux 上没有图形会话。
+ * 打不开也不报错 —— URL 已经打在终端里了，复制一下就能用。
+ */
+function openBrowser(url) {
+    if (!process.stdout.isTTY || process.env.CI)
+        return;
+    try {
+        if (process.platform === "darwin") {
+            spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+        }
+        else if (process.platform === "win32") {
+            // `start` 的第一个参数是窗口标题，必须留一个空串，否则带引号的 URL 会被当成标题
+            spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true, windowsHide: true }).unref();
+        }
+        else if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) {
+            spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+        }
+    }
+    catch {
+        // 没装 xdg-open / 权限不够：忽略
+    }
+}
+/** 前台模式：等服务真的在听，再开浏览器（起不来就不开，日志里已经有原因了） */
+function openWhenReady() {
+    const probeHost = probeHostOf();
+    const deadline = Date.now() + 20_000;
+    void (async () => {
+        while (Date.now() < deadline) {
+            const lock = await readLock(dataDir());
+            if (lock && (await fetchHealth(probeHost, lock.port, 1000))) {
+                openBrowser(`http://${probeHost}:${lock.port}`);
+                return;
+            }
+            await sleep(200);
+        }
+    })();
+}
+async function startDetached(rawArgv, open) {
     const script = fileURLToPath(import.meta.url);
-    // 把自己再起一遍，但去掉 -d（否则子进程会继续往后台上套娃）
-    const args = rawArgv.filter((arg) => arg !== "-d" && arg !== "--detach" && arg !== "--daemon");
+    // 把自己再起一遍，但去掉前后台/开页开关 —— 子进程固定「前台 + 不开页」（开页是父进程的事）
+    const args = [...rawArgv.filter((arg) => !PROCESS_FLAGS.has(arg)), ...CHILD_FLAGS];
     const log = daemonLogPath();
     mkdirSync(dirname(log), { recursive: true });
     const fd = openSync(log, "a");
@@ -279,6 +360,8 @@ async function startDetached(rawArgv) {
             console.log(`  → 打开 http://${probeHost}:${lock.port}`);
             console.log(`  → 日志 ${log}`);
             console.log(`  → 停止：${stopHint(rawArgv)}`);
+            if (open)
+                openBrowser(`http://${probeHost}:${lock.port}`);
             return;
         }
     }
@@ -330,11 +413,13 @@ async function main() {
         // 等端口真正释放再起，否则会撞 EADDRINUSE
         await sleep(400);
     }
-    // start / restart：默认**在前台**跑（日志与退出码都在同一条线上）
-    if (parsed.detach) {
-        await startDetached(process.argv.slice(2));
+    // start / restart：默认**后台**跑（终端立刻还给你），`-f` 才留在前台
+    if (!parsed.foreground) {
+        await startDetached(process.argv.slice(2), parsed.open);
         return;
     }
+    if (parsed.open)
+        openWhenReady();
     await import("./index.js");
 }
 // 被当脚本执行时才 main（被 import 时什么都不做）

package/dist/server/engine/builtin.js

@@ -1,9 +1,19 @@
+import { createClaudeEngine } from "./claude.js";
+import { probeCliVersion, probePackageVersion } from "./cli-version.js";
 import { createCodexEngine } from "./codex.js";
 import { createDshEngine } from "./dsh.js";
 import { createFakeEngine } from "./fake.js";
 import { createOpencodeEngine } from "./opencode.js";
 import { createPiSdkEngine } from "./pi-sdk.js";
+import { piSdkVersion } from "./pi-version.js";
 import { createEngineRegistry, FAKE_CAPABILITIES, PI_CAPABILITIES } from "./registry.js";
+/**
+ * ACP 适配器（claude-code-acp）的版本：它不认 `--version`（直接去握手），
+ * 所以读 bin 旁边的 package.json —— 与握手给的 `agentInfo.version` 是同一个数。
+ */
+function claudeVersionOf(bin) {
+    return Promise.resolve(probePackageVersion(bin ?? "claude-code-acp"));
+}
 export function createBuiltinEngineRegistry(options) {
     return createEngineRegistry([
         {
@@ -12,6 +22,8 @@ export function createBuiltinEngineRegistry(options) {
             badge: "PI",
             description: "完整插件与技能生态、工具延迟加载、审批门禁、目标模式与子代理",
             providerConfig: true, // 模型 / provider 配置由本工作台管理（models-store.json + auth.json）
+            // 版本同步就有（SDK 导出的 VERSION），不用探测
+            version: () => piSdkVersion(),
             capabilities: PI_CAPABILITIES,
             create: () => createPiSdkEngine({
                 onNotice: (text, level) => {
@@ -19,6 +31,7 @@ export function createBuiltinEngineRegistry(options) {
                     options.onNotice(text, level);
                 },
                 ...(options.skillPaths ? { skillPaths: options.skillPaths } : {}),
+                ...(options.thinkCount ? { thinkCount: options.thinkCount } : {}),
             }),
         },
         ...(options.codex
@@ -30,6 +43,8 @@ export function createBuiltinEngineRegistry(options) {
                     // 能力如实写：审批是命令/文件级的（比 pi 粗一档），没有 provider 面板
                     description: options.codex.description ?? "codex 官方 agent：独立 loop 与沙箱，会话与 Codex Desktop / CLI 共用",
                     providerConfig: false,
+                    // 版本号跟本机的 codex CLI 走（`codex --version` → `codex-cli 0.162.1`）
+                    version: () => probeCliVersion(options.codex?.bin ?? "codex"),
                     // steer: false —— 底层（JSON-RPC / ACP）没有「插进正在跑的这一轮」的语义，宿主会降级成排队
                     capabilities: {
                         approvals: true,
@@ -38,8 +53,19 @@ export function createBuiltinEngineRegistry(options) {
                         thinkingLevel: true,
                         resume: true,
                         steer: false,
+                        // 真回合探针：临时 thread 发一句 ping，量 TTFT / 出字速度（不偷 codex 的凭证，见 port.ts）
+                        modelProbe: true,
+                        // codex 自带多代理（spawn_agent 那一套）：显示成面板卡片 + 按会话注入模板
+                        subagents: true,
+                        // 它的隔离是「沙箱 + 审批」，不是逐工具白名单 → 模板里的工具勾选对 codex 不生效
+                        subagentToolWhitelist: false,
                     },
-                    create: () => createCodexEngine({ client: options.codex?.client, log: options.onLog }),
+                    create: () => createCodexEngine({
+                        client: options.codex?.client,
+                        log: options.onLog,
+                        ...(options.codex?.subagentPolicy ? { subagentPolicy: options.codex.subagentPolicy } : {}),
+                        ...(options.thinkCount ? { thinkCount: options.thinkCount } : {}),
+                    }),
                 },
             ]
             : []),
@@ -52,6 +78,8 @@ export function createBuiltinEngineRegistry(options) {
                     description: options.dsh.description ??
                         "DeepSeek 官方 agent（ACP）：模型与思考档可切、权限逐次确认，会话与 dsh web/tui 共用",
                     providerConfig: false,
+                    // 版本号跟本机的 dsh CLI 走（`dsh --version` → `0.2.0-rc.2`）
+                    version: () => probeCliVersion(options.dsh?.bin ?? "dsh"),
                     // steer: false —— 底层（JSON-RPC / ACP）没有「插进正在跑的这一轮」的语义，宿主会降级成排队
                     capabilities: {
                         approvals: true,
@@ -75,6 +103,8 @@ export function createBuiltinEngineRegistry(options) {
                     description: options.opencode.description ??
                         "opencode 官方 agent（ACP）：自带工具与 MCP/插件生态，模型与思考档可切，会话与 opencode CLI / TUI 共用；审批取决于 opencode 自身 permission 配置",
                     providerConfig: false,
+                    // 版本号跟本机的 opencode CLI 走（`opencode --version` → `1.19.0`）
+                    version: () => probeCliVersion(options.opencode?.bin ?? "opencode"),
                     // 没有子代理面板（ACP 不暴露 task 子代理的运行视图）→ subagents 不写，界面就不出现那块
                     // steer: false —— 底层（JSON-RPC / ACP）没有「插进正在跑的这一轮」的语义，宿主会降级成排队
                     capabilities: {
@@ -95,12 +125,45 @@ export function createBuiltinEngineRegistry(options) {
                 },
             ]
             : []),
+        ...(options.claude
+            ? [
+                {
+                    name: "claude",
+                    label: "Claude Code",
+                    // 短标签沿用 DSH / OC 的风格：长名字会把顶栏那枚胶囊撑开
+                    badge: "CC",
+                    // 能力如实写：模型可切（session/set_model），**没有思考档**（协议不暴露），没有子代理面板
+                    description: options.claude.description ??
+                        "Claude Code（ACP）：Anthropic 官方 agent，模型可切、工具逐次确认，会话与 claude CLI 共用；思考档与子代理面板不暴露",
+                    providerConfig: false,
+                    // 版本 = ACP 适配器（claude-code-acp）的版本，与握手给的 "agentInfo.version" 一致
+                    version: () => claudeVersionOf(options.claude?.bin),
+                    // steer: false —— 底层（JSON-RPC / ACP）没有「插进正在跑的这一轮」的语义，宿主会降级成排队
+                    capabilities: {
+                        approvals: true,
+                        tools: true,
+                        modelSwitch: true,
+                        thinkingLevel: false, // ACP 面里 Claude 不暴露 thinking/effort
+                        resume: true,
+                        steer: false,
+                    },
+                    create: () => createClaudeEngine({
+                        client: options.claude?.client,
+                        bin: options.claude?.bin,
+                        args: options.claude?.args,
+                        model: options.claude?.model,
+                        log: options.onLog,
+                    }),
+                },
+            ]
+            : []),
         {
             name: "fake",
             label: "假引擎",
             badge: "FAKE",
             description: "零 token 的脚本化引擎：没有真实模型，只用来验证协议、工具与审批流程",
             providerConfig: false,
+            version: () => "fake",
             hidden: true, // 测试引擎：AGENT_WEB_ENGINE=fake 仍可选，但不进普通用户的切换面板
             capabilities: FAKE_CAPABILITIES,
             create: () => createFakeEngine(),

package/dist/server/engine/catalog-probe.js

@@ -0,0 +1,34 @@
+/**
+ * 「模型目录」探针（dsh / opencode / claude 三个 ACP 引擎共用）。
+ *
+ * 为什么需要它：这三个引擎**只在 `session/new` / `session/resume` 的返回里**给出模型表
+ * （opencode / dsh 是 `configOptions`，claude 是 `models`），没有会话就问不到。
+ * 于是刚切到引擎、还没开会话时，模型下拉是空的 —— 界面上就是「模型未就绪」，
+ * 用户以为功能坏了（实测复现：`prewarm` 只连上子进程，`listModels()` 回 0 条；
+ * 建完会话立刻变成 219 / 3 / 5 条）。
+ *
+ * 做法：在**临时目录**里开一个一次性会话，把目录抄下来，然后立刻关掉并删掉：
+ *   - 临时目录由 `isScratchCwd` 判定 → 这些探针会话不会进侧栏（三个引擎的清单都按这条过滤）；
+ *   - 删掉是免得在引擎自己的历史里留一条空会话（claude 删 JSONL、opencode 有 `session delete`、
+ *     dsh 删会话目录，各自见调用处）。
+ *
+ * 代价（如实记在这里，免得以后有人以为它是免费的）：
+ *   - 每个引擎实例**只探一次**（`reloadModels` / `dispose` 会重置），不是每帧都建会话；
+ *   - 时间：claude / dsh ~1s，opencode 的 `session/new` 要 4~6s（它自己启动就要扫配置），
+ *     所以这一步放在切引擎的那条路径上（界面本来就在等），不放在发消息的路径上。
+ */
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** 探针目录前缀（`isScratchCwd` 判定 → 侧栏不显示这类目录） */
+const PROBE_CWD_PREFIX = "agent-web-models-";
+/** 在临时工作区里跑一段逻辑，跑完把目录删掉（失败也删） */
+export async function withProbeCwd(run) {
+    const cwd = await mkdtemp(join(tmpdir(), PROBE_CWD_PREFIX));
+    try {
+        return await run(cwd);
+    }
+    finally {
+        await rm(cwd, { recursive: true, force: true }).catch(() => undefined);
+    }
+}