dsh-session-conductor 1.3.16 → 1.3.18

package/README.md

@@ -27,6 +27,7 @@
 | 上下文用量自查 | AI 按需查自己会话的上下文占用（百分比、已用/容量 tokens）与构成（系统提示词/工具定义/消息文本），占用达 85% 时附收敛建议。数据与界面圆环同源（官方 `contextPressure` / `contextBreakdown` 投影），只读、无参数。**另：每轮把实时用量注入消息尾部**（AI 每轮都能直接看到数字；注入在尾部而非系统提示词前缀 ⇒ 前缀稳定、prompt cache 仍命中；按 turn 门控，一回合只注一次；配置 `injectContextUsage` 可关） | AI 工具 `context_usage` + 每轮注入 |
 | 跨会话消息 | AI 直接给另一个会话发消息（不经过人转达）：先 `list_sessions` 挑目标，再 `send_to_session` 投递；目标空闲时**由本体自动唤醒**它跑一个回合，运行中则排到其下一回合边界（`mode:"steer"` 改为注入当前回合）。全部走本体官方 `prompt` API（幂等 `requestId`、不自己写会话日志）。**支持 `dryRun` 预览**（报告目标状态与限流余量，不投递、不消耗配额）。`list_sessions` 支持 **`query` 子串过滤 + `limit`/`offset` 分页**（默认只给 20 条，避免整表塞进调用方上下文）。**索引快路径 + 后台化**：`fromIndex=true` 直接读落盘索引（秒回、不重建，不含 live 状态与归档态），默认刷新路径先等 3 秒拿热缓存结果、超时就把**同一次在途构建**交给宿主后台 job 并立刻返回 jobId（冷缓存全量构建实测 226 秒 / 201 会话 / 1.5 GB 日志，热缓存 47 毫秒；job 注册失败会同步降级并带回原因）。硬约束：禁自投、协作链跳数 ≥3 拒绝、同一对会话 60s 内最多 5 条 | AI 工具 `list_sessions` / `send_to_session` |
 | 成员权限预设切换 | 给队友/子代理查看与切换**权限预设**（`danger-full-access` / `workspace-write` 等）。**为什么必须有它**：子代理会话在界面上切不了权限预设，而 preset 一旦指向当前不可用的值（典型：`auto` 在「自动审查」关闭后悬空），该成员就永久唤不醒 —— 宿主 `pinInitialPermission()` 在会话发布前抛 `permission: cannot restore preset "auto" without its active integration`，再被 subagent 的 `coldResume()` 统一包成 `subagent/not-resumable`，报错文本完全指不到权限层。实现是**追加一条 `permission/preset` 事件**（独立 zstd 帧、带 checksum、长度 CAS、fsync；已有帧一字节不动，可删尾部回滚），靠宿主折叠语义「最后一条生效」。**参数都可空**：`target` 留空/`*`/`all` = 全部成员（排除 Lead、provisioning、failed）；`preset` 留空/`auto` = 跟随主代理。预设名先从宿主 `permissionPresets.catalog()` 校验，不在列表里直接拒绝（写错的预设会让成员加载失败）。批量串行执行、逐个隔离失败、回执带完整名单 | AI 工具 `set_member_permission` / `list_permission_presets` + 聊天框指令 `/perm-switch` |
+| 成员换名（新建 + 搬内容） | 给成员**换名字**。宿主把 Team 成员名钉死为不可变身份字段（`team/member` 投影里 `name`/`provider`/`context` 一变就抛 `changed immutable identity fields`，且只允许 provisioning → active 这一次写入），也没有任何 rename 接口 —— 所以换名只能「新建一个成员，再把旧内容搬过去」。这条路成立是因为成员名与会话内容分处两地：名字在 **Lead 日志**的 `team/member` 事件里，内容在**成员自己的日志**里，搬内容不会触碰不可变字段。工具 `clone_member_as` 流程：解析源成员 → spawn 新成员（占位任务）→ 中断并等它**真正空闲**（运行中的成员以内存态优先，改磁盘不生效）→ 搬会话事件：保留目标 header 身份、丢弃源的身份类事件、按目标重建 descriptor、**seq 从 0 严格重排**、用官方编码器写（**带 checksum**）→ 写前自检 → 备份后原子替换。旧成员不会被改动，需要脱手自行删除 | AI 工具 `clone_member_as` |
 | 创建成员并选模型 | 一条命令完成「**创建团队成员 + 让第一轮真实任务就用指定模型**」。宿主的 `spawn_teammate` 参数里没有 provider/model（服务层 `SpawnTeammateRequest` 也只有 provider，模型来自 agent-team 插件的 freshProvider/forkProvider 配置），直接创建的话首轮一定用默认模型把真实任务跑掉。本工具因此拆成四步：① 用**占位任务**创建（只消耗一条极短提示）② **立刻中断**把这一轮停掉 ③ **等它真正空闲**（用宿主 `waitForChange` 等状态变化，不睡固定时间；否则取消信号会串到下一轮）④ 写 `model/selection`（与 `set_member_model` 同一条链路，默认不碰任何 @Remote）然后**投递真实任务**。参数里 **`provider`/`model` 是模型 provider**（agnes / wb / sa6400 …）；创建成员另需**子代理 provider**（`ctx.subagents` 注册表，通常 `spawn`），默认自动取第一个，也可用可选参数 `subagentProvider` 指定 —— 两者是不同命名空间，混用会报 `no subagent provider registered`。设模型失败时**不投递**（否则等于用默认模型白跑），投递失败也如实回执。要彻底「创建前定模型」只能改宿主 agent-team（把 model 加进 request），宿主升级会被覆盖 | AI 工具 `create_teammate_with_model` |
 | 指定模型新建会话 | AI 新建会话并可**直接指定 provider/model**（建完即切到该模型），可选带一条初始消息让它立刻开始干活。**缺省工作目录 = 调用方会话自己的 cwd**（不落在 DSH 安装目录里）。本体 `create` 本身不带模型，所以是 `create` → `selectModel` 两步；任一步失败会如实回执（如「会话已建，但模型未设置」），不谎报成功。**支持 `dryRun` 预览**（含模型是否存在于目录的核对），不建会话 | AI 工具 `create_session` |
 
