dsh-session-conductor 1.3.11 → 1.3.16

package/lib/apply.js

@@ -1,66 +1,34 @@
 /** 插件入口 apply：注册路由、工具、设置页与各类钩子（本轮拆分后仍含各 handler 实现，下一步继续抽出）。 */
 
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { findSessionLog } from "./session-log.js";
 // 渲染/校验函数：供 /api/task-completion/render|check 端点使用（LLM 侧工具注册已移除，
 //   VALID_STATUSES 不再需要导入——它只在 core.js 的 renderCompletionBlock 内部使用）。
-import { renderCompletionBlock, checkCompletionText } from "./core.js";
 import { log } from "./shared/log.js";
-import {
-  MSG_METHOD_ONLY_GET_POST, MSG_NEED_SESSION_ID,
-  MAX_ATTACHED_LIMIT, MAX_CONTINUES_PER_SESSION_LIMIT, MAX_STALE_DAYS,
-} from "./shared/constants.js";
-import { lazyRepair, lazySeqGap, lazyEio, lazyValue, lazyFs } from "./core/lazy.js";
+import { MAX_ATTACHED_LIMIT, MAX_CONTINUES_PER_SESSION_LIMIT } from './shared/constants.js';
 import { pluginDomain, isDomainLive, resetDomainForTest } from "./core/domain.js";
-import {
-  continueTimers, continueLocks, continueJobs, deleteLocks,
-  withDeleteLock, withSessionLock, withConcurrencyGate, cancelSessionTimers,
-  getScanTimer, setScanTimer, resetRuntimeStateForTest,
-} from "./core/state.js";
-import {
-  cfg, DEFAULTS, setConfig, resolveDshHome, resolveBrowseRoot,
-  readSwitch, patchSwitch, loadPluginConfig, savePluginConfig, resetAutoContinueOnStart,
-  autoRenameEnabled, effectiveAutoContinue, resetSwitchGroupsForTest, deleteSwitch, getSwitchGroupsForTest,
-} from "./core/config.js";
-import { continueSession, sendMessageToSession } from "./features/continue/session.js";
-import {
-  maybeScheduleContinue, runAutoContinueSession, runAutoScan, scheduleScan, AUTO_CONTINUE_SCAN_DELAY_MS,
-} from "./features/continue/scan.js";
+import { continueTimers, getScanTimer } from './core/state.js';
+import { cfg, DEFAULTS, setConfig, resolveDshHome, patchSwitch, resetAutoContinueOnStart } from './core/config.js';
+import { maybeScheduleContinue, runAutoScan, scheduleScan, AUTO_CONTINUE_SCAN_DELAY_MS } from './features/continue/scan.js';
 import { num } from "./shared/util.js";
-import { registerContextUsageTool, createContextUsageInjector, readContextUsage } from "./features/context-usage/index.js";
+import { createContextUsageInjector, readContextUsage } from './features/context-usage/index.js';
 import { buildMemoryRecall } from "./features/memory-recall/index.js";
-import { registerSessionMessagingTools, readListIndex } from "./features/session-messaging/index.js";
-import { registerMemoryRecallTool } from "./features/memory-recall/index.js";
 import { registerGroupRoutes } from "./group.js";
-import { saveTemplate, saveTemplateFromUrl, saveTemplateFromPath, listTemplateDir, removeTemplate, readTemplateSync, readCompletionConventionSync, collectTemplateSlotText, planGateAllows, planEnforceDenyMessage, TEMPLATE_DEFAULTS, TEMPLATE_SLOTS, TEMPLATE_MAX_BYTES, PLAN_ENFORCE_EDIT_TOOLS, PLAN_ENFORCE_BASH_WRITE_RE } from "./template-inject.js";
+import { readCompletionConventionSync, collectTemplateSlotText, planGateAllows, planEnforceDenyMessage, TEMPLATE_DEFAULTS, TEMPLATE_SLOTS, PLAN_ENFORCE_EDIT_TOOLS, PLAN_ENFORCE_BASH_WRITE_RE } from './template-inject.js';
 import { name } from "./shared/constants.js";
-import { sessionEventsOf } from "./sessions/events.js";
-import { detachSessionAgent, detachAllIdleSessions } from "./sessions/detach.js";
-import {
-  invalidateSessionListCache, scheduleSaveListDiskCache, saveListDiskCacheNow, resetListCacheForTest,
-} from "./sessions/list-cache.js";
-import { buildSessionListCached } from "./sessions/list.js";
-import {
-  scheduleAnalysis, runAnalysis, resolveModelOverride, analyzeSession, resolveRoute,
-  driftAnalysisLlm, extractTitleOnly, parseDriftJson, pendingTimers, resetAnalysisForTest,
-} from "./features/rename/analysis.js";
-import { analyzeValueWithLlm } from "./features/rename/value.js";
-import {
-  collectSessionTitleMessages, resolveSessionTitle, stateSuffixOf, stripTitleStateSuffix, refreshTitleState,
-} from "./features/rename/title.js";
-import { SEARCH_MIN_QUERY, searchSessions } from './features/search.js';
+import { invalidateSessionListCache } from './sessions/list-cache.js';
+import { scheduleAnalysis, analyzeSession } from './features/rename/analysis.js';
+import { refreshTitleState } from './features/rename/title.js';
 // 价值判定索引：同一份会话内容在 TTL（默认 24 小时）内只算一次，避免每次筛选都重读日志
-import { getValueVerdict, putValueVerdict, saveValueIndexNow } from './features/value-index.js';
 // 成员模型：本文件用到 findTargetAgent / switchAgentModel / getMemberModelOverride /
 //   applyModelOverride / validateModelPair（拆出 apply.js 时漏了这一行 import，
 //   运行到相关代码路径会 ReferenceError: getMemberModelOverride is not defined）
-import { createTeammateWithModel, renderCreateTeammateResult } from "./features/member-model/create-teammate.js";
-import { findTargetAgent, switchAgentModel, getMemberModelOverride, applyModelOverride, validateModelPair,
-  registerSwitchWatch, noteRequestModel, takeSwitchOutcomes, readLastRequestModel,
-  registerModelSwitchCommand } from './features/member-model/index.js';
+import { getMemberModelOverride, applyModelOverride, noteRequestModel, takeSwitchOutcomes } from './features/member-model/index.js';
 // 会话操作的路由注册已抽到独立模块（handler 实现见该模块；此处只留注册入口）
 import { registerSessionOpsRoutes } from './features/session-ops-routes.js';
+import { registerMemberModelTools } from './features/member-model/tools.js';
+import { registerSessionActionRoutes } from './features/session-action-routes.js';
+import { registerBaseRoutes } from './features/base-routes.js';
+import { registerSettingsRoutes } from './features/settings-routes.js';
+import { registerValueReportRoutes } from './features/value-report-routes.js';
 import { registerTrashRoutes } from './features/session-ops-routes.js';
 import { purgeExpiredTrash } from './features/session-ops.js';
 import { installProcessGuards } from './guards.js';
