oh-my-agent-web 0.7.0 → 1.0.2

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

@@ -5,12 +5,12 @@
  * 一个包可以同时带扩展、技能、提示词模板、主题；另外还有散装放在
  * `~/.pi/agent/extensions/`（或项目 `.pi/extensions/`）里的单文件扩展。
  *
- * 与参考实现 `/data/git/pi-web`（`app/api/plugins/route.ts`）对齐的几条：
+ * 几条约定：
  *   - **谁说了算：pi 自己**。哪些资源、开没开，全部取自 `DefaultPackageManager.resolve()`；
  *     `onMissing` 一律回 `skip` —— 查询时绝不顺手跑 npm install。
  *   - **两个作用域**：全局（`~/.pi/agent/settings.json`）+ 项目（`<workspace>/.pi/settings.json`），
  *     跟会话加载时用的 cwd 是同一个，所以面板显示的就是这个项目里真正加载的东西。
- *     OMAW 没有「项目信任」的交互（ADR 未引入），与 SDK 的默认值一致：项目资源按已信任处理。
+ *     oh-my-agent-web 没有「项目信任」的交互（ADR 未引入），与 SDK 的默认值一致：项目资源按已信任处理。
  *   - **停用 ≠ 卸载**：写 `autoload: false`（pi 文档：先清空、再按 patterns 加回），
  *     不删文件、不动 npm 目录、**不丢用户手写的资源过滤**；开回来只删这一个键。
  *     `pi config` 那种「四类数组都置空」的停用也认，一并显示成已停用。
@@ -20,7 +20,7 @@
 import { readFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative, sep } from "node:path";
 import { DefaultPackageManager, SettingsManager } from "@earendil-works/pi-coding-agent";
-export const RESOURCE_KEYS = ["extensions", "skills", "prompts", "themes"];
+const RESOURCE_KEYS = ["extensions", "skills", "prompts", "themes"];
 const EMPTY_COUNTS = { extensions: 0, skills: 0, prompts: 0, themes: 0 };
 const KIND_OF = {
     extensions: "extension",
@@ -107,7 +107,7 @@ function toResourceInfo(resource, key) {
     };
 }
 /** 插件面板的 key：scope + source（同一个包可能在两个作用域各配一份） */