@@ -189,10 +190,89 @@ preview  { action: "serve", file: "<插件根>/assets/preview.html", backend: "h
 要查**实际**在用什么（含历史请求，不只本次进程）或切换：
   /model-switch <成员名或 sessionId>              ← 查实际模型
   /model-switch <成员名或 sessionId> <provider>/<模型>  ← 切换并回显查证
-  /model-switch * <provider>/<模型>                    ← 全部成员切到该模型（回执带名单）
-  /model-switch <成员名|*> auto                        ← 跟随主代理（Lead）当前模型
+
+和别人对齐 / 批量：
+  /model-switch * auto   ← 最常用：所有子代理都换成「我自己现在用的」模型
+  /model-switch <成员名> auto   ← 只让这一个成员换成我自己现在用的模型
+  /model-switch * <provider>/<模型>   ← 所有子代理换成一个指定的模型
+
+* = 全部成员（不含我自己）；auto = 「跟我保持一致」，不用去查我用的是哪个模型。
+```
+
+### 让全部子代理和我用同一个模型
+
+三种写法都能做到，按场景挑：
+
+| 场景 | 用户指令 | AI 工具调用 |
+|---|---|---|
+| **所有子代理都跟我一致** | `/model-switch * auto` | `set_member_model({})`（三个参数全留空） |
+| 只让某一个跟我一致 | `/model-switch <成员名> auto` | `set_member_model({ target: "<成员名>" })` |
+| 所有子代理统一到指定模型 | `/model-switch * sa6400/deepseek-v4.1-flash` | `set_member_model({ provider: "sa6400", model: "deepseek-v4.1-flash" })` |
+
+**参数留空的语义**（指令与工具一致）：
+
+| 参数 | 留空 / `*` / `auto` 的含义 |
+|---|---|
+| 成员（`target` 或第一个位置参数） | 留空或 `*` = **全部成员**（自动排除我自己，也排除正在创建 / 已失败的） |
+| 模型（`provider`+`model` 或第二个位置参数） | 留空或 `auto` = **跟主代理（Lead）一致**，即我自己当前实际在用的模型 |
+
+「我自己在用的模型」取自**请求级权威记录**（会话日志里的 `request/header`，即真实发出请求时用的值），
+读不到就如实报错，不会拿名册里的静态字段冒充。批量执行**串行**、**逐个隔离失败**、**回执带完整名单**。
+
+权限预设同样支持这套写法：`/perm-switch * auto` = 所有子代理的权限预设跟我一致；
+`set_member_permission({})` 等价。
+
+注意：正在跑回合的成员会被跳过（等 60s 仍未结束则报错并提示先中断）—— 这是有意的，
+运行中切模型不生效，还可能被其内存态覆盖。
+
+### 为什么子代理界面上没有「切换模型」按钮
+
+主会话输入框右上角那个模型选择器，在**子代理会话里是宿主硬性关掉的**，不是本插件漏做，也不是宿主漏做：
+
+```js
+// client/ui-model-selection/src/client/index.ts:134
+available: session => sessions.subagentAddress(session.sessionId) === undefined,
+
+// client/ui-model-selection/src/client/directory.ts:153
+throw new Error('model selection is unavailable for addressed subagent sessions')
 ```
 
+宿主源码给出的原因（同文件 `index.ts:9-11`）：子代理会话绑定的模型 RPC 会**绕过父级续跑路径去激活已持久化的历史**，
+所以 UI 层把入口直接关掉。任何走 `session.selectModel` 那条 RPC 的实现都会撞上同一个拦截，装插件也绕不过去。
+
+**所以子代理的模型只能由本插件切换** —— 我们写的是 `model/selection` 事件（交给宿主官方投影接管），
+不经过那条被禁的 RPC，因此不受该限制：
+
+| 目的 | 用户指令 | AI 工具 |
+|---|---|---|
+| 单个成员换成指定模型 | `/model-switch <成员名> <provider>/<模型>` | `set_member_model({ target, provider, model })` |
+| 单个成员跟我用同一个 | `/model-switch <成员名> auto` | `set_member_model({ target })` |
+| 全部子代理跟我用同一个 | `/model-switch * auto` | `set_member_model({})` |
+
+权限预设同理（`/perm-switch`、`set_member_permission`）—— 子代理界面上同样没有权限切换入口。
+
+### 模型切换为什么要写 override（以及它和官方界面的关系）
+
+官方模型选择链是「投影 pending → 会话请求头 → 部署默认」：写 `model/selection` 事件只让 pending
+生效**一轮**，被 `request/header` 消费后，新回合会沿请求头链回落，最终回到部署默认模型。
+所以本插件在 `agent/request` 瀑布流里按会话强制改写请求配置（每轮都改 → 跨轮必然持久），
+这份持久状态存在插件域 `memberModelOverrides` 里。
+
+**这个机制曾有致命副作用**（1.3.18 修复）：override 优先级高于官方链路，一旦写入，
+用户在主会话界面用官方模型选择器切换就**完全无效** —— 界面显示新模型、请求一直走 override 里的旧模型，
+不报错、不提示、也没有清除入口。现场表现为「界面切三次、跨三个回合、改日志、重启宿主全都不动」。
+
+**现在的行为**：官方切换会往 `modelSelection` 投影写 `pending`，插件每轮请求前把它与 override 比对，
+不一致就**把 override 同步成官方的新值**（同步而非清除 —— 既让界面选择立刻生效，又保留跨轮持久能力）。
+同步失败只记一条日志并退回旧 override，绝不打断请求。
+
+使用注意：
+
+- 同步只发生在**已有 override 的会话**上；没有 override 的会话完全交给官方链路，插件不干预。
+- `set_member_model` 的批量「跟随主代理」（`auto` / 三参数全空）写入的是**当时**主代理用的模型；
+  之后主代理再换模型，这些成员**不会**自动跟着变（需再执行一次）。
+- 想让某个会话彻底回到「官方说了算」，执行一次官方界面切换即可（override 会被同步成新值）。
+
 「最近请求」取自**进程内真实请求记录**（瞬时、不扫日志）；显示「未知」说明本进程还没见它请求过，用 ② 查历史。若同时显示目标与最近请求且不一致，会附 `⚠️ 与目标不一致（下一回合生效前属正常）`。
 
 **② 查某个成员实际在用什么**

package/lib/apply.js

@@ -21,7 +21,8 @@ import { refreshTitleState } from './features/rename/title.js';
 // 成员模型：本文件用到 findTargetAgent / switchAgentModel / getMemberModelOverride /
 //   applyModelOverride / validateModelPair（拆出 apply.js 时漏了这一行 import，
 //   运行到相关代码路径会 ReferenceError: getMemberModelOverride is not defined）
-import { getMemberModelOverride, applyModelOverride, noteRequestModel, takeSwitchOutcomes } from './features/member-model/index.js';
+import { getMemberModelOverride, applyModelOverride, noteRequestModel, takeSwitchOutcomes,
+  adoptOfficialSelection, readOfficialPendingSelection, setMemberModelOverride } from './features/member-model/index.js';
 // 会话操作的路由注册已抽到独立模块（handler 实现见该模块；此处只留注册入口）
 import { registerSessionOpsRoutes } from './features/session-ops-routes.js';
 import { registerMemberModelTools } from './features/member-model/tools.js';
@@ -317,7 +318,25 @@ export async function apply(ctx, config = {}) {
     // override 由 set_member_model 写入（domain 持久 + 内存缓存镜像），每轮都改 → 跨轮持久。
     ctx.on("agent/request", async ({ agent }, next) => {
       const resolved = await next();
-      const override = await getMemberModelOverride(ctx, agent?.session?.id);
+      const sessionId = agent?.session?.id;
+      let override = await getMemberModelOverride(ctx, sessionId);
+      // 官方界面切换同步：override 优先级高于官方链路，若用户在主会话界面用官方选择器改了模型，
+      // 不把新值同步进 override 就会出现「界面显示新模型、请求一直走旧模型」且无处可查
+      // （实测事故：批量写入的 override 把会话钉在已失效 provider 上，界面切换、改日志、重启全无效）。
+      // 做法是同步而不是清除：官方切换会写投影 pending，这里把它写回 override，
+      // 既让界面选择立刻生效，又保留 override 的跨轮持久能力（不会回落部署默认）。
+      try {
+        const pending = readOfficialPendingSelection(ctx, agent);
+        const adopt = adoptOfficialSelection(override, pending);
+        if (adopt) {
+          await setMemberModelOverride(ctx, sessionId, adopt.provider, adopt.model);
+          override = adopt;
+          log(ctx, `官方界面切换已同步到 override：${sessionId} → ${adopt.provider}/${adopt.model}`);
+        }
+      } catch (error) {
+        // 同步失败绝不打断请求：退回用旧 override（行为与修复前一致）
+        log(ctx, `官方切换同步失败（不影响本次请求）: ${String(error?.message ?? error)}`);
+      }
       const applied = applyModelOverride(resolved, override);
       // 切换查证（事件驱动）：记录本次请求**真实使用**的 provider/model；若该会话有待查证项，
       // 就在这里按事件判定结果并入队（切换本身不阻塞、不轮询 —— 只等事件到）。

package/lib/features/member-model/clone-member.js

@@ -0,0 +1,270 @@
+// dsh-session-conductor — 把成员「换名」成新成员（新建 + 搬会话内容）
+//
+// 【为什么需要它】宿主的 Team 成员名是**不可变身份字段**：`team/member` 投影里有断言
+//   if (prior.name !== member.name || prior.provider !== member.provider || prior.context !== member.context)
+//     throw new Error('changed immutable identity fields')
+// 而且只允许 provisioning → active 这一次写入，已 active 的成员再写必被 phase 校验拒绝；
+// 宿主侧也没有任何 rename 接口。所以「改名」唯一可行的路是：**新建一个成员，再把旧内容搬过去**。
+//
+// 【为什么这条路成立】成员名与会话内容是两份独立数据：
+//   · 成员名 → 存在 **Lead 会话日志**的 `team/member` 事件里（换名时由 spawn 写入新名）
+//   · 会话内容 → 存在 **成员自己的会话日志**里（本模块替换的就是这一份，其中没有 team/member）；
+//     实测该日志的事件里 0 处引用自己的 sessionId，因此**只换 header 就够**。
+//
+// 【搬运必须「原样复制」（一次真实事故换来的结论）】会话事件之间布满了跨事件引用：
+//   顶层 `sourceEventSeqs`、顶层 `surfaceOp { startSeq, endSeq }`、`data.messageSeqs`、
+//   `data.shadowedSeqs`、`data.headerSeq`，以及 compaction 的 start → summary/prune → end 强配对。
+//   任何 seq 重排或事件增删都会让这些关系断裂，宿主加载时直接判 corrupt。实测连续撞过三种：
+//     ① `sourceEventSeqs ranges must contain unique earlier seqs`
+//     ② `session/title messageSeqs must cite distinct earlier human user/message events`
+//     ③ `successful compaction/end requires one summary`
+//   而搬运本质就是复制：源 seq 本来就是 0..N 连续，所以正确做法是
+//   **事件一条不改、seq 一个不动，只替换 header 里的身份字段**。
+//
+// 【必须保留的两条硬约束】
+//   ① 帧必须带校验和：宿主读帧会验 checksum，缺了就报「会话文件 总和检查码不匹配」直接拒读；
+//   ② 目标成员不能正在跑：宿主以内存态优先，对运行中的成员改磁盘文件不生效，还可能被覆盖回去。
+import { readFileSync, writeFileSync, renameSync, copyFileSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { log } from "../../shared/log.js";
+import { findTargetAgent } from "./locate.js";
+import { PLACEHOLDER_PROMPT, waitUntilIdle } from "./create-teammate.js";
+
+/**
+ * 把源会话的事件原样搬到目标会话日志，**只替换 header 身份**。
+ *
+ * 设计要点（每一条都是为了避免破坏跨事件引用）：
+ *   · 源事件一条不丢、seq 一个不改 —— 引用关系因此天然保持，compaction 配对也完整；
+ *   · header 用**目标**自己的（id / cwd / parentSession / origin / delegationDepth / isSeeded），
+ *     否则新成员会变成旧成员；
+ *   · 只允许改 `subagent/descriptor` 里的 label / 模型路由（纯字符串字段，不参与任何引用）。
+ *
+ * @param {string} sourceFile 源成员会话日志
+ * @param {string} targetFile 目标成员会话日志
+ * @param {{label?: string, seedProvider?: string, seedModel?: string}} [opts]
+ *        label 改写 descriptor 的描述；seedProvider/seedModel 改写 descriptor 的模型路由（省略则沿用源）
+ * @returns {Promise<{ok: true, events: number, backup: string, size: number} | {ok: false, error: string}>}
+ */
+export async function transplantSessionLog(sourceFile, targetFile, opts = {}) {
+  const { decodeAllFrames } = await import("../../zstd-frames.js");
+  const { encodeSessionText } = await import("../../repair.js");
+
+  // ① 目标 header：新成员的身份，原样保留
+  let targetHead;
+  try {
+    const text = await decodeAllFrames(readFileSync(targetFile));
+    targetHead = JSON.parse(text.split("\n").find((l) => l.trim() !== ""));
+  } catch (error) {
+    return { ok: false, error: `读取目标会话 header 失败：${String(error?.message ?? error)}` };
+  }
+  if (!targetHead?.id) return { ok: false, error: "目标会话 header 缺少 id，无法确定新成员身份" };
+
+  // ② 源事件：全部读取，一条不丢（只跳过 header 那一行）
+  let sourceEvents;
+  try {
+    const text = await decodeAllFrames(readFileSync(sourceFile));
+    sourceEvents = [];
+    for (const line of text.split("\n")) {
+      if (line.trim() === "") continue;
+      let e;
+      try { e = JSON.parse(line); } catch { continue; }
+      if (e?.type === "session") continue;   // header 用目标的
+      sourceEvents.push(e);
+    }
+  } catch (error) {
+    return { ok: false, error: `读取源会话失败：${String(error?.message ?? error)}` };
+  }
+  if (sourceEvents.length === 0) return { ok: false, error: "源会话没有可搬运的事件" };
+
+  // ③ 仅改写 descriptor 的人类可读字段（不碰 seq、不碰任何引用）
+  for (const e of sourceEvents) {
+    if (e?.type !== "subagent/descriptor" || !e.data) continue;
+    if (opts.label !== undefined) e.data.label = String(opts.label);
+    if (opts.seedProvider !== undefined) e.data.agentProvider = String(opts.seedProvider);
+    if (opts.seedModel !== undefined) e.data.agentModel = String(opts.seedModel);
+  }
+
+  const outText = [JSON.stringify(targetHead), ...sourceEvents.map((e) => JSON.stringify(e))].join("\n") + "\n";
+  const encoded = await encodeSessionText(outText);   // 官方编码器：自带 checksum
+
+  // ④ 写前自检：解码回来**逐条与源对比**。这是唯一能证明「除 header 与 descriptor 外一字未改」的检查，
+  //    也是唯一能保证「源能加载 ⇒ 目标也能加载」的依据（跨事件引用全部原样）。
+  let verifyLines;
+  try {
+    const verifyText = await decodeAllFrames(encoded);
+    verifyLines = verifyText.split("\n").filter((l) => l.trim() !== "");
+  } catch (error) {
+    return { ok: false, error: `写前自检解码失败：${String(error?.message ?? error)}` };
+  }
+  if (verifyLines.length !== sourceEvents.length + 1) {
+    return { ok: false, error: `写前自检事件数不符（期望 ${sourceEvents.length + 1} 行，实际 ${verifyLines.length}）` };
+  }
+  const verifyHead = JSON.parse(verifyLines[0]);
+  if (verifyHead.id !== targetHead.id) {
+    return { ok: false, error: `写前自检 header 身份不符（期望 ${targetHead.id}，实际 ${verifyHead.id}）` };
+  }
+  const normalize = (v) => JSON.stringify(v);
+  for (let i = 0; i < sourceEvents.length; i += 1) {
+    let got;
+    try { got = JSON.parse(verifyLines[i + 1]); } catch {
+      return { ok: false, error: `写前自检第 ${i + 2} 行不是合法 JSON` };
+    }
+    const want = sourceEvents[i];
+    if (normalize(got) === normalize(want)) continue;
+    // descriptor 允许 label / 模型路由不同，其余必须逐字段一致
+    if (want?.type === "subagent/descriptor" && got?.type === "subagent/descriptor") {
+      const a = { ...want.data }; const b = { ...got.data };
+      delete a.label; delete b.label; delete a.agentProvider; delete b.agentProvider;
+      delete a.agentModel; delete b.agentModel;
+      if (normalize(a) === normalize(b) && got.seq === want.seq) continue;
+    }
+    return { ok: false, error: `写前自检失败：第 ${i + 2} 行（seq ${want?.seq ?? "?"} / ${want?.type ?? "?"}）与源不一致，放弃写入` };
+  }
+
+  // ⑤ 备份目标原日志 → 原子写回
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backup = join(dirname(targetFile), `session.before-clone-${stamp}.bak`);
+  try {
+    copyFileSync(targetFile, backup);
+  } catch (error) {
+    return { ok: false, error: `备份目标日志失败（未写入）：${String(error?.message ?? error)}` };
+  }
+  const tmp = join(dirname(targetFile), ".session.clone.tmp");
+  writeFileSync(tmp, encoded, { mode: 0o600 });
+  renameSync(tmp, targetFile);
+
+  return { ok: true, events: sourceEvents.length, backup, size: statSync(targetFile).size };
+}
+
+/**
+ * 把成员 A 的会话内容克隆到一个新成员 B（B 用新名字，A 不动）。
+ *
+ * 四步：① 解析源成员 ② spawn 新成员（占位任务，只消耗极短提示）③ 中断并等它空闲
+ *      ④ 把源会话内容原样搬进新成员日志。
+ *
+ * @param {object} ctx 插件 context
+ * @param {object} exec 执行上下文（含 agent）
+ * @param {{source: string, name: string, description?: string, withHistory?: boolean,
+ *          provider?: string, model?: string, subagentProvider?: string}} args 参数
+ * @returns {Promise<object>} 回执对象（成功含 newMember，失败含 error）
+ */
+export async function cloneMemberAs(ctx, exec, args) {
+  const caller = exec?.agent ?? null;
+  const source = String(args?.source ?? "").trim();
+  const name = String(args?.name ?? "").trim();
+  if (!source) return { error: "source 不能为空（成员名 / sessionId / 标题关键字）" };
+  if (!name) return { error: "name 不能为空（新成员名，lower-kebab-case）" };
+
+  // ① 源成员
+  const found = findTargetAgent(ctx, source, { caller });
+  if (found?.error) return { error: `找不到源成员：${found.error}` };
+  if (found.sessionId === name) return { error: "新成员名与源成员相同，无需克隆" };
+
+  // 目标会话日志路径要在 spawn 之前确认定位能力可用（否则白建一个成员）
+  const { findSessionLogById, sessionsRootOf } = await import("../../sessions/events.js");
+  const sourceFile = findSessionLogById(found.sessionId, sessionsRootOf());
+  if (!sourceFile) return { error: `源成员会话日志不存在（sessionId=${found.sessionId}）` };
+
+  // ② 能力检查
+  const teams = ctx.get("agentTeams");
+  if (typeof teams?.spawnTeammate !== "function") return { error: "宿主未挂载 agentTeams.spawnTeammate，无法新建成员" };
+  const lead = caller;
+  if (!lead) return { error: "拿不到发起方 Agent（请从 Lead 会话调用）" };
+  let subagentProvider = String(args?.subagentProvider ?? "").trim();
+  if (!subagentProvider) {
+    try {
+      const list = ctx.get("subagents")?.list?.() ?? [];
+      subagentProvider = String(list[0] ?? "");
+    } catch { subagentProvider = ""; }
+  }
+  if (!subagentProvider) return { error: "拿不到子代理 provider（ctx.subagents.list() 为空），可显式传 subagentProvider" };
+
+  // ③ spawn + 中断 + 等空闲
+  let spawned;
+  try {
+    spawned = await teams.spawnTeammate(lead, {
+      name,
+      description: String(args?.description ?? `克隆自 ${found.member?.name ?? found.sessionId}`),
+      prompt: [{ type: "text", text: PLACEHOLDER_PROMPT }],
+      context: "fresh",
+      provider: subagentProvider,
+    });
+  } catch (error) {
+    return { error: `新建成员失败：${String(error?.message ?? error)}` };
+  }
+  const newId = spawned?.id ?? spawned?.sessionId ?? null;
+  if (!newId) return { error: "新建成员成功但拿不到 sessionId" };
+
+  try {
+    if (typeof teams.interrupt === "function") {
+      try { await teams.interrupt(lead, name); } catch { /* 可能已结束，继续等 */ }
+    }
+    const idle = await waitUntilIdle(teams, lead, name, null);
+    if (!idle.idle) {
+      return { error: `新成员仍在运行（status=${idle.status}），为避免覆盖其内存态，未搬内容；可稍后重试`, newMember: { name, sessionId: newId } };
+    }
+
+    // ④ 搬内容
+    if (args?.withHistory === false) {
+      return { ok: true, newMember: { name, sessionId: newId }, events: 0, note: "已按要求只建空成员，未搬历史" };
+    }
+    const targetFile = findSessionLogById(newId, sessionsRootOf());
+    if (!targetFile) return { error: `新成员会话日志不存在（sessionId=${newId}）`, newMember: { name, sessionId: newId } };
+
+    const moved = await transplantSessionLog(sourceFile, targetFile, {
+      seedProvider: String(args?.provider ?? "").trim() || undefined,
+      seedModel: String(args?.model ?? "").trim() || undefined,
+    });
+    if (!moved.ok) return { error: `搬会话内容失败：${moved.error}`, newMember: { name, sessionId: newId } };
+
+    log(ctx, `成员克隆：${found.sessionId} → ${newId}（${moved.events} 事件，${(moved.size / 1048576).toFixed(2)}MB）`);
+    return {
+      ok: true,
+      newMember: { name, sessionId: newId },
+      sourceMember: { name: found.member?.name ?? null, sessionId: found.sessionId },
+      events: moved.events,
+      backup: moved.backup,
+      sizeMB: Number((moved.size / 1048576).toFixed(2)),
+    };
+  } catch (error) {
+    return { error: `克隆过程失败：${String(error?.message ?? error)}`, newMember: { name, sessionId: newId } };
+  }
+}
+
+/**
+ * 渲染 clone_member_as 的回执。
+ *
+ * 要点：① 明确「新成员已建、旧成员未动」，避免误以为旧成员被改名/删除；
+ * ② 报出搬了多少事件与多大体积（这是唯一能说明「内容真的搬过去了」的量）；
+ * ③ 报出备份路径（搬错可回滚）；④ 失败时连带已建成员一起说明，免得留下孤儿成员。
+ *
+ * @param {{source?: string, name?: string, withHistory?: boolean}} args 调用参数
+ * @param {object} result cloneMemberAs 的返回
+ * @returns {string}
+ */
+export function renderCloneMemberResult(args, result) {
+  const lines = [];
+  if (result?.error) {
+    lines.push(`克隆失败：${result.error}`);
+    if (result.newMember?.sessionId) {
+      lines.push(`已创建但未搬内容的新成员：${result.newMember.name}(${result.newMember.sessionId})`);
+      lines.push("该成员是空壳，可按需删除（delete 或团队面板移除）。");
+    }
+    return lines.join("\n");
+  }
+  const nm = result.newMember ?? {};
+  lines.push(`已新建成员：${nm.name}(${nm.sessionId})`);
+  if (result.sourceMember?.sessionId) {
+    lines.push(`内容来源：${result.sourceMember.name ?? "(未命名)"}(${result.sourceMember.sessionId}) — 该成员本身未改动`);
+  }
+  if (result.note) {
+    lines.push(result.note);
+  } else {
+    lines.push(`搬运事件：${result.events} 条 ｜ 会话体积：${result.sizeMB}MB`);
+    lines.push(`回滚备份：${result.backup}`);
+  }
+  lines.push("");
+  lines.push("生效方式：新成员下次被唤醒时按磁盘日志加载（当前是冷会话，此时替换才生效）。");
+  lines.push("如需「改名」效果，旧成员可自行删除；名字唯一性由宿主保证，新名不能与现有成员重复。");
+  return lines.join("\n");
+}

package/lib/features/member-model/command.js

@@ -55,8 +55,13 @@ async function renderMemberList(ctx, invocation) {
   lines.push("要查**实际**在用什么（含历史请求，不只本次进程）或切换：");
   lines.push(`  /${COMMAND_NAME} <成员名或 sessionId>              ← 查实际模型`);
   lines.push(`  /${COMMAND_NAME} <成员名或 sessionId> <provider>/<模型>  ← 切换并回显查证`);
-  lines.push(`  /${COMMAND_NAME} * <provider>/<模型>              ← 全部成员切到该模型（回执带名单）`);
-  lines.push(`  /${COMMAND_NAME} <成员名|*> auto                  ← 跟随主代理（Lead）当前模型`);
+  lines.push("");
+  lines.push("和别人对齐 / 批量：");
+  lines.push(`  /${COMMAND_NAME} * auto   ← 最常用：所有子代理都换成「我自己现在用的」模型`);
+  lines.push(`  /${COMMAND_NAME} <成员名> auto   ← 只让这一个成员换成我自己现在用的模型`);
+  lines.push(`  /${COMMAND_NAME} * <provider>/<模型>   ← 所有子代理换成一个指定的模型`);
+  lines.push("");
+  lines.push("* = 全部成员（不含我自己）；auto = 「跟我保持一致」，不用去查我用的是哪个模型。");
   return lines.join("\n");
 }
 
@@ -166,7 +171,7 @@ export async function handleModelSwitchCommand(ctx, invocation) {
       if (isAllTarget(targetRaw)) {
         return {
           kind: "error",
-          text: `批量操作需要指定模型：\n  /${COMMAND_NAME} * <provider>/<模型>   ← 全部成员切到该模型\n  /${COMMAND_NAME} * auto                  ← 全部成员跟随主代理（Lead）当前模型`,
+          text: `批量操作需要指定模型：\n  /${COMMAND_NAME} * auto   ← 所有子代理换成我自己现在用的模型（最常用）\n  /${COMMAND_NAME} * <provider>/<模型>   ← 所有子代理换成指定模型`,
         };
       }
       const found = findTargetAgent(ctx, targetRaw, { caller });

package/lib/features/member-model/create-teammate.js

@@ -29,7 +29,7 @@ import { switchAgentModel } from "./switch.js";
  * 占位任务：只为让成员被创建出来，不产生实质动作。
  * 写得极短是为了把首轮消耗压到最低（这一轮拿不到指定模型，越短越不亏）。
  */
-const PLACEHOLDER_PROMPT = "先待命：不要执行任何操作，不要调用任何工具，不要读写任何文件，等待后续消息。";
+export const PLACEHOLDER_PROMPT = "先待命：不要执行任何操作，不要调用任何工具，不要读写任何文件，等待后续消息。";
 
 /**
  * 等成员真正空闲（中断的取消信号被观测完）再投递。
@@ -39,7 +39,7 @@ const PLACEHOLDER_PROMPT = "先待命：不要执行任何操作，不要调用
  * 用宿主自己的 `waitForChange` 等状态变化（事件驱动），不睡固定时间。
  * @returns {Promise<{idle:boolean, status:string}>}
  */
-async function waitUntilIdle(teams, caller, name, signal, budget = 60) {
+export async function waitUntilIdle(teams, caller, name, signal, budget = 60) {
   if (typeof teams?.listMembers !== 'function' || typeof teams?.waitForChange !== 'function') {
     // 老宿主没有这两个能力：退化为「不等待」，行为与之前一致
     return { idle: false, status: 'unknown' };

package/lib/features/member-model/index.js

@@ -13,7 +13,11 @@ export {
   // 批量目标解析（空 / `*` / `all` = 全部成员，排除 Lead）与 Lead 定位
   collectTeamMembers, isAllTarget, resolveTargets, resolveLeader,
 } from "./locate.js";
-export { getMemberModelOverride, setMemberModelOverride, applyModelOverride, resetMemberModelCacheForTest } from "./override.js";
+export {
+  getMemberModelOverride, setMemberModelOverride, applyModelOverride, resetMemberModelCacheForTest,
+  // 官方界面切换的同步：override 优先级高于官方链路，不同步就会出现「界面切了但请求不变」
+  adoptOfficialSelection, readOfficialPendingSelection,
+} from "./override.js";
 export { waitForIdle, appendSelectionEventToLog, switchAgentModel } from "./switch.js";
 // 切换查证（事件驱动，注册 job 不阻塞）：登记待查证项 → 每次请求记录实际模型 → 按事件判定 → 结果回报
 export {
@@ -33,3 +37,5 @@ export { registerPermSwitchCommand, handlePermSwitchCommand } from "./permission
 export { readLeaderRoute } from "./lead.js";
 // 批量应用与回执渲染（串行执行、逐个隔离失败、回执带完整名单）
 export { applyModelToMany, applyPermissionToMany, renderBatchReport, memberDisplay } from "./batch.js";
+// 换名通道：新建成员 + 搬会话内容（成员名在宿主里不可变，只能走这条路）
+export { cloneMemberAs, transplantSessionLog, renderCloneMemberResult } from "./clone-member.js";

package/lib/features/member-model/override.js

@@ -77,6 +77,56 @@ export function applyModelOverride(resolved, override) {
   return { ...rest, provider: override.provider, model: override.model };
 }
 
+/**
+ * 判断是否要把「官方界面刚选的模型」同步进 override。
+ *
+ * 【为什么需要它】本插件的 override 是**每轮强制改写请求**的持久状态，优先级高于官方链路。
+ * 于是有个致命副作用：一旦写入，用户在主会话界面用官方模型选择器切换**完全无效** ——
+ * 界面显示新模型、实际请求走 override 里的旧模型，而且不报错、不提示、无清除入口
+ * （实测事故：批量「跟随主代理」把一批会话钉在某个已失效 provider 上，界面怎么切都不动，
+ *   改会话日志、重启宿主也都没用，因为 override 存在 domain 里且每轮覆盖）。
+ *
+ * 【做法：同步，而不是清除】官方切换会往 `modelSelection` 投影写 `pending`；
+ * 而插件在 hook 里用 override 改写了请求配置 → 与 pending 不匹配 → `consumeSelection` 不会
+ * 清空它，于是 pending 会一直保留。每轮把它与 override 比对，不一致就**把 override 更新成
+ * pending 的值**：官方界面选择立刻生效，同时仍享有 override 的「跨轮持久」能力（不会回落）。
+ *
+ * 只在**已存在 override** 的会话上同步：没有 override 的会话不干预，交给官方链路自己跑。
+ *
+ * @param {{provider: string, model: string} | null} override 当前生效的 override
+ * @param {{provider: string, model: string} | null} pending 官方投影里的待生效选择
+ * @returns {{provider: string, model: string} | null} 需要写入的新 override；null = 无需同步
+ */
+export function adoptOfficialSelection(override, pending) {
+  if (!override || !pending) return null;
+  if (typeof pending.provider !== "string" || typeof pending.model !== "string") return null;
+  if (pending.provider === "" || pending.model === "") return null;
+  if (override.provider === pending.provider && override.model === pending.model) return null;
+  return { provider: pending.provider, model: pending.model };
+}
+
+/**
+ * 从会话投影里读官方「待生效」的模型选择（官方界面切换会写这里）。
+ *
+ * 投影不可用、字段缺失、调用抛错一律返回 null（宁可不同步，也不要在 hook 里抛异常打断请求）。
+ *
+ * @param {object} ctx 插件 context
+ * @param {object} agent 当前请求所属 agent
+ * @returns {{provider: string, model: string} | null}
+ */
+export function readOfficialPendingSelection(ctx, agent) {
+  try {
+    const projections = ctx?.sessionProjections ?? ctx?.get?.("sessionProjections");
+    const state = projections?.stateOf?.(agent?.session, "modelSelection");
+    const pending = state?.pending;
+    if (!pending || typeof pending !== "object") return null;
+    if (typeof pending.provider !== "string" || typeof pending.model !== "string") return null;
+    return { provider: pending.provider, model: pending.model };
+  } catch {
+    return null;
+  }
+}
+
 /** 测试钩子：清空 override 缓存（单测在场景之间调用）。 */
 export function resetMemberModelCacheForTest() {
   memberModelCache.clear();

package/lib/features/member-model/permission-command.js

@@ -49,7 +49,7 @@ export async function handlePermSwitchCommand(ctx, invocation) {
       if (isAllTarget(targetRaw)) {
         return {
           kind: "error",
-          text: `批量操作需要指定预设：\n  /${COMMAND_NAME} * <预设名>   ← 全部成员切到该预设\n  /${COMMAND_NAME} * auto        ← 全部成员跟随主代理（Lead）当前预设`,
+          text: `批量操作需要指定预设：\n  /${COMMAND_NAME} * auto   ← 所有子代理换成我自己现在的权限预设（最常用）\n  /${COMMAND_NAME} * <预设名>   ← 所有子代理换成指定预设`,
         };
       }
       const found = findTargetAgent(ctx, targetRaw, { caller });

package/lib/features/member-model/tools.js

@@ -21,6 +21,7 @@ import { registerContextUsageTool } from "../context-usage/index.js";
 import { registerMemoryRecallTool } from "../memory-recall/index.js";
 import { registerSessionMessagingTools } from "../session-messaging/index.js";
 import { registerPermSwitchCommand } from "./permission-command.js";
+import { cloneMemberAs, renderCloneMemberResult } from "./clone-member.js";
 
 /**
  * 注册成员模型/权限相关的全部 AI 工具与聊天指令。
@@ -312,6 +313,40 @@ async function describeSwitchSnapshot(ctx, sessionId, provider, model) {
       log(ctx, `记忆取回工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
     }
     log(ctx, "成员模型工具已注册 (list_models / set_member_model)");
