oh-my-agent-web 0.7.0 → 1.0.2

package/dist/server/engine/dsh-log.js

@@ -20,11 +20,11 @@
  * ⚠️ `user/message` 里大量是**系统注入**（runtime-context / skill-catalog / goal …）：
  * 只有 `source.kind === "user"` 才是真的用户发言，其余一律不进对话区、也不拿来取标题。
  */
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, rmdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { zstdDecompressSync } from "node:zlib";
 /** projectKey(cwd) —— 镜像 DSH 的会话目录命名：分隔符 → "-"，其它非法字符 → ~XXXX（大写 hex） */
-export function projectKey(cwd) {
+function projectKey(cwd) {
     let readable = "";
     let separatorRun = false;
     for (let i = 0; i < cwd.length; i += 1) {
@@ -47,7 +47,7 @@ export function projectKey(cwd) {
     return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
 }
 /** 多帧 zstd 解压：按魔数切帧；切错了就向后合并重试（数据体里可能误命中魔数） */
-export function zstdDecompressAll(buf) {
+function zstdDecompressAll(buf) {
     const MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
     const starts = [];
     for (let i = 0; i + 4 <= buf.length; i += 1) {
@@ -181,39 +181,6 @@ export function firstUserText(log, maxChars = 30) {
     }
     return null;
 }
-/** 递归列出目录下的会话日志文件（按 mtime 倒序） */
-export function findSessionFiles(root) {
-    if (!existsSync(root))
-        return [];
-    const out = [];
-    const walk = (dir, depth) => {
-        if (depth > 3)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory())
-                walk(full, depth + 1);
-            else if (entry.name.endsWith(".jsonl.zstd") || entry.name.endsWith(".jsonl"))
-                out.push(full);
-        }
-    };
-    walk(root, 0);
-    return out.sort((left, right) => {
-        try {
-            return statSync(right).mtimeMs - statSync(left).mtimeMs;
-        }
-        catch {
-            return 0;
-        }
-    });
-}
 /** 按会话 id 找它的日志文件：优先用 cwd 直算目录，否则在 sessions 下一层找 */
 export function locateSessionFile(sessionRoot, sessionId, cwd) {
     const candidates = [];
@@ -243,3 +210,47 @@ export function locateSessionFile(sessionRoot, sessionId, cwd) {
     }
     return null;
 }
+/**
+ * 删掉一条会话在 DSH 自己存储里的目录（`<sessions>/<projectKey>/<sessionId>/`）。
+ *
+ * 用途只有一个：**模型目录探针**临时开的那条会话（见 catalog-probe.ts）别留在
+ * DSH 的 web / tui 历史里。做法是先按 cwd 直算、再扫一层（与 locateSessionFile 同样的
+ * 两条路径）—— 目录命名细节不对也知道要删哪个，删不掉就算了，侧栏还要按临时目录过滤。
+ *
+ * 返回 true = 真的删掉了。
+ */
+export function deleteDshSession(sessionRoot, sessionId, cwd) {
+    const groups = [];
+    if (cwd)
+        groups.push(projectKey(cwd));
+    try {
+        for (const entry of readdirSync(sessionRoot, { withFileTypes: true })) {
+            if (entry.isDirectory() && !groups.includes(entry.name))
+                groups.push(entry.name);
+        }
+    }
+    catch {
+        return false;
+    }
+    let removed = false;
+    for (const group of groups) {
+        const dir = join(sessionRoot, group, sessionId);
+        if (!existsSync(dir))
+            continue;
+        try {
+            rmSync(dir, { recursive: true, force: true });
+            removed = true;
+            // 组目录空了就一起删（DSH 自己也会留一堆空目录，但没必要再添一个）
+            try {
+                rmdirSync(join(sessionRoot, group));
+            }
+            catch {
+                /* 还有别的会话在里头 */
+            }
+        }
+        catch {
+            /* 删不掉就算了 */
+        }
+    }
+    return removed;
+}

package/dist/server/engine/dsh-map.js

@@ -34,7 +34,7 @@ export function parseModelValue(value) {
     }
 }
 /** 我们在界面上用的模型 id：`provider/model`（可读、可回填） */
-export function modelIdOf(choice) {
+function modelIdOf(choice) {
     const parsed = parseModelValue(choice.value);
     return parsed ? `${parsed.provider}/${parsed.model}` : null;
 }
@@ -51,7 +51,7 @@ export function modelOptions(config) {
         models.push({
             id,
             label: choice.name ?? id,
-            ...((current && id === `${current.provider}/${current.model}`) ? { current: true } : {}),
+            ...(current && id === `${current.provider}/${current.model}` ? { current: true } : {}),
         });
     }
     return models;
@@ -121,9 +121,7 @@ function textOfContent(update) {
     if (!content)
         return "";
     if (Array.isArray(content)) {
-        return content
-            .map((item) => (item?.content?.type === "text" ? (item.content.text ?? "") : ""))
-            .join("");
+        return content.map((item) => (item?.content?.type === "text" ? (item.content.text ?? "") : "")).join("");
     }
     return content.type === "text" ? (content.text ?? "") : "";
 }

package/dist/server/engine/dsh-prompt-patch.js

@@ -0,0 +1,48 @@
+/**
+ * 把「下一步建议」的写法带进 dsh（ADR-0022 的 dsh 版）。
+ *
+ * 为什么只能走 patch 文件：ACP 是**唯一**入口，而它的 `session/new` 只有
+ * `cwd / additionalDirectories / mcpServers / _meta`（schema 实测），没有系统提示字段；
+ * dsh 的系统提示由插件栈里的 `@deepseek-ai/dsh-system-prompt` 组装，其中
+ * `personaSuffix` 排在系统提示末尾 —— 正好是这段说明该待的位置。
+ *
+ * 两个必须写清的约束：
+ *   1. patch 的 `config` 是**整块替换**（不是深合并）：只写 `personaSuffix` 会把 acp 模板
+ *      原本的 `personaPrefix` 冲掉（实测 dump 里会整个消失）。所以两句 persona 都带上，
+ *      取值照抄 `@deepseek-ai/dsh-acp-app` 的默认值；dsh 改这两句默认值时这里要跟着改。
+ *   2. 它是**进程级**的：dsh 子进程启动时才 compose 配置栈，所以改完「想想」条数要
+ *      重启工作台（引擎）才生效 —— 不像 pi / codex 那样每条新会话现读。
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** `@deepseek-ai/dsh-acp-app` 给 acp profile 的默认 persona（照抄，别改措辞） */
+const PERSONA_PREFIX = "You are a coding agent powered by the {{model}} model.";
+const PERSONA_SUFFIX = "Your working directory is {{cwd}}.";
+/** YAML 块标量的缩进：`personaSuffix: |` 下的内容比 key 深两级 */
+function indentBlock(text) {
+    return text
+        .split("\n")
+        .map((line) => (line === "" ? "" : `      ${line}`))
+        .join("\n");
+}
+/** 纯函数：生成 patch 文件内容（喂给 `dsh --patch <file>`） */
+export function dshSuggestionPatch(guidance) {
+    return [
+        "# 由 oh-my-agent-web 生成（不要手改）：给 dsh 的 system prompt 追加「下一步建议」写法。",
+        "# 改条数请改设置里的「想想」，然后重启工作台 —— dsh 的配置栈是进程启动时 compose 的。",
+        "- id: system-prompt",
+        "  config:",
+        "    personaPrefix: |",
+        indentBlock(PERSONA_PREFIX),
+        "    personaSuffix: |",
+        indentBlock(`${PERSONA_SUFFIX}\n\n${guidance}`),
+        "",
+    ].join("\n");
+}
+/** 写到一个临时目录里（不污染用户的 `dsh-patches` 目录），返回 patch 文件路径 */
+export function writeDshSuggestionPatch(dir, guidance) {
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, "dsh-suggestion-patch.yml");
+    writeFileSync(file, dshSuggestionPatch(guidance), "utf8");
+    return file;
+}

package/dist/server/engine/dsh-sessions.js

@@ -10,8 +10,8 @@
  *     拿 header（cwd/createdAt）与 `session/title`，缓存里没有时兜底。
  *
  * 为什么要自己扫目录：ACP 的 `session/list` 只回 `{sessionId, cwd}`，**没有标题和时间**；
- * 侧栏需要标题/时间/模型，所以直接读 DSH 自己的持久化（与 pi-web-ui 的做法一致，但我们
- * 额外用了 workspace.json 与投影缓存，避免每个会话都解压日志）。
+ * 侧栏需要标题/时间/模型，所以直接读 DSH 自己的持久化，并额外用 workspace.json 与投影
+ * 缓存，避免每个会话都解压日志）。
  */
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
@@ -19,7 +19,7 @@ import { basename, join } from "node:path";
 import { firstUserText, locateSessionFile, readSessionHeader, readSessionLog, sessionTitle } from "./dsh-log.js";
 import { isScratchCwd } from "./scratch.js";
 /** 读 workspace.json；没有/坏了都返回空表（侧栏退回按 cwd 分组） */
-export function readWorkspaces(home) {
+function readWorkspaces(home) {
     const file = join(home, "storages", "workspace.json");
     if (!existsSync(file))
         return {};
@@ -31,7 +31,7 @@ export function readWorkspaces(home) {
     }
 }
 /** workspace.json → path → 项目名（title 优先，缺了用目录名） */
-export function workspaceNames(workspaces) {
+function workspaceNames(workspaces) {
     const out = new Map();
     for (const row of Object.values(workspaces.tables?.workspaces ?? {})) {
         const path = row.path?.trim();
@@ -149,18 +149,17 @@ function summaryOf(home, session) {
     };
 }
 /** 纯分组：会话 → 项目（workspace 的 path 精确匹配；否则按 cwd 单独成组） */
-export function groupDshSessions(sessions, names, options = {}) {
+function groupDshSessions(sessions, names, options = {}) {
     const groups = new Map();
     for (const session of sessions) {
         if (options.archived?.has(session.id))
             continue;
         const key = session.cwd;
-        const group = groups.get(key) ??
-            {
-                cwd: session.cwd,
-                name: names.get(session.cwd) ?? basename(session.cwd) ?? session.cwd,
-                sessions: [],
-            };
+        const group = groups.get(key) ?? {
+            cwd: session.cwd,
+            name: names.get(session.cwd) ?? basename(session.cwd) ?? session.cwd,
+            sessions: [],
+        };
         group.sessions.push({
             id: session.id,
             engineSessionId: session.id,

package/dist/server/engine/dsh-transport.js

@@ -3,12 +3,12 @@
  *
  * 为什么走 ACP（`dsh --profile acp`）而不是 SDK（`--profile sdk`）或 headless：
  *   - SDK 面只有 `initialize / session/prompt / shutdown`，没有会话列表/续接/取消/配置/权限，
- *     这些要么自己读文件、要么自己写插件补（pi-web-ui 就是这么干的，代价是 26 个本地依赖 + 重启换模型）；
+ *     这些要么自己读文件、要么自己写插件补（等于把 26 个本地依赖 + 重启换模型揽进来）；
  *   - ACP 原生给了 `session/new|list|resume|close`、`session/set_config_option`（模型/思考档）、
  *     `session/cancel`、`session/request_permission`，我们只需当客户端；
  *   - headless 是一次性进程，没有权限问询。
  *
- * 协议细节见 ADR-0037；映射规则在 dsh-map.ts（纯函数，单测覆盖）。
+ * 协议细节见 ADR-0037；映射规则在 dsh-map.ts（纯函数）。
  */
 import { createJsonRpcStdioClient } from "./jsonrpc-stdio.js";
 /** ACP 要求初始化的能力协商；我们不用它的 fs/terminal 桥（工具都在 DSH 进程里跑） */

package/dist/server/engine/dsh.js

@@ -1,7 +1,8 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createDshClient } from "./dsh-transport.js";
-import { locateSessionFile, readSessionHeader, readSessionLog } from "./dsh-log.js";
+import { withProbeCwd } from "./catalog-probe.js";
+import { deleteDshSession, locateSessionFile, readSessionHeader, readSessionLog } from "./dsh-log.js";
 import { logToTranscript, logToUiMessages, statsFromLog } from "./dsh-history.js";
 import { sanitizeHistoricalActions } from "../markers/actions.js";
 import { currentModelId, currentThinkingLevel, friendlyDshError, modelOptions, modelValueFor, parseModelValue, permissionApprovalRequest, permissionOptionId, pickDefaultModelValue, stopReasonToTurnEnd, thinkingLevels, updateToEvent, } from "./dsh-map.js";
@@ -24,6 +25,8 @@ export function createDshEngine(options = {}) {
      * 真正切模型时仍会先 resume（拿不到就报可读错误）。
      */
     let lastConfig = [];
+    /** 目录探针跑过没有（每个实例只探一次；`reloadModels` / `dispose` 重置） */
+    let catalogProbed = false;
     const rememberTool = (id, update) => {
         toolFacts.set(id, { title: update.title, rawInput: update.rawInput });
         if (toolFacts.size > MAX_TOOL_FACTS) {
@@ -60,6 +63,30 @@ export function createDshEngine(options = {}) {
             return binding.config;
         return [...bindings.values()].find((item) => item.config.length > 0)?.config ?? lastConfig;
     };
+    /**
+     * 没有会话时把模型目录弄进来（原因与代价见 catalog-probe.ts 文件头）：
+     * DSH 的目录只在 `session/new` 的 `configOptions` 里 → 开个临时会话抄一份，
+     * 然后 `session/close` 并删掉它在 `~/.dsh` 里的会话目录（不在 DSH 自己的历史里留空会话）。
+     */
+    const warmCatalog = async () => {
+        if (catalogProbed || lastConfig.length > 0)
+            return;
+        catalogProbed = true;
+        await withProbeCwd(async (cwd) => {
+            const created = await client.request("session/new", {
+                cwd,
+                mcpServers: [],
+            });
+            const probeId = created?.sessionId;
+            if (!probeId)
+                return;
+            applyConfig(undefined, created.configOptions);
+            await client.request("session/close", { sessionId: probeId }).catch(() => undefined);
+            if (!deleteDshSession(sessionsRoot, probeId, cwd)) {
+                options.log?.(`dsh：模型目录探针会话没删掉（${probeId}），侧栏不会显示（临时目录）`);
+            }
+        });
+    };
     /** 历史会话首次使用时才 resume（ACP 的 resume 会拿到写句柄，所以按需） */
     const ensureLive = async (conversationId) => {
         const binding = bindingOf(conversationId);
@@ -147,9 +174,24 @@ export function createDshEngine(options = {}) {
         version: () => client.version(),
         async prewarm() {
             await client.ensureStarted();
+            // 顺手把模型目录也弄进来：否则切过来、还没开会话时下拉是空的（见 catalog-probe.ts）
+            await warmCatalog().catch((error) => {
+                options.log?.(`dsh：读取模型目录失败：${error instanceof Error ? error.message : String(error)}`);
+            });
+        },
+        /** 重读模型表（改完 dsh 自己的 provider / 模型配置后）：清掉快照，重新探一次 */
+        async reloadModels() {
+            lastConfig = [];
+            catalogProbed = false;
+            await warmCatalog().catch((error) => {
+                options.log?.(`dsh：重读模型目录失败：${error instanceof Error ? error.message : String(error)}`);
+            });
         },
         async createSession(sessionOptions) {
-            const created = await client.request("session/new", { cwd: sessionOptions.workspace, mcpServers: [] });
+            const created = await client.request("session/new", {
+                cwd: sessionOptions.workspace,
+                mcpServers: [],
+            });
             const sessionId = created?.sessionId;
             if (!sessionId)
                 throw new Error("dsh 没有返回 sessionId");
@@ -222,6 +264,7 @@ export function createDshEngine(options = {}) {
         },
         async dispose() {
             lastConfig = [];
+            catalogProbed = false;
             bindings.clear();
             bySession.clear();
             active.clear();

package/dist/server/engine/engine-versions.js

@@ -0,0 +1,41 @@
+export function createEngineVersionProber(options) {
+    const cache = new Map();
+    const inflight = new Map();
+    const probe = (descriptor) => {
+        const known = inflight.get(descriptor.name);
+        if (known)
+            return known;
+        const pending = (async () => {
+            try {
+                const value = await descriptor.version?.();
+                return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+            }
+            catch (error) {
+                options.onLog?.(`探测 ${descriptor.name} 的版本号失败：${error instanceof Error ? error.message : String(error)}`);
+                return null;
+            }
+        })();
+        inflight.set(descriptor.name, pending);
+        return pending;
+    };
+    const snapshot = () => Object.fromEntries(cache);
+    return {
+        known: snapshot,
+        remember(name, version) {
+            // 握手给的版本最准：记下来，后面 refresh 也不会把它擦掉
+            if (version && version.trim() !== "")
+                cache.set(name, version.trim());
+        },
+        async refresh() {
+            await Promise.all(options.descriptors().map(async (descriptor) => {
+                if (cache.has(descriptor.name))
+                    return;
+                const value = await probe(descriptor);
+                // 期间可能有 remember()（握手）写过更准的值，别覆盖
+                if (!cache.has(descriptor.name))
+                    cache.set(descriptor.name, value);
+            }));
+            return snapshot();
+        },
+    };
+}

package/dist/server/engine/fake.js

@@ -1,6 +1,6 @@
 const BIG_OUTPUT_CHARS = 200 * 1024;
 /** 触发词 → 脚本。默认行为：把用户输入原样念一遍，证明「逐字说话」。 */
-export function planFor(text) {
+function planFor(text) {
     const key = text.toLowerCase();
     if (key.includes("boom")) {
         return [
@@ -80,6 +80,8 @@ export function createFakeEngine(options = {}) {
     const switchedModels = [];
     let approvalHandler = null;
     let toolCallSeq = 0;
+    /** 派生会话的 id 序号（真引擎是 pi 的 `createSessionId()`，同样不复用传进来的 id） */
+    let forkSeq = 0;
     async function streamText(sessionId, text, onEvent, slow) {
         const buffer = sessions.get(sessionId)?.transcript;
         for (let index = 0; index < text.length; index += chunkChars) {
@@ -95,12 +97,41 @@ export function createFakeEngine(options = {}) {
     return {
         version: () => "fake",
         async createSession(sessionOptions) {
-            sessions.set(sessionOptions.sessionId, {
-                workspace: sessionOptions.workspace,
-                transcript: [],
-                sessionPath: `fake-sessions/${sessionOptions.sessionId}.jsonl`,
-            });
-            return { sessionPath: `fake-sessions/${sessionOptions.sessionId}.jsonl` };
+            const ephemeral = sessionOptions.ephemeral === true;
+            /** 派生：把源会话的转录拄过来（按 `fake-<会话>-<序号>` 里的序号截断） */
+            let transcript = [];
+            if (sessionOptions.fork) {
+                const source = sessions.get(sessionOptions.fork.sourceSessionId);
+                // 与真引擎一致：没落盘的会话不能 fork
+                if (!source?.sessionPath)
+                    throw new Error("这条会话还没存过盘（临时对话），不能从它派生分支");
+                const cut = Number(/-(\d+)$/.exec(sessionOptions.fork.leafId)?.[1] ?? Number.NaN);
+                transcript = Number.isFinite(cut) ? source.transcript.slice(0, cut + 1) : [...source.transcript];
+                // 与真引擎一致（pi 的 `createBranchedSession`）：派生会**另生一个会话 id**，
+                // 不采纳传进来的那个。宿主必须拿回报的 id 当会话 id，否则发消息就会
+                // `engine.no_session`（引擎表里只有新 id）—— 这里必须忠实复现，不然测试盖不住。
+                forkSeq += 1;
+                const forkedId = `forked-${forkSeq}`;
+                const forkedPath = `fake-sessions/${forkedId}.jsonl`;
+                sessions.set(forkedId, { workspace: sessionOptions.workspace, transcript, sessionPath: forkedPath });
+                return { sessionPath: forkedPath, sessionId: forkedId };
+            }
+            // 临时会话没有会话文件（与 pi 的 `--no-session` 一致）
+            const sessionPath = ephemeral ? null : `fake-sessions/${sessionOptions.sessionId}.jsonl`;
+            sessions.set(sessionOptions.sessionId, { workspace: sessionOptions.workspace, transcript, sessionPath });
+            return { sessionPath };
+        },
+        /** 临时会话转正：给它一个文件路径（真引擎是原生导出写盘） */
+        async persistSession(sessionId) {
+            const session = sessions.get(sessionId);
+            if (!session)
+                return { sessionPath: null };
+            if (session.sessionPath)
+                return { sessionPath: session.sessionPath };
+            if (session.transcript.length === 0)
+                return { sessionPath: null };
+            session.sessionPath = `fake-sessions/${sessionId}.jsonl`;
+            return { sessionPath: session.sessionPath };
         },
         /** 打开已有会话（ADR-0021 §2）：假引擎没有真文件，只登记「已打开」 */
         async openSession(openOptions) {

package/dist/server/engine/model-registry-reload.js

@@ -22,7 +22,7 @@ async function readJson(path, fallback) {
     }
 }
 /** 把 pi 的两份配置读成「可直接 registerProvider 的形状」 */
-export async function readProviderConfigs(agentDir) {
+async function readProviderConfigs(agentDir) {
     const catalog = await readJson(join(agentDir, "models.json"), {});
     const store = await readJson(join(agentDir, "models-store.json"), {});
     const auth = await readJson(join(agentDir, "auth.json"), {});

package/dist/server/engine/opencode-map.js

@@ -1,5 +1,5 @@
 /**
- * opencode ACP 的**纯映射**（不碰网络/子进程，单测直接覆盖）。
+ * opencode ACP 的**纯映射**（不碰网络/子进程）。
  *
  * 三件事：
  *   1. `configOptions`（模型 / 思考档）→ 我们的模型下拉与档位；
@@ -90,7 +90,7 @@ export function modelValueFor(config, modelId) {
  * 思考档那一项：按 `category: "thought_level"` 找（dsh 叫 reasoning_effort，opencode 叫 effort）。
  * 不支持推理的模型没有这一项 → 返回 undefined，界面自动隐藏控件。
  */
-export function thinkingOptionOf(config) {
+function thinkingOptionOf(config) {
     return (config ?? []).find((entry) => entry.category === "thought_level" || entry.id === "effort" || entry.id === "reasoning_effort");
 }
 export function thinkingLevels(config) {

package/dist/server/engine/opencode-projects.js

@@ -17,7 +17,7 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 /** opencode 的库文件：跟随 XDG（它自己也是这么找数据的） */
-export function opencodeDbFile(env = process.env, home = homedir()) {
+function opencodeDbFile(env = process.env, home = homedir()) {
     const xdg = env.XDG_DATA_HOME?.trim();
     const dataHome = xdg && xdg !== "" ? xdg : join(home, ".local", "share");
     return join(dataHome, "opencode", "opencode.db");

package/dist/server/engine/opencode-sessions.js

@@ -30,13 +30,13 @@ const timestampOf = (value) => {
     return Number.isFinite(parsed) ? parsed : 0;
 };
 /**
- * 纯分组：`session/list` 的行 → 侧栏形状（单测直接覆盖）。
+ * 纯分组：`session/list` 的行 → 侧栏形状。
  *
  * - 临时目录（/tmp、/var/folders…）里的一次性会话丢掉，别塞噪音进侧栏；
  * - 同 cwd 归一组，组内按更新时间倒序；组之间按「最近一条会话」倒序；
  * - 没有标题的会话不编名字（opencode 自己会给「New session - …」，照它的原文显示）。
  */
-export function groupOpencodeSessions(rows) {
+function groupOpencodeSessions(rows) {
     // 逐个项目点名时同一条会话会被问到多次（项目根与它的子目录都解析到同一个项目），先去重：
     // 同一个 sessionId 只留 updatedAt 最新的一条。
     const byId = new Map();

package/dist/server/engine/opencode.js

@@ -1,4 +1,5 @@
 import { isScratchCwd } from "./scratch.js";
+import { withProbeCwd } from "./catalog-probe.js";
 import { currentModelId, currentThinkingLevel, exportStats, exportToTranscript, exportToUiMessages, friendlyOpencodeError, hasPendingUsage, hasUsableToolFacts, isFinalToolStatus, modelOptions, modelValueFor, parseModelValue, permissionApprovalRequest, permissionOptionId, stopReasonToTurnEnd, textEventOf, thinkingConfigId, thinkingLevels, toolEndEvent, toolStartEvent, usageEventOf, } from "./opencode-map.js";
 import { deleteOpencodeSession, readOpencodeExport } from "./opencode-sessions.js";
 import { createOpencodeClient } from "./opencode-transport.js";
@@ -16,6 +17,7 @@ const EXPORT_CACHE_MS = 3000;
 const EXPORT_SETTLE_MS = 3000;
 export function createOpencodeEngine(options = {}) {
     const bin = options.bin ?? "opencode";
+    const removeSession = options.deleteSession ?? ((engineSessionId) => deleteOpencodeSession(bin, engineSessionId));
     const client = options.client ?? createOpencodeClient({ bin, args: options.args, log: options.log ?? (() => { }) });
     const bindings = new Map();
     const byEngineSession = new Map();
@@ -33,6 +35,8 @@ export function createOpencodeEngine(options = {}) {
      * 真正切模型时仍会先 resume（拿不到就报可读错误）。
      */
     let lastConfig = [];
+    /** 目录探针跑过没有（每个实例只探一次；`reloadModels` / `dispose` 重置） */
+    let catalogProbed = false;
     const rememberTool = (facts) => {
         const previous = toolFacts.get(facts.toolCallId);
         // 后到的 update 更详细（title 从 "bash" 变成真命令），合并而不是覆盖
@@ -57,6 +61,27 @@ export function createOpencodeEngine(options = {}) {
             return binding.config;
         return [...bindings.values()].find((item) => item.config.length > 0)?.config ?? lastConfig;
     };
+    /**
+     * 没有会话时把模型目录弄进来（原因与代价见 catalog-probe.ts 文件头）。
+     * opencode 的目录只在 `session/new` 的 `configOptions` 里，所以开一个临时会话抄一份，
+     * 然后 `session/close` + `opencode session delete` 收掉（不留在 CLI/TUI 的历史里）。
+     */
+    const warmCatalog = async () => {
+        if (catalogProbed || lastConfig.length > 0)
+            return;
+        catalogProbed = true;
+        await withProbeCwd(async (cwd) => {
+            const created = await client.request("session/new", { cwd, mcpServers: [] });
+            const engineSessionId = created?.sessionId;
+            if (!engineSessionId)
+                return;
+            applyConfig(undefined, created.configOptions);
+            await client.request("session/close", { sessionId: engineSessionId }).catch(() => undefined);
+            await removeSession(engineSessionId).catch((error) => {
+                options.log?.(`opencode：模型目录探针会话没删掉（${engineSessionId}）：${error instanceof Error ? error.message : String(error)}`);
+            });
+        });
+    };
     const invalidateExport = (conversationId) => {
         const binding = bindingOf(conversationId);
         if (binding)
@@ -202,6 +227,18 @@ export function createOpencodeEngine(options = {}) {
         version: () => client.version(),
         async prewarm() {
             await client.ensureStarted();
+            // 顺手把模型目录也弄进来：否则切过来、还没开会话时下拉是空的（见 catalog-probe.ts）
+            await warmCatalog().catch((error) => {
+                options.log?.(`opencode：读取模型目录失败：${error instanceof Error ? error.message : String(error)}`);
+            });
+        },
+        /** 重读模型表（改完 opencode 自己的配置后）：清掉快照，重新探一次 */
+        async reloadModels() {
+            lastConfig = [];
+            catalogProbed = false;
+            await warmCatalog().catch((error) => {
+                options.log?.(`opencode：重读模型目录失败：${error instanceof Error ? error.message : String(error)}`);
+            });
         },
         async createSession(sessionOptions) {
             const created = await client
@@ -324,6 +361,7 @@ export function createOpencodeEngine(options = {}) {
             toolFacts.clear();
             exportCache.clear();
             settledAt.clear();
+            catalogProbed = false; // 探针会话随进程一起没了：下次切回来重新探
             client.close();
         },
         setApprovalHandler(handler) {
@@ -387,7 +425,7 @@ export function createOpencodeEngine(options = {}) {
         },
         /** opencode 原生删除（`opencode session delete <sid>`）；改名没接（ACP 无此方法） */
         async deleteSession(handle) {
-            await deleteOpencodeSession(bin, handle);
+            await removeSession(handle);
             exportCache.delete(handle);
         },
     };

package/dist/server/engine/pi-events.js

@@ -2,7 +2,7 @@
  * SDK 会话事件 → 端口事件的映射（ADR-0003 的端口实现里最容易出错的一层）。
  *
  * 从 `pi-sdk.ts` 拆出（400 行护栏）：这是**纯映射**，与「怎么建会话、怎么订阅」无关，
- * 所以可以脱离 SDK 用合成事件直接测（单测覆盖整张映射表，不烧 token）。
+ * 所以可以脱离 SDK 用合成事件直接驱动（整张映射表都能覆盖，不烧 token）。
  */
 import { parseUsage } from "../util/usage.js";
 function asRecord(value) {
@@ -22,7 +22,7 @@ export function resultText(result) {
         .join("\n");
 }
 /** 把 bash 工具结果的退出码抠出来（不同工具 details 形状不同，取不到就不给） */
-export function resultExitCode(result) {
+function resultExitCode(result) {
     const details = asRecord(asRecord(result).details);
     const value = details.exitCode ?? asRecord(asRecord(result).structuredContent).exitCode;
     return typeof value === "number" ? value : undefined;
@@ -30,7 +30,7 @@ export function resultExitCode(result) {
 /** 一行预览的长度：超过就截（参数再长，抬头也只有一行） */
 const SUMMARY_CHARS = 200;
 /** 完整参数的上限：不能让一条快照因参数膨胀（正常命令远小于这个数） */
-export const FULL_ARGS_CHARS = 4000;
+const FULL_ARGS_CHARS = 4000;
 /** 把任意参数变成文本（字符串原样返回：有的引擎直接给命令串，不是 JSON） */
 function argsText(args) {
     if (typeof args === "string")
@@ -63,7 +63,7 @@ function providerError(raw) {
 }
 /**
  * 纯函数：把 SDK 会话事件翻译成端口事件。返回 null 表示这个事件不影响 UI。
- * （单测用合成事件直接覆盖这张映射表 —— 不需要真的连模型。）
+ * （合成事件就能覆盖这张映射表 —— 不需要真的连模型。）
  */
 export function mapSessionEvent(event) {
     const record = asRecord(event);