@@ -222,451 +190,11 @@ export async function apply(ctx, config = {}) {
   ctx.inject(["webServer"], (wctx) => {
     const webServer = wctx.get("webServer");
 
-    // i18n 语言包：**只读一次并缓存**。原先每个请求都同步读两个 JSON（约 33 KB）并解析，
-    // 既阻塞事件循环（审计 io-risk 高风险），又纯属浪费 —— 语言包在一个进程生命周期内不会变。
-    let i18nCache = null;
-    const loadI18n = () => {
-      if (i18nCache !== null) return i18nCache;
-      i18nCache = {
-        zh: JSON.parse(readFileSync(new URL("./i18n/zh.json", import.meta.url), "utf8")),
-        en: JSON.parse(readFileSync(new URL("./i18n/en.json", import.meta.url), "utf8")),
-      };
-      return i18nCache;
-    };
-
-    // ---------- GET /api/session-conductor/i18n ----------
-    // 语言包外置 lib/i18n/{zh,en}.json（单份权威，改文案无需重打包 client bundle）：
-    // 浏览器端 ModuleLoader 的 require 不支持相对路径 JSON（require("./i18n/*.json") 抛 missed-the-module-table），
-    // 故由宿主侧读外置 JSON 经 HTTP 暴露、客户端 fetch 拉取合并（语言包外置做法）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/i18n",
-      handler: async (req, res) => {
-        try {
-          if ((req.method ?? "GET") !== "GET") {
-            return send(res, 405, { ok: false, error: { code: "METHOD", message: "Method Not Allowed" } });
-          }
-          const { zh, en } = loadI18n();
-          return send(res, 200, { ok: true, zh, en });
-        } catch (error) {
-          return send(res, 500, { ok: false, error: { code: "INTERNAL", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+    // ---------- 基础路由（i18n 语言包 / 会话列表）：整块拆到 features/base-routes.js ----------
+    registerBaseRoutes({ webServer, ctx });
 
-    // ---------- 预览页已移出本插件 ----------
-    // 原先这里用 /api/session-conductor/preview/<settings|panel> 同源服务 assets/preview-*.html
-    // （那两份 html 由已移除的 tools/preview-snapshot.sh 生成）。现在预览能力统一由独立插件
-    // dsh-useful-tools 的 `preview` 工具提供：gen 生成 + serve 带 backend 反代真实后端，
-    // 效果等价且本插件不必再托管静态页，故路由与产物一并移除。
-
-    // ---------- GET /api/session-conductor/list ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/list",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          // 索引直读（`?fromIndex=true`）：与 `list_sessions` 工具的 `fromIndex` **同义** ——
-          //   直接读落盘索引、**不做全量构建**，秒回精简列表（不含 live 状态与归档态）。
-          //   原先路由只认 job / stream 两个声明，传 fromIndex 会被**静默忽略** ⇒ 悄悄退化成
-          //   226 秒级的全量构建（本机实测一次 41 秒才回），调用方以为拿到了快照、实际被钉在慢路径上。
-          if (String(req.url ?? "").includes("fromIndex=true")) {
-            const items = await readListIndex(ctx);
-            if (!items) {
-              send(res, 200, { ok: true, fromIndex: true, sessions: [], hint: "落盘索引为空或尚未建立；去掉 fromIndex 走一次刷新（会重建索引，冷缓存可能很慢）" });
-              return;
-            }
-            send(res, 200, { ok: true, fromIndex: true, sessions: items, hint: "来自落盘索引，不含 live 状态与归档态；要实时状态请去掉 fromIndex 走刷新" });
-            return;
-          }
-          // job 模式（`?job=1` 或 `Accept: application/x-job`）：冷缓存下全量构建很慢
-          //   （本机实测 201 份日志 / 1.5 GB 时 226 秒），把构建交给宿主后台 job 并**立即**返回 jobId，
-          //   调用方改用 job_output / job_list 取结果，前台不再被钉住。
-          //   默认（无 job 声明）仍走下面的普通 JSON / NDJSON 流式分支 —— 一字不动，避免改坏面板。
-          const wantJob = /application\/x-job/i.test(req.headers?.accept ?? "")
-            || String(req.url ?? "").includes("job=1");
-          if (wantJob) {
-            const jobs = ctx?.get?.("jobs");
-            if (!jobs || typeof jobs.start !== "function") {
-              send(res, 501, { ok: false, error: { code: "unsupported", message: "宿主未挂载 jobs 服务，无法注册后台 job；请改用默认（流式/JSON）路径" } });
-              return;
-            }
-            // 构建只做一次；完成后顺手失效 TTL，保证随后任何一条路径读到的都是本次结果
-            const done = buildSessionListCached(ctx).then(
-              (sessions) => { invalidateSessionListCache(); return { status: "completed", output: JSON.stringify({ ok: true, sessions }) }; },
-              (error) => ({ status: "failed", detail: String(error?.message ?? error) }),
-            );
-            const spec = { kind: "session-conductor-list", label: "list（会话列表刷新）", run: () => ({ cancel: () => {}, done }) };
-            // HTTP 入口没有执行主体 ⇒ 用「无主」注册（宿主存在全局 job 控制器即可）；
-            // 无主不可用时如实回 501，由调用方决定是否改用默认路径（不静默吞掉）。
-            try {
-              send(res, 200, { ok: true, async: true, jobId: jobs.start(spec), hint: "用宿主 job_output / job_list 取结果" });
-            } catch (error) {
-              // 后台 job 不可用（HTTP 入口**没有执行主体**，宿主 job 控制器会拒绝无主注册 ——
-              //   实测回的是「no job controller serves this agent」）：不再直接 501 把调用方堵死；
-              //   退一步给**索引快照**（秒回、明确标注来源与「不含 live 状态」），索引也没有才如实 501。
-              const items = await readListIndex(ctx).catch(() => null);
-              if (items) {
-                send(res, 200, {
-                  ok: true,
-                  async: false,
-                  fromIndex: true,
-                  sessions: items,
-                  jobUnavailable: String(error?.message ?? error),
-                  hint: "后台 job 不可用，已回退为落盘索引快照（不含 live 状态）；要实时状态请走默认或流式分支",
-                });
-                return;
-              }
-              send(res, 501, { ok: false, error: { code: "unsupported", message: `注册后台 job 失败：${String(error?.message ?? error)}（且落盘索引不可用，无回退）` } });
-            }
-            return;
-          }
-          // list 流式（仅当请求声明 Accept: application/x-ndjson）——live 会话先快速
-          // 写出，冷会话串行逐个解析边写边出，前端 fetch stream 逐行追加（每获取一个立即显示，
-          // 不等全部）；排序由前端按 updatedAt 倒序插入保持（流式下后端不再整体排序）。
-          // 默认（无 Accept 头/旧前端/预览页垫片）仍返回普通 JSON——兼容不匹配的调用方。
-          const wantStream =
-            /application\/x-ndjson/i.test(req.headers?.accept ?? "") || String(req.url ?? "").includes("stream=1");
-          if (!wantStream) {
-            const sessions = await buildSessionListCached(ctx);
-            send(res, 200, { ok: true, sessions });
-            return;
-          }
-          res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
-          res.setHeader("Cache-Control", "no-store");
-          if (res.socket?.setNoDelay) res.socket.setNoDelay(true);
-          res.write(JSON.stringify({ ok: true, stream: true }) + "\n"); // 头行（前端跳过非会话行）
-          // 立即把头行推出去：冷缓存时后面要逐份解压上百份日志（实测 41~226 秒），
-          // 若头行压在缓冲里，浏览器这侧会一直「没有响应」，看起来就像接口挂了。
-          // flushHeaders/flush 老版本不一定有，取不到就跳过（写操作本身已尽量及时）。
-          try {
-            if (typeof res.flushHeaders === "function") res.flushHeaders();
-            if (typeof res.flush === "function") res.flush();
-          } catch { /* 不支持 flush 的宿主不影响主流程 */ }
-          const onItem = (item) => { try { res.write(JSON.stringify(item) + "\n"); } catch { /* 连接已断 */ } };
-          await buildSessionListCached(ctx, { onItem, serial: true });
-          try { res.end(); } catch { /* 连接已断 */ }
-        } catch (error) {
-          try {
-            res.end(JSON.stringify({ ok: false, error: { code: "internal", message: String(error?.message ?? error) } }) + "\n");
-          } catch { /* 连接已断 */ }
-        }
-      },
-    });
-
-    // ---------- GET/POST /api/session-conductor/templates ----------
-    //  会话模板注入（）：plan（方案模板）/ closing（收尾模板）两个固定槽位，
-    // 支持上传本地 md 文件或在线 md 网址（host 下载转存），内容落盘
-    // <DSH_HOME>/template-inject-md/<slot>.md → systemPrompt section「session-templates」注入。
-    // GET → {ok, slots: {plan:{enabled,name,url,bytes,updatedAt}, closing:{...}}, maxBytes}
-    // POST {slot, enabled?} → 只改开关；
-    // POST {slot, name, content} → 上传本地 md；
-    // POST {slot, url} → 在线 md 网址下载转存；
-    // POST {slot, action:"remove"} → 清空槽位。
-    {
-      const tplHome = resolveDshHome(ctx, cfg);
-      // 浏览根与选用校验根唯一来源 = resolveBrowseRoot（工作区目录）。
-      // 同一 browseRoot 变量贯穿本块内两个路由：/templates 的 pickPath 校验、/templates/dir 浏览。
-      // 落盘仍 tplHome（DSH_HOME/template-inject-md/），浏览/校验/落盘三者职责清晰。
-      const browseRoot = resolveBrowseRoot(ctx, cfg);
-      if (tplHome) {
-        webServer.register({
-          kind: "exact",
-          path: "/api/session-conductor/templates",
-          handler: async (req, res) => {
-            try {
-              // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-              if (req.method !== "GET") invalidateSessionListCache();
-              const domain = await pluginDomain(ctx);
-              const st = domain.global.get();
-              const meta = st.sessionTemplates ?? structuredClone(TEMPLATE_DEFAULTS);
-              // 缓存写入口必须是归属模块的 setter（import 绑定对导入方只读，直接赋值会 TypeError）
-              setTemplateStateCache(meta);
-              // 构造带 content 的 slots（GET/POST 统一：导入/编辑后前端编辑框直接读到内容）
-              const buildSlotsWithContent = (meta2) => {
-                const out = {};
-                for (const slot of TEMPLATE_SLOTS) {
-                  const slotMeta = meta2[slot] ?? { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 };
-                  let content = "";
-                  if (slotMeta.bytes > 0 || slotMeta.name) {
-                    // readTemplateSync 返回 sanitized 字符串（无文件/不可读返回空串），不是 {ok,text} 对象
-                    try { content = String(readTemplateSync(tplHome, slot) ?? "").slice(0, TEMPLATE_MAX_BYTES); } catch { content = ""; }
-                  }
-                  out[slot] = { ...slotMeta, content };
-                }
-                return out;
-              };
-              if (req.method === "GET") {
-                return send(res, 200, { ok: true, slots: buildSlotsWithContent(meta), maxBytes: TEMPLATE_MAX_BYTES });
-              }
-              if (req.method === "POST") {
-                const body = await readJson(req);
-                // 目录内选用 md 文件（action="pickPath"）——校验用工作区浏览根，落盘用 DSH_HOME
-                if (body?.action === "pickPath") {
-                  const slot = String(body?.slot ?? "");
-                  if (!TEMPLATE_SLOTS.includes(slot)) {
-                    return send(res, 400, { ok: false, error: { code: "bad-slot", message: `模板槽位须为 ${TEMPLATE_SLOTS.join("|")}` } });
-                  }
-                  const saved = await saveTemplateFromPath(browseRoot, slot, body.path, tplHome);
-                  if (!saved.ok) return send(res, 400, saved);
-                  const cur = meta[slot] ?? { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 };
-                  const next = {
-                    ...meta,
-                    [slot]: {
-                      enabled: cur.enabled,
-                      enforce: cur.enforce === true,
-                      name: saved.name || cur.name,
-                      url: "",
-                      bytes: saved.bytes,
-                      updatedAt: Date.now(),
-                    },
-                  };
-                  setTemplateStateCache(next);
-                  await domain.global.set({ ...st, sessionTemplates: next });
-                  return send(res, 200, { ok: true, slots: buildSlotsWithContent(next), message: `模板「${slot}」已从目录选用（${saved.name}），记得点「开启注入」` });
-                }
-                const slot = String(body?.slot ?? "");
-                if (!TEMPLATE_SLOTS.includes(slot)) {
-                  return send(res, 400, { ok: false, error: { code: "bad-slot", message: `模板槽位须为 ${TEMPLATE_SLOTS.join("|")}` } });
-                }
-                const cur = meta[slot] ?? { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 };
-                if (body?.action === "remove") {
-                  const r = await removeTemplate(tplHome, slot);
-                  if (!r.ok) return send(res, 400, r);
-                  const next = { ...meta, [slot]: { ...cur, enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 } };
-                  setTemplateStateCache(next);
-                  await domain.global.set({ ...st, sessionTemplates: next });
-                  return send(res, 200, { ok: true, slots: buildSlotsWithContent(next), message: `模板「${slot}」已清空` });
-                }
-                let saved = null;
-                if (typeof body?.url === "string" && body.url.trim()) {
-                  saved = await saveTemplateFromUrl(tplHome, slot, body.url);
-                } else if (typeof body?.content === "string") {
-                  // 编辑保存：可只带 content（name 保留现值）；也可带 name（本地导入）
-                  saved = await saveTemplate(tplHome, slot, { name: (typeof body?.name === "string" && body.name.trim()) ? body.name : cur.name, content: body.content });
-                }
-                if (saved && saved.ok) {
-                  const next = {
-                    ...meta,
-                    [slot]: {
-                      enabled: cur.enabled, // 上传内容不自动开，用户再点开关
-                      enforce: cur.enforce === true,
-                      name: saved.name || cur.name,
-                      url: typeof body?.url === "string" && body.url.trim() ? body.url.trim() : "",
-                      bytes: saved.bytes,
-                      updatedAt: Date.now(),
-                    },
-                  };
-                  setTemplateStateCache(next);
-                  await domain.global.set({ ...st, sessionTemplates: next });
-                  return send(res, 200, { ok: true, slots: buildSlotsWithContent(next), message: `模板「${slot}」已保存，记得点「开启注入」` });
-                }
-                if (saved && !saved.ok) return send(res, 400, saved);
-                if (typeof body?.enabled === "boolean") {
-                  const next = { ...meta, [slot]: { ...cur, enabled: body.enabled } };
-                  setTemplateStateCache(next);
-                  await domain.global.set({ ...st, sessionTemplates: next });
-                  return send(res, 200, { ok: true, slots: buildSlotsWithContent(next), message: body.enabled ? `模板「${slot}」已开启注入` : `模板「${slot}」已关闭` });
-                }
-                // 方案模板强制门禁开关（{slot:"plan", enforce:bool}）——即时生效，无需重启
-                if (slot === "plan" && typeof body?.enforce === "boolean") {
-                  const next = { ...meta, plan: { ...cur, enforce: body.enforce } };
-                  setTemplateStateCache(next);
-                  await domain.global.set({ ...st, sessionTemplates: next });
-                  return send(res, 200, { ok: true, slots: buildSlotsWithContent(next), message: body.enforce
-                    ? `方案模板强制门禁已开启（未出提案并获确认前，代码修改类工具调用被拒绝）`
-                    : `方案模板强制门禁已关闭` });
-                }
-                return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 {slot, name, content}（本地 md）、{slot, url}（在线 md）、{slot, enabled} 或 {slot:'plan', enforce}" } });
-              }
-              return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
-            } catch (error) {
-              send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
-            }
-          },
-        });
-
-        // ---------- GET /api/session-conductor/templates/dir ----------
-        //  模板目录浏览（「在工作区目录内找」）：列 DSH 工作区目录树内一层目录。
-        // 浏览根与选用校验根同源（上方 browseRoot）；落盘仍在 DSH_HOME/template-inject-md/。
-        // GET ?path=... → {ok, path, parent, entries:[{name,path,isDir,isMd}]}（缺省从工作区根开始）
-        if (browseRoot) {
-          webServer.register({
-            kind: "exact",
-            path: "/api/session-conductor/templates/dir",
-            handler: async (req, res) => {
-              try {
-                // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-                if (req.method !== "GET") invalidateSessionListCache();
-                if (req.method !== "GET") return send(res, 405, { ok: false, error: { code: "method", message: "仅 GET" } });
-                const url = new URL(req.url, "http://localhost");
-                const path = url.searchParams.get("path") ?? "";
-                const r = await listTemplateDir(browseRoot, path);
-                if (!r.ok) return send(res, 400, r);
-                return send(res, 200, r);
-              } catch (error) {
-                send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
-              }
-            },
-          });
-        }
-      }
-    }
-
-    // ---------- GET /api/session-conductor/fts-status ----------
-    // 全文搜索诊断（ 并入，原独立插件 dsh-session-search 已合并）：
-    // 报告官方 FTS5（sessionQuery）是否挂载 + 内置 zstd 扫描兜底是否可用。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/fts-status",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const sessionQuery = ctx.get("sessionQuery");
-          const sessionEvents = ctx.get("sessionEvents");
-          send(res, 200, {
-            ok: true,
-            plugin: "dsh-session-conductor",
-            sessionQueryMounted: sessionQuery !== void 0,
-            ftsMode: sessionQuery === void 0 ? "unavailable" : "first-search",
-            builtinScanAvailable: typeof searchSessions === "function",
-            note:
-              sessionQuery === void 0
-                ? "官方 FTS5 服务未挂载（检查 session-query-sqlite openAt 配置），使用内置 zstd 扫描兜底"
-                : "官方 FTS5 内容搜索已解锁（openAt: first-search），内置 zstd 扫描为兜底",
-          });
-        } catch (error) {
-          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- GET/POST /api/session-conductor/compaction-model ----------
-    // 压缩模型选择：会话模型旁单独选压缩用模型。
-    // GET → {ok, compactionModel: {provider,model}|null, follow: true(跟随会话模型)}
-    // POST {provider, model} → 设置；POST {follow:true} → 重置为跟随会话模型
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/compaction-model",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const domain = await pluginDomain(ctx);
-          const state = domain.global.get();
-          const cur = state.compactionModel ?? null;
-          if (req.method === "GET") {
-            return send(res, 200, { ok: true, compactionModel: cur, follow: cur === null });
-          }
-          if (req.method === "POST") {
-            const body = await readJson(req);
-            if (body?.follow === true) {
-              await domain.global.set({ ...state, compactionModel: null });
-              return send(res, 200, { ok: true, compactionModel: null, follow: true, message: "压缩模型已重置为跟随会话模型" });
-            }
-            const provider = String(body?.provider ?? "").trim();
-            const model = String(body?.model ?? "").trim();
-            if (!provider || !model) return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 provider 和 model" } });
-            await domain.global.set({ ...state, compactionModel: { provider, model } });
-            return send(res, 200, { ok: true, compactionModel: { provider, model }, follow: false, message: `压缩模型已设为 ${provider}/${model}（重启后生效）` });
-          }
-          return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
-        } catch (error) {
-          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- GET/POST /api/session-conductor/auto-rename-model ----------
-    // 自动重命名模型选择：设置页「DSH 同款解析选择器」选定。
-    // GET → {ok, selection: {provider,model}|null, follow: true(跟随会话模型), catalog}
-    //   catalog = 官方 modelCatalog（provider 分组 + 模型 + 默认），供前端渲染选择器。
-    // POST {provider, model} → 设置；POST {follow:true} → 重置为跟随会话模型。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/auto-rename-model",
-      handler: async (req, res) => {
-        try {
-          const domain = await pluginDomain(ctx);
-          const state = domain.global.get();
-          const cur = state.autoRenameModel ?? null;
-          if (req.method === "GET") {
-            // 官方解析选择器的数据源：provider 分组 + 模型列表 + 部署默认
-            let catalog = null;
-            try {
-              const sc = ctx.get("sessionController");
-              catalog = sc?.modelCatalog ? await sc.modelCatalog() : null;
-            } catch (error) {
-              log(ctx, `auto-rename-model: 官方 modelCatalog 获取失败（前端仍可手动输入）: ${String(error?.message ?? error)}`);
-              catalog = null;
-            }
-            return send(res, 200, { ok: true, selection: cur, follow: cur === null, catalog });
-          }
-          if (req.method === "POST") {
-            const body = await readJson(req);
-            if (body?.follow === true) {
-              await domain.global.set({ ...state, autoRenameModel: null });
-              return send(res, 200, { ok: true, selection: null, follow: true, message: "自动重命名模型已重置为跟随会话模型" });
-            }
-            const provider = String(body?.provider ?? "").trim();
-            const model = String(body?.model ?? "").trim();
-            if (!provider || !model) return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 provider 和 model" } });
-            await domain.global.set({ ...state, autoRenameModel: { provider, model } });
-            return send(res, 200, { ok: true, selection: { provider, model }, follow: false, message: `自动重命名模型已设为 ${provider}/${model}` });
-          }
-          return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
-        } catch (error) {
-          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- GET/POST /api/session-conductor/auto-continue-gate ----------
-    // 自动续跑全局闸门（与 guardian 联动）：
-    //   GET → {ok, gate: "open"|"closed", note}
-    //   POST {gate:"open"|"closed"} → 设置；closed 时一切自动续跑跳过（周期扫描/scan 自动续跑部分）
-    //   guardian 在 DSH 恢复健康时置 closed；用户手动开启或首次手动对话（turn/start user）后自动置 open
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/auto-continue-gate",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const domain = await pluginDomain(ctx);
-          const state = domain.global.get();
-          const cur = state.autoContinueGate ?? "open";
-          if (req.method === "GET") {
-            return send(res, 200, {
-              ok: true,
-              gate: cur,
-              note: cur === "closed"
-                ? "自动续跑全局闸门关闭：一切自动续跑跳过（DSH 刚启动/崩溃恢复后），用户手动开启或第一次手动对话后自动放行"
-                : "自动续跑全局闸门开放：按原有判定（单会话开关 → 全局默认）",
-            });
-          }
-          if (req.method === "POST") {
-            const body = await readJson(req);
-            const gate = String(body?.gate ?? "");
-            if (gate !== "open" && gate !== "closed") {
-              return send(res, 400, { ok: false, error: { code: "bad-request", message: 'gate 必须为 "open" 或 "closed"' } });
-            }
-            await domain.global.set({ ...state, autoContinueGate: gate });
-            return send(res, 200, {
-              ok: true,
-              gate,
-              message: gate === "closed" ? "自动续跑闸门已关闭（所有自动续跑暂停）" : "自动续跑闸门已开放",
-            });
-          }
-          return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
-        } catch (error) {
-          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+    // ---------- 模板与设置类路由：整块拆到 features/settings-routes.js ----------
+    registerSettingsRoutes({ webServer, ctx });
 
     // ---------- 会话操作路由（归档/取消归档/删除/撤回）----------
     // 从本文件抽出为 lib/features/session-ops-routes.js：apply 只保留「注册入口」，
@@ -687,586 +215,12 @@ export async function apply(ctx, config = {}) {
       ctx.effect?.(() => () => { try { clearInterval(purgeTimer); } catch { /* 已清理 */ } }, "session-conductor: trash purge timer");
     } catch { /* 定时器建不起来也不影响手动清理 */ }
 
-    // ---------- POST /api/session-conductor/search ----------
-    // 全文搜索：跨会话搜消息内容，返回命中会话 + 上下文片段
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/search",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const query = typeof body?.query === "string" ? body.query : "";
-          const scope = ["all", "active", "archived"].includes(body?.scope) ? body.scope : "all";
-          if (query.trim().length < SEARCH_MIN_QUERY) {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: `关键词至少 ${SEARCH_MIN_QUERY} 个字符` } });
-          }
-          const searchResult = await searchSessions(ctx, query, { scope });
-          send(res, 200, { ok: true, ...searchResult });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "search-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/auto-rename ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/auto-rename",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const enabled = body.enabled === true;
-          const setting = await patchSwitch(ctx, "autoRename", body.sessionId, { enabled }, { enabled: false });
-          let analyzed = null;
-          if (enabled) analyzed = await runAnalysis(ctx, body.sessionId); // 开启后立即分析一次
-          send(res, 200, { ok: true, enabled: setting.enabled, analyzed });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "auto-rename-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/analyze ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/analyze",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const analysisResult = await runAnalysis(ctx, body.sessionId, {
-            manual: true, // 手动 API：跳过限频/新消息数门槛（显式意图即执行）
-            model: typeof body?.model === "string" && body.model !== "" ? body.model : undefined,
-          });
-          if (!analysisResult.ok) return send(res, 409, analysisResult);
-          send(res, 200, analysisResult);
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "analyze-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/continue ----------
-    // 手动续跑：异步执行（回合可能耗时数分钟），立即返回 accepted，列表用 continueRunning 反映进行中。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/continue",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const sessionId = body.sessionId;
-          const running = continueJobs.has(sessionId) || (() => {
-            try {
-              const agent = ctx.get("agents")?.get(sessionId);
-              return agent?.status === "running";
-            } catch {
-              return false;
-            }
-          })();
-          if (running) {
-            return send(res, 409, { ok: false, error: { code: "busy", message: "该会话已有续跑/回合在进行中" } });
-          }
-          continueSession(ctx, sessionId, { auto: false }).then((result) => {
-            if (!result?.ok) log(ctx, `手动续跑 ${sessionId} 未成功: ${result?.error?.message ?? "?"}`);
-          }).catch((error) => {
-            // 手动续跑异步链兜底——continueSession 永不 reject（prepare 段已包 try），
-            // 此处再兜一层防未来回归把 rejection 逃逸成 unhandledRejection 杀进程。
-            log(ctx, `手动续跑 ${sessionId} 异常: ${String(error?.message ?? error)}`);
-          });
-          send(res, 200, { ok: true, accepted: true, sessionId });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "continue-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/message ----------
-    // 跨会话消息投递：{targetSessionId, message, fromSessionId?}
-    // 向目标会话投递用户消息并唤起（live followup / cold resume+followup），不受"中断"限制。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/message",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const sessionId = body?.targetSessionId || body?.sessionId;
-          const text = body?.message;
-          if (typeof sessionId !== "string" || sessionId === "" || typeof text !== "string" || text === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: "缺少 targetSessionId 或 message" } });
-          }
-          // 异步执行（回合可能耗时），立即返回 accepted
-          const r = await sendMessageToSession(ctx, sessionId, text, { fromSessionId: body?.fromSessionId || "" });
-          return send(res, r.ok ? 200 : (r.error?.code === "not-found" ? 404 : 400), r);
-        } catch (error) {
-          return send(res, 400, { ok: false, error: { code: "message-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/auto-continue ----------
-    // 开启/关闭某会话的自动续跑（显式 enabled 覆盖全局默认）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/auto-continue",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const enabled = body.enabled === true;
-          // 开关落盘 config.json；先取旧 entry 保留记账字段，enabled 以本次为准。
-          const entry = readSwitch("autoContinue", body.sessionId) ?? {};
-          await patchSwitch(ctx, "autoContinue", body.sessionId, { ...entry, enabled });
-          // 开启开关即触发一次续跑（force 跳过失败重试延迟）——原先要等最长
-          // scanIntervalMs（默认 5 分钟）周期扫描才续，用户体感「打开后处理中很久」。
-          // 关闭开关不触发；开启是幂等触发点，重复点不会叠加（内部有会话串行锁 + 门槛）。
-          if (enabled) {
-            runAutoContinueSession(ctx, body.sessionId, { force: true }).catch((error) => {
-              log(ctx, `开启自动续跑后立即续跑失败 ${body.sessionId}: ${String(error?.message ?? error)}`);
-            });
-          }
-          send(res, 200, { ok: true, enabled, sessionId: body.sessionId, triggered: enabled });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "auto-continue-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/scan ----------
-    // 立即扫描一次全部会话并自动续跑（测试/手动触发用）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/scan",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          runAutoScan(ctx).then((count) => {
-            log(ctx, `手动扫描完成（排队 ${count ?? 0}）`);
-          }).catch((error) => {
-            log(ctx, `手动扫描失败: ${String(error?.message ?? error)}`);
-          });
-          send(res, 200, { ok: true, accepted: true });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "scan-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/detach ----------
-    // 手动释放（置为不活跃）：把 live 空闲会话拆回冷状态（日志保留，可重新挂载）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/detach",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const detachResult = await detachSessionAgent(ctx, body.sessionId);
-          if (!detachResult.ok) return send(res, 409, detachResult);
-          send(res, 200, detachResult);
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "detach-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/detach-all ----------
-    // 释放全部 live 空闲会话（跳过运行中 / subagent / 续跑中）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/detach-all",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const detachAllResult = await detachAllIdleSessions(ctx);
-          send(res, 200, detachAllResult);
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "detach-all-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- 会话日志修复（扫描/修复损坏会话） ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/repair-sessions",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const { supportsRepair } = await lazyRepair();
-          if (!supportsRepair(ctx)) {
-            return send(res, 501, { ok: false, error: { code: "unsupported", message: "当前持久化后端不支持修复（需要 jsonl 后端）" } });
-          }
-          const dryRun = body?.dryRun === true;
-          const { scanCorruptSessions, repairCorruptSessions } = await lazyRepair();
-          const report = dryRun ? await scanCorruptSessions(ctx) : await repairCorruptSessions(ctx, { dryRun: false });
-          if (report.error) return send(res, 500, { ok: false, error: { code: "repair-failed", message: report.error } });
-          send(res, 200, { ok: true, dryRun, report });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "repair-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/repair-frames ----------
-    // 会话日志 zstd 帧修复（救援恢复，）：会话列表消失/corrupt Zstandard 时，
-    // 扫描并修复帧损坏（逐帧解码→多帧正确写回，自动备份）。与 repair-sessions 互补：
-    // repair-sessions 修 tool-result content 结构；repair-frames 修 zstd 帧格式。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/repair-frames",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const dryRun = body?.dryRun === true;
-          const { scanCorruptFrames, repairCorruptFrames } = await lazyRepair();
-          const report = dryRun ? await scanCorruptFrames() : await repairCorruptFrames({ dryRun: false });
-          send(res, 200, { ok: true, dryRun, report });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "repair-frames-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/repair-seq-gap ----------
-    // 会话日志 seq-gap + token-surface 修复（实测）：
-    //   seq gap 错位（spliced 拼接未重编号）+ replace 引用缺失 + compaction shadowedRange 未映射
-    //   三层叠加导致 history unavailable（token surface: no adjacent shadow price）。
-    //   dryRun=true 扫描全部会话列出疑似 seq-gap；sessionId 指定则修复单个（自动备份 .seq-gap-backup/）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/repair-seq-gap",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const sessionsRoot = path.join(process.env.DSH_HOME || path.join(process.env.HOME ?? "", ".dsh"), "sessions");
-          if (body?.dryRun === true) {
-            const { scanSeqGapSessions } = await lazySeqGap();
-            const list = await scanSeqGapSessions(sessionsRoot);
-            send(res, 200, { ok: true, dryRun: true, corrupt: list, total: list.length });
-            return;
-          }
-          const sessionId = body?.sessionId;
-          if (!sessionId) { send(res, 400, { ok: false, error: { code: "session-id-required", message: "need sessionId" } }); return; }
-          // 定位会话日志路径（sessionId 需含 session- 前缀，cwd 目录未知 → 全仓查找）
-          const { readdirSync, existsSync } = await lazyFs();
-          let targetPath = null;
-          for (const proj of readdirSync(sessionsRoot, { withFileTypes: true })) {
-            if (!proj.isDirectory()) continue;
-            const p = findSessionLog(path.join(sessionsRoot, proj.name, sessionId));
-            if (p) { targetPath = p; break; }
-          }
-          if (!targetPath) { send(res, 404, { ok: false, error: { code: "session-not-found", message: sessionId } }); return; }
-          const { repairSeqGap } = await lazySeqGap();
-          const report = await repairSeqGap(targetPath, { dryRun: false });
-          send(res, report.ok ? 200 : 400, { ok: report.ok, sessionId, report });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "repair-seq-gap-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/repair-eio ----------
-    // 会话日志 EIO 坏块修复（实测固化，来源 sa6400-nested-vm-io-panic skill）：
-    //   底层存储（BTRFS csum 损坏 / iSCSI LUN I/O 错误）导致 session.jsonl.zstd 某些 4KB 块
-    //   读取抛 EIO（Errno 5）→ 网关 observe 会话报 "EIO: i/o error, read"。
-    //   修复 = 块级探测找出第一个 EIO 边界 → 读 [0, 边界) 完好前缀 → 原子写回
-    //   （BTRFS COW 换新块）→ DSH 加载时 readZstdPrefix/commitRepair 自动收尾 torn tail。
-    //   dryRun=true 全仓扫描；sessionId 指定则修复单个（全仓定位）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/repair-eio",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const { sessionsRootOf: eioSessionsRootOf } = await lazyEio();
-          const sessionsRoot = eioSessionsRootOf();
-          if (body?.dryRun === true) {
-            const { scanEioSessions } = await lazyEio();
-            const list = await scanEioSessions(sessionsRoot);
-            send(res, 200, { ok: true, dryRun: true, eio: list.eio, total: list.total, healthy: list.healthy, error: list.error });
-            return;
-          }
-          const sessionId = body?.sessionId;
-          if (sessionId) {
-            // 定位会话日志路径（sessionId 需含 session- 前缀，cwd 目录未知 → 全仓查找）
-            const { readdirSync, existsSync } = await lazyFs();
-            let targetPath = null;
-            for (const proj of readdirSync(sessionsRoot, { withFileTypes: true })) {
-              if (!proj.isDirectory()) continue;
-              const p = findSessionLog(path.join(sessionsRoot, proj.name, sessionId));
-              if (p) { targetPath = p; break; }
-            }
-            if (!targetPath) { send(res, 404, { ok: false, error: { code: "session-not-found", message: sessionId } }); return; }
-            const { repairEioFile } = await lazyEio();
-            const report = await repairEioFile(targetPath);
-            send(res, report.ok ? 200 : 400, { ok: report.ok, sessionId, report });
-            return;
-          }
-          const { repairEioSessions } = await lazyEio();
-          const report = await repairEioSessions({ dryRun: false });
-          send(res, 200, { ok: true, dryRun: false, report });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "repair-eio-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/repair-dual-format ----------
-    // 双格式会话修复：会话目录同时存在 session.jsonl（明文）+ session.jsonl.zstd
-    // （压缩）→ 官方 listArtifacts() 抛 encodingMismatch → 会话列表全失败（侧边栏会话消失）。
-    // 纯磁盘级扫描（不走 sessionPersistence，后者自身会被 encodingMismatch 阻断），
-    // 把多余明文移入 .dual-format-backup/ 保留 zstd 官方格式；dryRun=true 只扫不写。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/repair-dual-format",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const dryRun = body?.dryRun === true;
-          // live 会话跳过：正在写入的会话不应被移动（按 id 查 sessions 服务）
-          let skipIds = [];
-          try {
-            const sessionsSvc = ctx.get("sessions");
-            skipIds = (sessionsSvc?.list?.() ?? []).map((s) => s.id);
-          } catch {
-            // sessions 服务不可用时不做 live 跳过（保守：仍只移非 live 目录）
-          }
-          const report = dryRun
-            ? await (await lazyRepair()).scanDualFormatSessions()
-            // 修复：原为裸调 `repairDualFormatSessions(...)`，但该名字从未导入 ⇒ 抛
-            //   ReferenceError 被下面的 catch 变成 400「repair-dual-format-failed」，非 dryRun 的
-            //   双格式修复实际从未执行过。改为与上一行同源的懒加载命名空间调用。
-            : await (await lazyRepair()).repairDualFormatSessions({ dryRun: false, skipIds });
-          if (report.error) {
-            send(res, 500, { ok: false, error: { code: "repair-dual-format-failed", message: report.error } });
-            return;
-          }
-          send(res, 200, { ok: true, dryRun, skipped: report.skipped ?? 0, report });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "repair-dual-format-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- POST /api/session-conductor/value-analysis ----------
-    // 会话价值分析（ 规则判定 +  特征/LLM/关键词价值）：
-    //   规则分类 completed/unfinished/stale/active + 最后回复摘要；
-    //   高/低价值 = assessValue 特征评分（活跃/长度/完成/未完成/细节补充）；
-    //   可选 body.keywords=[...] 记录指定关键词 → 标题/最后用户消息命中任一关键词的会话无条件最高价值；
-    //   可选 body.llm=true 额外用 LLM 打分（fail-soft）。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/value-analysis",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const staleDays = typeof body?.staleDays === "number" && Number.isFinite(body.staleDays)
-            ? Math.min(MAX_STALE_DAYS, Math.max(1, Math.round(body.staleDays)))
-            : 3;
-          const useLlm = body?.llm === true;
-          const sessions = await buildSessionListCached(ctx); // 价值分析走缓存（容忍 5s 陈旧，避免与面板刷新叠加扫描）
-          // 流式（`?stream=1` 或 Accept: application/x-ndjson）：**每分析完一个会话就推一行**。
-          // 前端拿到 value==="low" 立刻勾上（分析出一个勾一个），不必等全量跑完 ——
-          // 全量要逐个读上百份日志，慢的是读取本身，而读取是天然可增量的。
-          // 判定规则与批量路径同源（value.js 的 classifySessionLevel），不在这里另写一套。
-          const wantValueStream = /application\/x-ndjson/i.test(req.headers?.accept ?? "")
-            || String(req.url ?? "").includes("stream=1");
-          if (wantValueStream) {
-            // body.ids：只分析这些会话（面板已先用归档/时间/目录在本地筛过一轮，
-            // 没必要把全量会话都读一遍事件）。不传 = 全量。
-            const wantedIds = Array.isArray(body?.ids)
-              ? new Set(body.ids.filter((id) => typeof id === "string" && id !== ""))
-              : null;
-            const streamTargets = wantedIds ? sessions.filter((s) => wantedIds.has(s.id)) : sessions;
-            res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
-            res.setHeader("Cache-Control", "no-store");
-            if (res.socket?.setNoDelay) res.socket.setNoDelay(true);
-            res.write(JSON.stringify({ ok: true, stream: true, total: streamTargets.length }) + "\n");
-            try {
-              if (typeof res.flushHeaders === "function") res.flushHeaders();
-            } catch { /* 老宿主不支持 flush，不影响主流程 */ }
-            const { classifySessionLevel } = await lazyValue();
-            let done = 0;
-            for (const s of streamTargets) {
-              done += 1;
-              // ① 索引命中（内容没变 + 未超 TTL）→ 零 I/O 直接给结论
-              const cachedVerdict = getValueVerdict(ctx, s.id, s.updatedAt);
-              if (cachedVerdict) {
-                try {
-                  res.write(JSON.stringify({
-                    id: s.id, value: cachedVerdict.value, score: cachedVerdict.score,
-                    reason: cachedVerdict.reason, cached: true, done, total: streamTargets.length,
-                  }) + "\n");
-                } catch { break; }
-                continue;
-              }
-              // ② 没索引 / 会话变过 / 超 TTL → 真读一次日志
-              let events = [];
-              try {
-                const found = await sessionEventsOf(ctx, s.id);
-                events = found?.events ?? [];
-              } catch { /* 读不到就当空事件：会走 artifact-safe 保守判 high，不误删 */ }
-              const verdict = classifySessionLevel(s, events, new Date(), staleDays);
-              putValueVerdict(ctx, s.id, s.updatedAt, verdict);
-              try {
-                res.write(JSON.stringify({ ...verdict, cached: false, done, total: streamTargets.length }) + "\n");
-              } catch { break; }
-            }
-            saveValueIndexNow(ctx); // 本次算出来的结论立刻落盘（下次筛选直接命中索引）
-            try { res.end(); } catch { /* 连接已断 */ }
-            return;
-          }
-          // 一次性读取各会话事件（复用，避免大会话重复解压导致超时/失败）
-          const eventsById = {};
-          // 逐个会话读取最后 assistant 文本 + 最后用户消息（损坏/不可读会话跳过，用空串）
-          const texts = {};
-          const userTexts = {};
-          for (const s of sessions) {
-            try {
-              const found = await sessionEventsOf(ctx, s.id);
-              if (found) {
-                eventsById[s.id] = found.events || [];
-                const { lastAssistantText, lastUserText, filterSessionsByKeywords } = await lazyValue();
-                texts[s.id] = lastAssistantText(found.events);
-                userTexts[s.id] = lastUserText(found.events);
-              }
-            } catch {
-              /* 单会话失败跳过 */
-            }
-          }
-          // 可选 LLM 高/低价值判断
-          let llmById = {};
-          if (useLlm) {
-            llmById = await analyzeValueWithLlm(ctx, sessions, texts, (m) => log(ctx, m));
-          }
-          // 特征评分（活跃/长度/完成/未完成/细节补充）+ 关键词命中→无条件最高
-          const featuresById = {};
-          for (const s of sessions) {
-            try {
-              const { buildValueFeatures } = await lazyValue();
-              featuresById[s.id] = buildValueFeatures(eventsById[s.id] || [], s, new Date());
-            } catch {
-              const { buildValueFeatures: buildValueFeatures2 } = await lazyValue();
-              featuresById[s.id] = buildValueFeatures2([], s, new Date());
-            }
-          }
-          const keywords = Array.isArray(body?.keywords) ? body.keywords : [];
-          const { analyzeValuesWithKeywords } = await lazyValue();
-          const analysisSummary = analyzeValuesWithKeywords(sessions, texts, userTexts, featuresById, keywords, llmById, new Date(), staleDays);
-          const counts = {};
-          for (const key of Object.keys(analysisSummary)) counts[key] = analysisSummary[key].length;
-          send(res, 200, {
-            ok: true,
-            staleDays,
-            llm: !!useLlm,
-            keywords: keywords.length ? keywords : void 0,
-            keywordHits: keywords.length ? filterSessionsByKeywords(sessions, texts, userTexts, keywords, new Date()) : [],
-            generatedAt: Date.now(),
-            counts,
-            completed: analysisSummary.completed,
-            unfinished: analysisSummary.unfinished,
-            stale: analysisSummary.stale,
-            active: analysisSummary.active,
-            high: analysisSummary.high,
-            low: analysisSummary.low,
-          });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "value-analysis-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    // ---------- 任务完成汇报（task-completion-report 管道） ----------
-    // 收尾约定不再由代码写死注入 systemPrompt——改由模板注入「收尾模板」槽位承担
-    // （设置 → 会话管理 → 模板注入 → closing，可自定义内容）。
-    // LLM 侧的 render/check 工具已移除，只剩下面的 HTTP 端点（面板/自检用），故 tools 如实回报空列表。
-    webServer.register({
-      kind: "exact",
-      path: "/api/task-completion/status",
-      handler: async (req, res) => {
-        send(res, 200, {
-          ok: true,
-          name: "dsh-session-conductor",
-          skill: "task-completion-report",
-          conventionSource: "template-inject:closing（不再代码写死，由收尾模板槽位注入）",
-          tools: []
-        });
-      },
-    });
-
-    webServer.register({
-      kind: "exact",
-      path: "/api/task-completion/render",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          const block = renderCompletionBlock(body);
-          send(res, 200, { ok: true, block });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "render-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
-
-    webServer.register({
-      kind: "exact",
-      path: "/api/task-completion/check",
-      handler: async (req, res) => {
-        try {
-          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
-          if (req.method !== "GET") invalidateSessionListCache();
-          const body = await readJson(req);
-          if (typeof body?.text !== "string") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: "缺少 text" } });
-          }
-          send(res, 200, { ok: true, ...checkCompletionText(body.text) });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "check-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+    // ---------- /search 已并入下面的 session-action-routes（同一类「对会话做动作」）----------
+    // 与 /auto-rename、/analyze、/continue、/message、/auto-continue、/scan、/detach、
+    // /detach-all 以及 /repair-* 五条修复路由一起，整块拆到 features/session-action-routes.js。
+    registerSessionActionRoutes({ webServer, ctx });
+    // ---------- 价值分析 + 任务完成汇报：整块拆到 features/value-report-routes.js ----------
+    registerValueReportRoutes({ webServer, ctx });
 
     log(ctx, `API 路由已注册 (/api/session-conductor/* + /api/task-completion/*)；自动续跑: enabled=${cfg.enabled}, 默认开启=${cfg.defaultAutoContinue}, maxAttached=${cfg.maxAttached}, maxConcurrent=${cfg.maxConcurrent}`);
   });
@@ -1496,177 +450,8 @@ export async function apply(ctx, config = {}) {
   ctx.inject(["tools"], (tctx) => {
     const tools = tctx.get("tools");
     if (!defineTool) return; // 无 DSH 依赖时不注册（避免 ReferenceError 炸掉整个 inject 回调）
-    tools.register(defineTool({
-      name: "list_models",
-      description: "列出当前可用模型（provider → models[]）。切模型前先用它拿到确切 model id，不要凭记忆猜模型名。",
-      parameters: {},
-      output: {
-        schema: { type: "string" },
-        render(args, value) {
-          return [{ type: "text", text: String(value) }];
-        }
-      },
-      async execute() {
-        try {
-          const sc = ctx.get("sessionController");
-          if (!sc?.modelCatalog) return "modelCatalog 服务不可用（无法列出模型）";
-          const catalog = await sc.modelCatalog();
-          const groups = catalog?.groups ?? [];
-          if (groups.length === 0) return "模型目录为空（检查 provider 配置）";
-          return groups.map((g) => {
-            const models = (g.models ?? [])
-              .map((m) => `  - ${m.id}${m.name && m.name !== m.id ? `（${m.name}）` : ""}`)
-              .join("\n");
-            return `${g.id}${g.name && g.name !== g.id ? `（${g.name}）` : ""}:\n${models}`;
-          }).join("\n\n");
-        } catch (error) {
-          return `列出模型失败：${String(error?.message ?? error)}`;
-        }
-      }
-    }));
-/**
- * 切换后的「查证快照」：最近一次实际请求 + 最近一次切换意图 + 一行判定。
- * 抽出来是因为这段有 4 个分支，塞在工具 execute 里把圈复杂度顶到 18；
- * 判定只认「请求时真实使用的模型」（request/header），不信注入的提示语。
- * @returns {Promise<{snap: string, verdict: string}>}
- */
-async function describeSwitchSnapshot(ctx, sessionId, provider, model) {
-  const startedAt = Date.now();
-  const { lastRequest, lastSelection, scanned } = await readLastRequestModel(sessionId);
-  // 读整份日志取「最近一次请求」，大日志上这一步本身就要时间
-  log(ctx, `切换查证快照耗时 ${Date.now() - startedAt}ms（命中请求记录 ${scanned ?? 0} 条）`);
-  if (!lastRequest) {
-    return {
-      snap: "【查证·最近一次实际请求】会话日志里还没有 request/header 记录（该成员可能从未运行过）",
-      verdict: "【查证·判定】⏳ 待该成员首次运行后生效",
-    };
-  }
-  const when = lastRequest.time ? `（${new Date(lastRequest.time).toLocaleString("zh-CN")}）` : "";
-  const snap = `【查证·最近一次实际请求】${lastRequest.provider}/${lastRequest.model}${when}`
-    + (lastSelection ? `\n【查证·最近一次切换意图】${lastSelection.provider}/${lastSelection.model}` : "");
-  const alreadyNew = lastRequest.provider === provider && lastRequest.model === model;
-  return {
-    snap,
-    verdict: alreadyNew
-      ? "【查证·判定】✅ 该成员最近的请求已经是新模型"
-      : "【查证·判定】⏳ 待下一回合生效：最近一次请求是切换前发出的（属正常，不代表失败）",
-  };
-}
-
-    tools.register(defineTool({
-      name: "set_member_model",
-      description: "给指定成员/子代理切换模型（只影响该成员的会话，不动其他成员）。target 传成员名/sessionId/标题关键字；provider 是 list_models 里的分组名（如 agnes / wb），model 是该分组下的模型 id（如 global:deepseek-v4.1-flash）。切换前会校验组合是否存在，避免切到无效组合导致回合失败。",
-      parameters: {
-        target: { type: "string", required: true, description: "目标成员：成员名（如 model-test）、sessionId 或标题关键字" },
-        provider: { type: "string", required: true, description: "provider 分组名（list_models 输出的顶层分组，如 agnes / wb / ai-gateway）" },
-        model: { type: "string", required: true, description: "该 provider 下的模型 id（含前缀，如 global:deepseek-v4.1-flash / agnes-3.0-flash）" }
-      },
-      output: {
-        schema: { type: "string" },
-        render(args, value) {
-          return [{ type: "text", text: String(value) }];
-        }
-      },
-      async execute(args, exec) {
-        const provider = String(args?.provider ?? "").trim();
-        const model = String(args?.model ?? "").trim();
-        if (!provider || !model) return "切换失败：provider 和 model 都必填（先用 list_models 查确切值）";
-        // 先校验组合有效性——无效组合会让后续回合的模型请求被拒（表现为「切换生效但回合失败」）
-        const pair = await validateModelPair(ctx, provider, model);
-        if (pair.error) return `切换失败：${pair.error}`;
-        // 显式传发起方：与聊天指令 /model-switch 走**同一条**解析路径（抽公共后两边只此一份）
-        const found = findTargetAgent(ctx, args?.target, { caller: exec?.agent ?? null });
-        if (found.error) return `切换失败：${found.error}`;
-        const switchResult = await switchAgentModel(ctx, found.sessionId, provider, model, found.agent);
-        if (switchResult.error) return `切换失败：${switchResult.error}`;
-        const memberLabel = found.member?.name ? `${found.member.name}(${found.sessionId})` : found.sessionId;
-        // 查证（注册 job，不阻塞）：登记待查证项 → 该成员下次发起请求时由 agent/request 事件判定
-        // → 结果注入回本次调用方。同时立刻附一份快照：最近一次实际请求 + 最近一次切换意图。
-        // 判定只认「请求时真实使用的模型」（request/header），不信注入的提示语。
-        try {
-          registerSwitchWatch(found.sessionId, provider, model, exec?.agent?.session?.id ?? null);
-        } catch (error) {
-          log(ctx, `切换查证登记失败（不影响本次切换）: ${String(error?.message ?? error)}`);
-        }
-        let snap = "";
-        let verdict = "";
-        try {
-          ({ snap, verdict } = await describeSwitchSnapshot(ctx, found.sessionId, provider, model));
-        } catch (error) {
-          snap = `【查证·快照】读取会话日志失败：${String(error?.message ?? error)}`;
-        }
-        // 复核命令按**当前插件安装位置**生成（不写死本机路径），可直接复制执行
-        const scriptUrl = new URL("../scripts/check-member-model.mjs", import.meta.url);
-        const cmd = `node ${decodeURIComponent(scriptUrl.pathname)} ${found.sessionId}`;
-        return [
-          `已把成员 ${memberLabel}（${found.matched} 匹配）切到 ${provider}/${model}；生效方式：${switchResult.via}`,
-          // 组合校验默认关闭（避免 @Remote 卡顿）；跳过时如实告知，别让人以为「拼错也会被拦住」
-          pair.note ? `【校验】${pair.note}` : "",
-          snap,
-          verdict,
-          "【查证·任务】已登记（不阻塞）：该成员下次发起请求时按事件判定，结果会在下一次 step 注入给你",
-          `复核命令（可直接复制）：\n${cmd}`,
-        ].filter(Boolean).join("\n");
-      }
-    }));
-    // 创建成员并同时指定模型：宿主 spawn_teammate 没有 provider/model 参数，这里补齐。
-    // 形状必须与其它工具一致（render 放在 output 里）；且单独包 try/catch——
-    // 这个回调里任何一个 defineTool 抛错都会让整个 inject("tools") 中止，四个工具一起消失。
-    try {
-      tools.register(defineTool({
-        name: "create_teammate_with_model",
-        description: "创建团队成员，并让第一轮真实任务就用指定模型（宿主 spawn_teammate 没有 provider/model 参数，此工具补齐）。内部流程：占位任务创建 → 立刻中断（避免用默认模型把首轮跑掉）→ 写 model/selection → 投递真实任务。只能由 Team Lead 调用。",
-        parameters: {
-          name: { type: "string", required: true, description: "成员名（lower-kebab-case，唯一）" },
-          description: { type: "string", required: true, description: "职责简述" },
-          prompt: { type: "string", required: true, description: "该成员的初始任务全文" },
-          provider: { type: "string", required: true, description: "模型 provider 分组名（agnes / wb / d …；先用 list_models 查确切值）" },
-          model: { type: "string", required: true, description: "模型 id（先用 list_models 查确切值）" },
-          subagentProvider: { type: "string", description: "子代理 provider（与模型 provider 不是一回事；默认取 ctx.subagents.list() 第一个，通常就是 spawn）。一般不用填" },
-          context: { type: "string", description: "上下文来源：fresh（默认，不继承）或 fork（继承调用方已有回合）" },
-        },
-        output: {
-          schema: { type: "string" },
-          render(args, value) {
-            return [{ type: "text", text: String(value) }];
-          },
-        },
-        async execute(args, exec) {
-          const result = await createTeammateWithModel(ctx, exec, args);
-          return renderCreateTeammateResult(args, result);
-        },
-      }));
-    } catch (error) {
-      log(ctx, `create_teammate_with_model 注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
-    }
-
-    // 上下文用量自查工具：让 AI 自己按需查占用与构成，而不是每轮把数值注入系统提示词
-    // （每轮注入会让系统提示词前缀每轮变化 → prompt cache 失效 → 成本上升）。
-    if (registerContextUsageTool(ctx, defineTool, tools)) {
-      log(ctx, "上下文用量工具已注册 (context_usage)");
-    }
-    // 跨会话消息 + 指定模型新建会话（三个工具一次注册）。
-    // 整体包 try/catch：注册期抛错会连累同批其它工具（本项目历史事故），失败只留痕、不阻断。
-    try {
-      if (registerSessionMessagingTools(ctx, defineTool, tools)) {
-        log(ctx, "跨会话工具已注册 (list_sessions / send_to_session / create_session)");
-      }
-    } catch (error) {
-      log(ctx, `跨会话工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
-    }
-    try {
-      // 记忆取回的手动通道：让 AI 自己按需回溯（自动注入之外的补充）
-      if (registerMemoryRecallTool(ctx, defineTool, tools)) {
-        log(ctx, "记忆取回工具已注册 (recall_memory)");
-      }
-    } catch (error) {
-      log(ctx, `记忆取回工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
-    }
-    log(ctx, "成员模型工具已注册 (list_models / set_member_model)");
-    // 聊天框指令 `/model-switch`：用户自己就能看/切成员模型的入口（与 AI 工具同一套切换 + 查证路径）。
-    // 异步注册 + 独立兜底：宿主 commands 服务或 brand 包不可用时只留痕，绝不影响其它功能（同既有约定）。
-    registerModelSwitchCommand(ctx)
-      .then((ok) => { if (ok) log(ctx, "聊天框指令已注册 (/model-switch)"); })
-      .catch((error) => log(ctx, `聊天框指令注册失败（不影响其它功能）: ${String(error?.message ?? error)}`));
+    // 成员模型/权限相关的 5 个工具与 2 条聊天指令：整块拆到 member-model/tools.js
+    // （原先内联在这里 293 行，把 inject 回调撑成巨型函数；handler 体与错误隔离策略不变）。
+    registerMemberModelTools({ ctx, tools, defineTool });
   });
 }