+    // 把成员「换名」成新成员（新建 + 搬会话内容）。
+    // 宿主把成员名钉死为不可变身份字段：`team/member` 投影里 name/provider/context 一变就抛
+    // `changed immutable identity fields`，且只允许 provisioning → active 这一次写入，
+    // 宿主也没有任何 rename 接口。所以换名只能「新建成员 + 搬旧会话内容」。
+    // 这条路成立是因为成员名与会话内容分处两地：名字在 Lead 日志的 team/member 事件里，
+    // 内容在成员自己的日志里——搬内容不会触碰不可变字段。
+    try {
+      tools.register(defineTool({
+        name: "clone_member_as",
+        description: "把一个成员的会话内容克隆到一个新成员（用于换名：宿主不允许改成员名，只能新建+搬内容）。内部流程：解析源成员 → spawn 新成员（占位任务）→ 中断并等它空闲 → 把源会话事件搬进新成员日志（重排 seq、带 checksum、写前自检、自动备份）。只由 Team Lead 调用。旧成员不会被改动，需要脱手请自行删除。",
+        parameters: {
+          source: { type: "string", required: true, description: "源成员：成员名 / sessionId / 标题关键字" },
+          name: { type: "string", required: true, description: "新成员名（lower-kebab-case，不能与现有成员重复）" },
+          description: { type: "string", description: "新成员职责简述（默认「克隆自 <源成员>」）" },
+          withHistory: { type: "boolean", description: "是否搬历史内容（默认 true）。传 false = 只建空成员" },
+          provider: { type: "string", description: "写进新成员 descriptor 的模型 provider（省略则沿用宿主默认）" },
+          model: { type: "string", description: "写进新成员 descriptor 的模型 id（省略则沿用宿主默认）" },
+          subagentProvider: { type: "string", description: "子代理 provider（默认取 ctx.subagents.list() 第一个，通常就是 spawn）。一般不用填" },
+        },
+        output: {
+          schema: { type: "string" },
+          render(args, value) {
+            return [{ type: "text", text: String(value) }];
+          },
+        },
+        async execute(args, exec) {
+          const result = await cloneMemberAs(ctx, exec, args);
+          return renderCloneMemberResult(args, result);
+        },
+      }));
+      log(ctx, "成员克隆工具已注册 (clone_member_as)");
+    } catch (error) {
+      log(ctx, `成员克隆工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
+    }
     // 聊天框指令 `/model-switch`：用户自己就能看/切成员模型的入口（与 AI 工具同一套切换 + 查证路径）。
     // 异步注册 + 独立兜底：宿主 commands 服务或 brand 包不可用时只留痕，绝不影响其它功能（同既有约定）。
     registerModelSwitchCommand(ctx)

package/lib/features/settings-routes.js

@@ -7,12 +7,23 @@
 //       /compaction-model · /auto-rename-model（两条模型设置）、/auto-continue-gate（自动继续闸门）
 import { readJson, send } from '../http.js';
 import { log } from '../shared/log.js';
-import { readSwitch, patchSwitch } from '../core/config.js';
+// cfg 是核心配置的 live binding（`export let cfg`）：模板落盘目录与浏览根都由它算出来。
+// 拆分时漏掉这一个 import 会让 registerSettingsRoutes 在**调用期**抛 ReferenceError，
+// 进而使整个 webServer inject 回调中断 —— 表现为「settings 及其之后的所有路由全部 404」。
+import { cfg, readSwitch, patchSwitch, resolveBrowseRoot, resolveDshHome } from '../core/config.js';
 import { invalidateSessionListCache } from '../sessions/list-cache.js';
 import { pluginDomain } from '../core/domain.js';
-import { resolveBrowseRoot, resolveDshHome } from '../core/config.js';
 import { setTemplateStateCache } from '../shared/test-hooks.js';
-import { saveTemplate, saveTemplateFromUrl, saveTemplateFromPath, listTemplateDir, removeTemplate, readTemplateSync } from '../template-inject.js';
+// 405 响应文案与内置全文检索入口同样是拆分遗漏项：前者在非 GET/POST 分支里被直接引用
+// （漏了会在方法不对时抛 ReferenceError），后者用 typeof 探测（漏了不会抛，但会永远判成不可用）。
+import { MSG_METHOD_ONLY_GET_POST } from '../shared/constants.js';
+import { searchSessions } from './search.js';
+// 模板读写实现 + 三个模板常量：常量只在表达式里被引用（不是函数调用），
+// 按「找未定义函数调用」的扫描抓不到，拆分时漏过一轮。
+import {
+  saveTemplate, saveTemplateFromUrl, saveTemplateFromPath, listTemplateDir, removeTemplate, readTemplateSync,
+  TEMPLATE_SLOTS, TEMPLATE_DEFAULTS, TEMPLATE_MAX_BYTES,
+} from '../template-inject.js';
 
 /**
  * 注册模板与设置类路由。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-conductor",
-  "version": "1.3.16",
+  "version": "1.3.18",
   "description": "DSH session management enhancement: archive/restore sessions, batch & conditional delete, AI auto-rename, interrupted-session auto-resume, release idle sessions, workspace grouping, undo last message, repair damaged session logs, value analysis, full-text search, per-member model switching (list_models / set_member_model), and plan/closing template injection (system-prompt + context).",
   "type": "module",
   "main": "lib/index.js",