-export function pluginKey(source, scope) {
+function pluginKey(source, scope) {
     return `${scope}\0${source}`;
 }
 export function createPluginStore(options) {
@@ -230,7 +230,9 @@ export function createPluginStore(options) {
     }
     /** 改一条 package 的启停；只动目标条目，其它条目与管理器里的其它键原样保留 */
     function setDisabled(settings, source, scope, wanted) {
-        const current = scope === "global" ? [...(settings.getGlobalSettings().packages ?? [])] : [...(settings.getProjectSettings().packages ?? [])];
+        const current = scope === "global"
+            ? [...(settings.getGlobalSettings().packages ?? [])]
+            : [...(settings.getProjectSettings().packages ?? [])];
         const index = current.findIndex((entry) => sourceOf(entry) === source);
         if (index === -1)
             return false;
@@ -240,7 +242,7 @@ export function createPluginStore(options) {
         let next;
         if (wanted) {
             // 停用：autoload:false = 「先清空，再按 patterns 加回」。保留用户手写的过滤规则，
-            // 否则「停一下再开」会把过滤弄丢（参考实现在这点上会丢，这里刻意不跟）。
+            // 否则「停一下再开」会把过滤弄丢。
             next = { ...(typeof entry === "string" ? { source: entry } : entry), autoload: false };
         }
         else if (typeof entry === "string") {

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

@@ -6,7 +6,8 @@
  *
  * 与 SDK 的对接方式（M3 侦察结论）：
  */
-import { DefaultResourceLoader, SessionManager, createAgentSession, getAgentDir, } from "@earendil-works/pi-coding-agent";
+import { DefaultResourceLoader, SessionManager, createAgentSession, getAgentDir, initTheme, } from "@earendil-works/pi-coding-agent";
+import { dirname } from "node:path";
 import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
 import { classifyScope } from "../approval/scope.js";
 import { mapSessionEvent } from "./pi-events.js";
@@ -15,6 +16,28 @@ import { makeSubagentToolExtension } from "./pi-subagent-tool.js";
 import { enabledSubagentSpecs, readSubagentSettings } from "../subagents/profile-store.js";
 import { readSessionModel } from "./pi-session-model.js";
 import { entriesToUiMessages } from "./pi-transcript.js";
+/**
+ * 把界面上那条消息换算成**真正的分叉点**。
+ *
+ * 助手气泡是多条 entry 合并出来的（一次工具轮次 = 一条），它身上的 `UiMessage.id` 只是其中
+ * 第一条；直接按它切会把这一轮的思考和工具块全丢掉。所以从这条消息往下走，走到
+ * 「下一个用户消息之前」的最后一个 entry —— 那才是「这条回复真的说完了」的位置。
+ */
+function resolveForkLeaf(manager, messageId) {
+    if (!manager.getEntry(messageId))
+        return null;
+    let leaf = messageId;
+    // 沿树往下（只认最后一个孩子）；碰到下一条用户消息就停：那是下一轮了
+    for (let guard = 0; guard < 10_000; guard += 1) {
+        const next = manager.getChildren(leaf).at(-1);
+        if (!next)
+            break;
+        if (next.type === "message" && asRecord(next.message).role === "user")
+            break;
+        leaf = next.id;
+    }
+    return leaf;
+}
 function asRecord(value) {
     return typeof value === "object" && value !== null ? value : {};
 }
@@ -42,7 +65,7 @@ const STEER_SETTLE_FALLBACK_MS = 20 * 60 * 1000;
  */
 const SETTLE_GRACE_MS = 800;
 /**
- * provider 的显示名：只覆盖 SDK 名字太长/不直观的两个（和 pi-web 的选择一致），
+ * provider 的显示名：只覆盖 SDK 名字太长/不直观的两个，
  * 其余直接用引擎给的 OAuth 名称（`Anthropic (Claude Pro/Max)`、`xAI (Grok/X subscription)` 等）。
  */
 const OAUTH_LABELS = {
@@ -108,13 +131,26 @@ function toAuthEvent(event) {
 /** 教模型怎么写「下一步建议」（ADR-0022）：刻意写得短（每次请求都付 token） */
 import { reloadModelRegistry } from "./model-registry-reload.js";
 import { NARRATE_GUIDANCE } from "./narrate-guidance.js";
-import { SUGGESTION_GUIDANCE } from "./suggestion-guidance.js";
+import { SUGGESTION_GUIDANCE, suggestionGuidance } from "./suggestion-guidance.js";
 import { SUBAGENT_GUIDANCE } from "./subagent-guidance.js";
 export { NARRATE_GUIDANCE, SUGGESTION_GUIDANCE, SUBAGENT_GUIDANCE };
 import { createPiThinking } from "./pi-thinking.js";
 import { piSdkVersion } from "./pi-version.js";
 import { renameSessionIn } from "./pi-rename.js";
 export function createPiSdkEngine(options = {}) {
+    /**
+     * pi 的 `theme` 是个全局 Proxy：没调过 `initTheme()` 就抛
+     * `Theme not initialized. Call initTheme() first.`（import 本身**不会**初始化它）。
+     *
+     * TUI 启动时自己会初始化，而这个无界面的工作台不会 —— 但扩展里那些「给终端画东西」的代码
+     * （`getMarkdownTheme().heading()`、`new Text(..., theme.fg(...))`）照样会被调用，尤其是
+     * 塞在 `setTimeout` 里的渲染：那个异常没人接，**直接把这个服务进程带走**（同事机器上真踩过：
+     * 扩展 `token-speed.ts` 的定时渲染崩了整个 agent-web）。
+     *
+     * 所以宿主这边先初始化一次，让这类渲染退化成「画了个没人看的东西」，而不是崩服务。
+     * 顺带也是所有 `@earendil-works/*` 导入的唯一出口（本文件）。
+     */
+    initTheme();
     const sessions = new Map();
     const thinking = createPiThinking(sessions);
     let approvalHandler = null;
@@ -168,6 +204,22 @@ export function createPiSdkEngine(options = {}) {
             },
         };
     }
+    /**
+     * 算一个新会话文件的路径 + 建好目录（**不写文件**）。
+     *
+     * 借用一次 `SessionManager.create` 来算：文件名格式（`<ISO 时间>_<id>.jsonl`）与 pi 自己写的
+     * 完全一致。自己拼文件名的话，一旦 pi 改了格式，侧栏扫描器就找不到这些会话。
+     */
+    function sessionFileFor(workspace, id) {
+        const file = SessionManager.create(workspace, options.sessionDir, { id }).getSessionFile();
+        if (!file)
+            throw new Error("无法确定会话文件路径（会话目录不可写）");
+        return file;
+    }
+    /** 这个工作区的会话目录（布局跟 pi 自己的完全一致） */
+    function sessionDirFor(workspace) {
+        return dirname(sessionFileFor(workspace, "probe"));
+    }
     /** 建 resourceLoader 并拉起一个 AgentSession（createSession 与 openSession 共用） */
     async function startSession(sessionId, workspace, sessionManager, sessionPath = null) {
         const agentDir = options.agentDir ?? getAgentDir();
@@ -195,7 +247,11 @@ export function createPiSdkEngine(options = {}) {
             extensionFactories,
             // 教模型「下一步建议」的写法（ADR-0022）：纯文本标记，不需要调用任何工具
             // 「动手前先说话」：过程默认折叠，不写正文用户就不知道它在干什么
-            appendSystemPrompt: [SUGGESTION_GUIDANCE, NARRATE_GUIDANCE, ...(subagentReady ? [SUBAGENT_GUIDANCE] : [])],
+            appendSystemPrompt: [
+                suggestionGuidance(options.thinkCount?.() ?? null),
+                NARRATE_GUIDANCE,
+                ...(subagentReady ? [SUBAGENT_GUIDANCE] : []),
+            ],
         });
         await resourceLoader.reload();
         const { session } = await createAgentSession({
@@ -378,14 +434,80 @@ export function createPiSdkEngine(options = {}) {
             },
         },
         async createSession(sessionOptions) {
+            const { sessionId, workspace, ephemeral, fork } = sessionOptions;
+            // ── 派生（分支）：与 pi 自己 `/fork` 的做法一致（见 SDK 的 agent-session-runtime）──
+            // 关键是**另开一个 manager 读同一个文件**：`createBranchedSession` 会把它自己指向新文件，
+            // 而源会话那个 manager 完全不受影响 —— 所以原对话一个字不动。
+            if (fork) {
+                const source = sessions.get(fork.sourceSessionId);
+                // pi 原生的拒绝理由就是这句：没落盘的会话不能 fork（`/clone` 前先说话）
+                if (!source?.sessionPath)
+                    throw new Error("这条会话还没存过盘（临时对话），不能从它派生分支");
+                const leafId = resolveForkLeaf(source.sessionManager, fork.leafId);
+                if (!leafId)
+                    throw new Error("找不到要分叉的那条消息（它可能不在当前分支上）");
+                // 新会话的目录跟新工作区走（布局与 pi 自己的完全一致）
+                const sessionManager = SessionManager.open(source.sessionPath, sessionDirFor(workspace), workspace);
+                const forkedPath = sessionManager.createBranchedSession(leafId);
+                if (!forkedPath)
+                    throw new Error("派生会话文件创建失败");
+                // `createBranchedSession` 会给派生会话**另生一个 id** 并写进新文件头（pi 自己的 `/fork` 也这样）：
+                // 句柄必须按**它**登记，不能按传进来的 `sessionId` —— 宿主要拿它当会话 id（见
+                // `conversation-create.ts` 的 `engineAssignedId ?? planned`），这里不跟上，之后发消息就是
+                // `engine.no_session`（引擎的表里只有那个没被采用的 id）。
+                const forkedId = sessionManager.getSessionId();
+                await startSession(forkedId, workspace, sessionManager, forkedPath);
+                return { sessionPath: forkedPath, sessionId: forkedId };
+            }
+            // ── 临时会话 = pi 的 `--no-session`：纯内存，不建文件、不进历史 ──
+            if (ephemeral) {
+                const sessionManager = SessionManager.inMemory(workspace, { id: sessionId });
+                await startSession(sessionId, workspace, sessionManager);
+                return { sessionPath: null };
+            }
             // ADR-0021 §2：新建会话就落在 **pi 的会话存储**里（不再用 inMemory + 自建 jsonl），
             // 用我们的 sessionId 当 SDK 的会话 id → 两边 id 空间完全一致。
-            const sessionManager = SessionManager.create(sessionOptions.workspace, options.sessionDir, {
+            const sessionManager = SessionManager.create(workspace, options.sessionDir, {
                 id: sessionOptions.sessionId,
             });
             const handle = await startSession(sessionOptions.sessionId, sessionOptions.workspace, sessionManager);
             return { sessionPath: handle.sessionPath };
         },
+        /**
+         * 临时会话转正：用 pi 原生导出让文件落盘（id 不变），再关掉重开。
+         *
+         * 序列化走 `session.exportToJsonl()`—— pi 自己的 `/export` 用的就是它，我们一个字不自己拼。
+         * 为什么必须「重开」：内存句柄对那个文件一无所知，不换掉它的话，之后说的话还是不会落盘
+         * （看着已经存了，其实一个字没进文件）。重开后上下文不变：历史就在文件里。
+         */
+        async persistSession(sessionId) {
+            const handle = sessions.get(sessionId);
+            if (!handle)
+                return { sessionPath: null };
+            const manager = handle.sessionManager;
+            // 已经是落盘的会话：直接回它的文件（幂等：重复点「保存为正式对话」不会写出两份）
+            if (manager.isPersisted())
+                return { sessionPath: manager.getSessionFile() ?? null };
+            const entries = manager.getEntries();
+            // 一个字都还没说：不值得落盘（空会话进历史只会变成一个没法看的空行）
+            if (!entries.some((entry) => asRecord(entry).type === "message"))
+                return { sessionPath: null };
+            const workspace = handle.workspace;
+            const sessionPath = sessionFileFor(workspace, sessionId);
+            // 原生导出：header + 当前分支的全部条目（id 就是这条会话原来的 id）
+            handle.session.exportToJsonl(sessionPath);
+            handle.unsubscribe();
+            try {
+                handle.session.dispose();
+            }
+            catch {
+                // 已经关掉了
+            }
+            sessions.delete(sessionId);
+            const reopened = SessionManager.open(sessionPath, options.sessionDir, workspace);
+            await startSession(sessionId, workspace, reopened, sessionPath);
+            return { sessionPath };
+        },
         async openSession(openOptions) {
             const sessionPath = openOptions.sessionPath ?? openOptions.engineSessionId;
             if (!sessionPath)
@@ -395,6 +517,58 @@ export function createPiSdkEngine(options = {}) {
             await startSession(openOptions.sessionId, workspace, sessionManager, sessionPath);
         },
         renameSession: (sessionPath, name) => renameSessionIn(sessions, sessionPath, name, options.sessionDir),
+        /**
+         * 「按会话内容起个名」：一次**独立**的一次性问答。
+         *
+         * 为什么自己开一个会话而不是往当前会话里塞一句提示词：起名不该出现在用户的
+         * 对话里（不能污染历史、不能算一轮、不能被用户看到）。所以用 `inMemory()` 的
+         * SessionManager（不落盘、不进 session 列表）+ `noTools`（不调工具）。
+         *
+         * 模型跟**当前全局选择**走：拿预热会话的 `model` / `modelRuntime` 直接用，
+         * 不重新解析凭据 —— 因此「没有可用模型」时返回 null，交给上层提示文案。
+         */
+        async suggestTitle(prompt) {
+            const handle = sessions.get(PREWARM_ID) ?? [...sessions.values()].at(-1);
+            const source = handle?.session;
+            if (!source?.modelRuntime || !source.model) {
+                // 没有预热会话（从未发过消息 / 刚启动）→ 现场预热一次再说
+                await warmUp();
+            }
+            const warm = sessions.get(PREWARM_ID) ?? handle;
+            const from = warm?.session;
+            if (!from?.modelRuntime || !from.model)
+                return null;
+            const disposable = await createAgentSession({
+                cwd: process.cwd(),
+                sessionManager: SessionManager.inMemory(),
+                noTools: "all",
+                /**
+                 * 故意用一只「空资源」的 loader：起名不需要技能 / 扩展 / 上下文文件 / 主题，
+                 * 全关掉只剩一句系统提示词 —— 否则点一下图标就要白扫一遍 skill 与 AGENTS.md，
+                 * 既慢又白烧 token。
+                 */
+                resourceLoader: new DefaultResourceLoader({
+                    cwd: process.cwd(),
+                    agentDir: options.agentDir ?? getAgentDir(),
+                    noExtensions: true,
+                    noSkills: true,
+                    noPromptTemplates: true,
+                    noThemes: true,
+                    noContextFiles: true,
+                    systemPrompt: "你是一个给会话起标题的助手。只输出标题本身，不要解释。",
+                }),
+                modelRuntime: from.modelRuntime,
+                model: from.model,
+            });
+            try {
+                await disposable.session.prompt(prompt);
+                return disposable.session.getLastAssistantText() ?? null;
+            }
+            finally {
+                // 一次性会话：问完就丢（dispose 会 abort 掉还在跑的东西）
+                disposable.session.dispose();
+            }
+        },
         async readUiMessages(sessionId) {
             const handle = sessions.get(sessionId);
             if (!handle)

package/dist/server/engine/pi-subagent-tool.js

@@ -43,10 +43,10 @@ function resultText(run) {
 /**
  * 等这个运行进入终态；返回最后一次看到的记录。
  *
- * 导出是为了单测（`tests/unit/subagent-wait.test.ts`）：这里有一个「先查再订阅」的竞态，
+ * 导出是为了能单独调：这里有一个「先查再订阅」的竞态，
  * 只有把函数单独拿出来才能构造出那个窗口。
  */
-export function waitForRun(port, id, timeoutMs) {
+function waitForRun(port, id, timeoutMs) {
     // 极快的任务可能在 start() 返回前就结束了：先看一眼，再订阅
     const current = port.get(id);
     if (current && TERMINAL.has(current.status))

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

@@ -35,14 +35,14 @@ const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
  * 在子会话里就找不到 —— SDK 只会甩一句英文「No API provider registered for api: xxx」。
  * 这里补一句人话，否则用户看到一屏英文完全不知道下一步该干嘛。
  */
-export function explainError(message) {
+function explainError(message) {
     if (/No API provider registered for api:/i.test(message)) {
         return `${message}\n（子代理会话不加载扩展：这个模型是由扩展提供的。换一个内置 provider 的模型，或在子代理模板里指定模型。）`;
     }
     return message;
 }
 /** 给定父会话文件，算出子代理的会话目录（与父会话并列，不进项目清单） */
-export function subagentSessionDir(parentSessionPath, fallbackDir) {
+function subagentSessionDir(parentSessionPath, fallbackDir) {
     if (!parentSessionPath)
         return fallbackDir;
     return join(dirname(parentSessionPath), basename(parentSessionPath, ".jsonl"), "subagents");

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

@@ -7,7 +7,7 @@
  * 输出是我们的 `UiMessage[]`（text / tool / error 三类块）。
  *
  * 刻意**不 import SDK 类型**：只用最小结构描述（TS 里用 unknown + 收窄），
- * 这样单测可以用合成条目直接覆盖，不需要拉起 SDK。
+ * 这样合成条目就能直接驱动，不需要拉起 SDK。
  */
 import { TOOL_EXCERPT_CHARS } from "../protocol.js";
 import { fullArgs, summarizeArgs } from "./pi-events.js";

package/dist/server/engine/registry.js

@@ -38,11 +38,21 @@ export function createEngineRegistry(descriptors, fallbackName = "pi") {
 }
 /** 假引擎的能力：**没有审批**（它只是剧本，不需要拦），其余从简 */
 export const FAKE_CAPABILITIES = {
-    approvals: true, // 假引擎仍会走审批剧本（approve 触发词），保留 true 便于测试
+    approvals: true, // 假引擎仍会走审批剧本（approve 触发词），保留 true
     tools: true,
     modelSwitch: true,
     thinkingLevel: false,
     resume: true,
+    // 也实现了（内存会话 / 转录截断），用它就能走一遍「临时对话 + 派生分支」的宿主流程
+    ephemeralChat: true,
+    forkChat: true,
 };
 /** pi：能力全开，而且**只有它真能插队**（`streamingBehavior: "steer"`，见 ADR-0043） */
-export const PI_CAPABILITIES = { ...ALL_ON, subagents: true, steer: true };
+export const PI_CAPABILITIES = {
+    ...ALL_ON,
+    subagents: true,
+    steer: true,
+    // 临时会话（`SessionManager.inMemory`）与派生分支（按 entry 剪历史另存）都是 pi 会话存储的能力
+    ephemeralChat: true,
+    forkChat: true,
+};

package/dist/server/engine/suggestion-guidance.js

@@ -1,9 +1,22 @@
-/** 教模型「下一步建议」的写法（ADR-0022）：纯文本标记，不需要调用任何工具 */
-export const SUGGESTION_GUIDANCE = [
-    "## Suggested next actions",
-    "When the user must choose what to do next, end the reply with 4 to 5 lines of:",
-    "[[action:suggest:<button text>]]",
-    "Clicking a button sends that text as the next user message.",
-    "Use [[action:suggest:<short label>,prompt=<text to send>]] when the label should differ from the sent text.",
-    "Put them on their own lines at the very end, and never mention this syntax in prose.",
-].join("\n");
+/**
+ * 教模型「下一步建议」的写法（ADR-0022）：纯文本标记，不需要调用任何工具。
+ *
+ * 条数由调用方给（设置里「想想」那一个 `settings.thinkCount`，取值 1~5）：
+ * 界面上「再给一批」按几条问，模型结尾就写几条 —— 两边用同一个数，不然按钮数和
+ * 「想想」的结果数对不上。拿不到就退回默认区间 4~5（与 ADR-0039 一致）。
+ */
+export function suggestionGuidance(count) {
+    const wanted = typeof count === "number" && Number.isInteger(count) && count >= 1 && count <= 5 ? count : null;
+    const amount = wanted === null ? "4 to 5" : String(wanted);
+    const unit = wanted === 1 ? "line" : "lines";
+    return [
+        "## Suggested next actions",
+        `When the user must choose what to do next, end the reply with ${amount} ${unit} of:`,
+        "[[action:suggest:<button text>]]",
+        "Clicking a button sends that text as the next user message.",
+        "Use [[action:suggest:<short label>,prompt=<text to send>]] when the label should differ from the sent text.",
+        "Put them on their own lines at the very end, and never mention this syntax in prose.",
+    ].join("\n");
+}
+/** 默认版（4~5 条）：给拿不到设置的地方用（测试、临时会话、预热） */
+export const SUGGESTION_GUIDANCE = suggestionGuidance();

package/dist/server/engine/wiring.js

@@ -9,12 +9,18 @@
  * codex 客户端构造时不 spawn：机器上没装 codex 也能正常启动，只有在切到它时才报错。
  */
 import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createBuiltinEngineRegistry } from "./builtin.js";
+import { enabledSubagentSpecs, readSubagentSettings } from "../subagents/profile-store.js";
 import { createEngineCatalog } from "./catalog.js";
+import { createClaudeSessionsProvider } from "./claude-sessions.js";
+import { createClaudeClient } from "./claude-transport.js";
 import { createCodexSessionsProvider } from "./codex-sessions.js";
 import { createCodexClient } from "./codex-transport.js";
 import { createDshClient } from "./dsh-transport.js";
+import { writeDshSuggestionPatch } from "./dsh-prompt-patch.js";
+import { suggestionGuidance } from "./suggestion-guidance.js";
 import { createDshSessionsProvider } from "./dsh-sessions.js";
 import { createOpencodeSessionsProvider } from "./opencode-sessions.js";
 import { readOpencodeSessionDirs } from "./opencode-projects.js";
@@ -28,7 +34,7 @@ const OPENCODE_DIRS_TTL_MS = 30_000;
  * 仍然按它自己的默认路由给 `currentValue`（实测 `agent-default-model` 不生效），
  * 于是「新会话默认用哪个模型」必须由我们自己指定。
  */
-export function readDshDefaultModel(dir) {
+function readDshDefaultModel(dir) {
     const file = join(dir, "default-model.json");
     if (!existsSync(file))
         return null;
@@ -56,7 +62,14 @@ export function createEngineWiring(options) {
      * 顺序 = 环境变量里显式给的 → 用户目录里的 `*.yml`（按文件名）。
      */
     const patchDir = options.dshPatchDir;
+    /**
+     * 「下一步建议」的写法：dsh 只能靠 patch 叠加层带进去（ACP 的 session/new 没有系统提示字段）。
+     * 写在工作台自己的临时目录，**不**混进用户的 `dsh-patches`；排在最前面，
+     * 用户自己写的 patch 仍有最终决定权。
+     */
+    const suggestionPatchFile = writeDshSuggestionPatch(join(tmpdir(), "oh-my-agent-web"), suggestionGuidance(options.thinkCount?.() ?? null));
     const patchFiles = [
+        suggestionPatchFile,
         ...(options.dshPatches ?? []),
         ...(patchDir && existsSync(patchDir)
             ? readdirSync(patchDir)
@@ -117,18 +130,55 @@ export function createEngineWiring(options) {
         }
         return dirs;
     };
+    /**
+     * Claude Code 的 ACP 客户端（同样懒启动：没装适配器也能正常起工作台）。
+     * 历史会话清单不走它（直接读 `~/.claude/projects`），所以这里只给引擎用。
+     *
+     * `claudeBin` 空串 = 自动探测（老包 `claude-code-acp` / 新包 `claude-agent-acp`）。
+     */
+    const claudeClient = createClaudeClient({
+        bin: options.claudeBin || undefined,
+        args: options.claudeArgs,
+        cwd: options.workspace,
+        log: (text) => options.onLog(text, { engine: "claude" }),
+    });
+    /**
+     * codex 的子代理策略：**每次建会话现读**模板库（面板改完，下一条新会话就生效）。
+     *
+     * 读不到模板目录（精简部署）= 关掉：宁可不给 spawn 工具，也不要让模型
+     * 拿着一堆它看不见的「类型」乱派活。
+     */
+    const codexSubagentPolicy = () => {
+        const dir = options.subagentAgentDir;
+        if (!dir)
+            return { enabled: false, concurrency: 4, profiles: [] };
+        const settings = readSubagentSettings(dir);
+        const profiles = enabledSubagentSpecs(dir).map((profile) => ({
+            id: profile.id,
+            label: profile.label,
+            description: profile.description,
+        }));
+        return { enabled: settings.enabled, concurrency: settings.concurrency, profiles };
+    };
     const registry = createBuiltinEngineRegistry({
         onNotice: options.onNotice,
         ...(options.skillPaths ? { skillPaths: options.skillPaths } : {}),
         onLog: (text) => options.onLog(text),
-        codex: { client: codexClient },
-        dsh: { client: dshClient, model: defaultModel },
+        ...(options.thinkCount ? { thinkCount: options.thinkCount } : {}),
+        codex: { client: codexClient, bin: options.codexBin, subagentPolicy: codexSubagentPolicy },
+        dsh: { client: dshClient, bin: options.dshBin, model: defaultModel },
         opencode: {
             client: opencodeClient,
             bin: options.opencodeBin,
             args: options.opencodeArgs,
             model: options.opencodeModel ?? null,
         },
+        claude: {
+            client: claudeClient,
+            bin: options.claudeBin || undefined,
+            args: options.claudeArgs,
+            model: options.claudeModel ?? null,
+        },
     });
     const catalog = createEngineCatalog({
         registry,
@@ -145,6 +195,8 @@ export function createEngineWiring(options) {
                 workspaces: opencodeWorkspaces,
                 log: (text) => options.onLog(text),
             }),
+            // claude 的历史会话清单：直接读 `~/.claude/projects/*/*.jsonl`（标题/时间/模型都在文件里）
+            claude: createClaudeSessionsProvider({ log: (text) => options.onLog(text) }),
         },
     });
     const resolved = registry.resolve(options.engineName);
@@ -157,11 +209,13 @@ export function createEngineWiring(options) {
         registry,
         catalog,
         resolved,
+        codexClient,
         // 收掉外部引擎的子进程；pi 是进程内 SDK，不需要额外收
         close: () => {
             codexClient.close();
             dshClient.close();
             opencodeClient.close();
+            claudeClient.close();
         },
     };
 }