dsh-session-conductor 1.3.11 → 1.3.16

package/lib/features/base-routes.js

@@ -0,0 +1,156 @@
+// dsh-session-conductor — 基础路由（语言包 / 会话列表）
+//
+// 【为什么单独成文件】原先内联在 lib/apply.js 的 `ctx.inject(["webServer"])` 回调里（该回调上千行，
+// 审计 readability/max-function-length 拦截）。这里只搬「注册」这部分，handler 体逐字保留。
+//
+// ⚠️ 语言包路径：原先写 `./i18n/zh.json`（相对 lib/apply.js）。本文件位于 lib/features/，
+// 必须改成 `../i18n/...`，否则运行时读不到语言包、页面文案会整块变空。
+import { readFileSync } from 'node:fs';
+import { readJson, send } from '../http.js';
+import { log } from '../shared/log.js';
+import { invalidateSessionListCache } from '../sessions/list-cache.js';
+import { readListIndex } from '../features/session-messaging/index.js';
+import { buildSessionListCached } from '../sessions/list.js';
+
+/**
+ * 注册基础路由（语言包 + 会话列表）。
+ * @param {object} deps
+ * @param {object} deps.webServer 宿主 webServer 服务
+ * @param {object} deps.ctx 插件 ctx
+ * @returns {void}
+ */
+export function registerBaseRoutes({ webServer, ctx }) {
+    // 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) } });
+        }
+      },
+    });
+
+    // ---------- 预览页已移出本插件 ----------
+    // 原先这里用 /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 { /* 连接已断 */ }
+        }
+      },
+    });
+}

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

@@ -0,0 +1,97 @@
+// dsh-session-conductor — 批量把模型/权限应用到多个成员
+//
+// 【为什么单独抽一层】「对全部子代理统一模型/权限」在指令和 AI 工具两边都要用，
+// 而且批量写会话日志有几个必须统一的纪律：
+//   ① **串行**执行：并发写多个会话日志容易互相干扰（每个都是一次读-改-写），串行最省心；
+//   ② **逐个隔离失败**：某个成员失败（日志损坏、名册状态异常）不能中断其余成员；
+//   ③ **回执必须带名单**：批量操作最怕「不知道改了谁」，所以结果逐条列出、并统计成功/失败数。
+import { log } from "../../shared/log.js";
+import { switchAgentModel } from "./switch.js";
+import { switchMemberPermission } from "./permission.js";
+
+/** 成员显示名（名字 + 短 id，便于人核对）。 */
+export function memberDisplay(member, sessionId) {
+  const name = member?.name ?? null;
+  const shortId = sessionId ? `${sessionId.slice(0, 8)}…` : "?";
+  return name ? `${name}(${shortId})` : String(sessionId ?? "?");
+}
+
+/**
+ * 批量切换模型。
+ *
+ * @param {object} ctx 插件 context
+ * @param {Array<{sessionId: string, member?: object, agent?: object|null}>} targets 目标列表（已解析）
+ * @param {{provider: string, model: string}} route 目标路由
+ * @returns {Promise<{rows: Array<{sessionId: string, label: string, ok: boolean, detail: string}>, okCount: number, failCount: number}>}
+ */
+export async function applyModelToMany(ctx, targets, { provider, model }) {
+  const rows = [];
+  for (const t of targets) {
+    const label = memberDisplay(t.member, t.sessionId);
+    try {
+      const result = await switchAgentModel(ctx, t.sessionId, provider, model, t.agent ?? null);
+      if (result?.error) {
+        rows.push({ sessionId: t.sessionId, label, ok: false, detail: String(result.error) });
+      } else {
+        rows.push({ sessionId: t.sessionId, label, ok: true, detail: String(result.via ?? "") });
+      }
+    } catch (error) {
+      rows.push({ sessionId: t.sessionId, label, ok: false, detail: String(error?.message ?? error) });
+    }
+  }
+  const okCount = rows.filter((r) => r.ok).length;
+  log(ctx, `批量切换模型：${okCount}/${rows.length} 成功（${provider}/${model}）`);
+  return { rows, okCount, failCount: rows.length - okCount };
+}
+
+/**
+ * 批量切换权限预设。
+ *
+ * @param {object} ctx 插件 context
+ * @param {Array<{sessionId: string, member?: object}>} targets 目标列表（已解析）
+ * @param {string} preset 目标预设名
+ * @returns {Promise<{rows: Array<{sessionId: string, label: string, ok: boolean, detail: string}>, okCount: number, failCount: number}>}
+ */
+export async function applyPermissionToMany(ctx, targets, preset) {
+  const rows = [];
+  for (const t of targets) {
+    const label = memberDisplay(t.member, t.sessionId);
+    try {
+      const result = await switchMemberPermission(ctx, t.sessionId, preset);
+      if (result?.error) {
+        rows.push({ sessionId: t.sessionId, label, ok: false, detail: String(result.error) });
+      } else {
+        const from = result.from ?? "(未记录)";
+        const note = result.note ? `；${result.note}` : "";
+        rows.push({ sessionId: t.sessionId, label, ok: true, detail: `${from} → ${result.to}${note}` });
+      }
+    } catch (error) {
+      rows.push({ sessionId: t.sessionId, label, ok: false, detail: String(error?.message ?? error) });
+    }
+  }
+  const okCount = rows.filter((r) => r.ok).length;
+  log(ctx, `批量切换权限：${okCount}/${rows.length} 成功（${preset}）`);
+  return { rows, okCount, failCount: rows.length - okCount };
+}
+
+/**
+ * 渲染批量结果（先名单、后逐条结果、最后统计）。
+ *
+ * 批量操作的价值一半在「改了谁」的可核对性上，所以名单一定要完整列出，
+ * 不能只给一句「已处理 N 个」。
+ *
+ * @param {string} title 标题行（如「批量切换模型 → sa6400/deepseek-v4.1-flash」）
+ * @param {{rows: Array<{label: string, ok: boolean, detail: string}>, okCount: number, failCount: number}} report
+ * @param {string[]} [extra] 额外说明行
+ * @returns {string}
+ */
+export function renderBatchReport(title, report, extra = []) {
+  const lines = [title, ""];
+  lines.push(`受影响成员（共 ${report.rows.length} 个）：`);
+  for (const r of report.rows) lines.push(`  ${r.ok ? "✅" : "❌"} ${r.label}`);
+  lines.push("", "逐条结果：");
+  for (const r of report.rows) lines.push(`  ${r.ok ? "✅" : "❌"} ${r.label}：${r.detail || (r.ok ? "成功" : "失败")}`);
+  lines.push("", `统计：成功 ${report.okCount} 个 ｜ 失败 ${report.failCount} 个`);
+  for (const line of extra) if (line) lines.push(line);
+  return lines.join("\n");
+}

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

@@ -17,7 +17,9 @@
 //   就抛 ERR_MODULE_NOT_FOUND，连累整个插件加载失败（本项目在 defineTool / createUserMessage
 //   上踩过同类坑）。因此拿不到宿主能力时**跳过注册并如实留痕**，绝不影响插件其它功能。
 import { log } from "../../shared/log.js";
-import { findTargetAgent, collectTeamMembers } from "./locate.js";
+import { findTargetAgent, collectTeamMembers, resolveTargets, isAllTarget } from "./locate.js";
+import { readLeaderRoute } from "./lead.js";
+import { applyModelToMany, renderBatchReport } from "./batch.js";
 import { getMemberModelOverride } from "./override.js";
 import { readLastRequestModel, registerSwitchWatch, switchAgentModel, peekLastRequestModel } from "./switch.js";
 
@@ -53,6 +55,8 @@ 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）当前模型`);
   return lines.join("\n");
 }
 
@@ -151,14 +155,64 @@ async function switchMember(ctx, found, provider, model, invocation) {
 export async function handleModelSwitchCommand(ctx, invocation) {
   const raw = String(invocation?.rawInput ?? "").trim();
   const parts = raw.split(/\s+/).filter(Boolean);
+  const caller = invocation?.agent ?? null;
   try {
+    // 无参：列成员（保留原行为——列表和批量执行不能共用同一种输入，否则语义含糊）
     if (parts.length === 0) return { kind: "success", text: await renderMemberList(ctx, invocation) };
-    const found = findTargetAgent(ctx, parts[0], { caller: invocation?.agent ?? null });
-    if (found?.error) return { kind: "error", text: `找不到成员：${found.error}` };
-    if (parts.length === 1) return { kind: "success", text: await renderMemberDetail(found) };
-    const pair = splitPair(parts[1]);
-    if (pair.error) return { kind: "error", text: pair.error };
-    return await switchMember(ctx, found, pair.provider, pair.model, invocation);
+
+    const targetRaw = parts[0];
+    // 单参：查成员实际模型（`*` 没有「查」的意义，直接提示正确用法）
+    if (parts.length === 1) {
+      if (isAllTarget(targetRaw)) {
+        return {
+          kind: "error",
+          text: `批量操作需要指定模型：\n  /${COMMAND_NAME} * <provider>/<模型>   ← 全部成员切到该模型\n  /${COMMAND_NAME} * auto                  ← 全部成员跟随主代理（Lead）当前模型`,
+        };
+      }
+      const found = findTargetAgent(ctx, targetRaw, { caller });
+      if (found?.error) return { kind: "error", text: `找不到成员：${found.error}` };
+      return { kind: "success", text: await renderMemberDetail(found) };
+    }
+
+    // 二参：切换（单个或全部）
+    const routeRaw = parts[1];
+    let provider;
+    let model;
+    let followedLead = null;
+    if (routeRaw.toLowerCase() === "auto") {
+      // auto = 跟随主代理（Lead）：从请求级记录读它当前真实使用的模型
+      const lead = await readLeaderRoute(ctx, { caller });
+      if (lead.error) return { kind: "error", text: `跟随主代理失败：${lead.error}` };
+      provider = lead.provider;
+      model = lead.model;
+      followedLead = lead;
+    } else {
+      const pair = splitPair(routeRaw);
+      if (pair.error) return { kind: "error", text: pair.error };
+      provider = pair.provider;
+      model = pair.model;
+    }
+
+    const resolved = resolveTargets(ctx, targetRaw, { caller });
+    if (resolved?.error) return { kind: "error", text: `找不到成员：${resolved.error}` };
+
+    // 单个目标：沿用原有路径（带查证快照与查证任务登记）
+    if (!resolved.all && resolved.targets.length === 1) {
+      return await switchMember(ctx, resolved.targets[0], provider, model, invocation);
+    }
+
+    // 全部目标：串行逐个切，回执必须带完整名单
+    const report = await applyModelToMany(ctx, resolved.targets, { provider, model });
+    const extra = [];
+    if (followedLead) {
+      extra.push(`模型来源：跟随主代理 ${followedLead.sessionId}（${followedLead.modelSource}）`);
+      for (const w of followedLead.warnings ?? []) extra.push(`提示：${w}`);
+    }
+    extra.push("批量切换逐条写入各成员会话日志；单个成员失败不影响其余成员。");
+    return {
+      kind: "success",
+      text: renderBatchReport(`批量切换模型 → ${provider}/${model}`, report, extra),
+    };
   } catch (error) {
     return { kind: "error", text: `执行失败：${String(error?.message ?? error)}` };
   }

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

@@ -8,7 +8,11 @@
 //
 // 对外只暴露本文件——内部文件不直接被域外引用，便于后续再细分或整体提升为顶层目录。
 
-export { pickTeamCaller, memberStatusError, validateModelPair, findTargetAgent } from "./locate.js";
+export {
+  pickTeamCaller, memberStatusError, validateModelPair, findTargetAgent,
+  // 批量目标解析（空 / `*` / `all` = 全部成员，排除 Lead）与 Lead 定位
+  collectTeamMembers, isAllTarget, resolveTargets, resolveLeader,
+} from "./locate.js";
 export { getMemberModelOverride, setMemberModelOverride, applyModelOverride, resetMemberModelCacheForTest } from "./override.js";
 export { waitForIdle, appendSelectionEventToLog, switchAgentModel } from "./switch.js";
 // 切换查证（事件驱动，注册 job 不阻塞）：登记待查证项 → 每次请求记录实际模型 → 按事件判定 → 结果回报
@@ -19,3 +23,13 @@ export {
 export { resumeSetupFor } from "./setup.js";
 // 聊天框指令 /model-switch（用户视角入口，与 AI 工具共用同一条切换 + 查证路径）
 export { registerModelSwitchCommand, handleModelSwitchCommand } from "./command.js";
+// 权限预设查看/切换（子代理在界面上切不了，只能写会话日志；与模型切换同一套成员定位）
+export {
+  readMemberPermission, readPresetCatalog, switchMemberPermission,
+  describeMemberPermission, renderMemberPermissionList,
+} from "./permission.js";
+export { registerPermSwitchCommand, handlePermSwitchCommand } from "./permission-command.js";
+// 「跟随主代理」的取值来源（Lead 当前真实模型 + 当前权限预设）
+export { readLeaderRoute } from "./lead.js";
+// 批量应用与回执渲染（串行执行、逐个隔离失败、回执带完整名单）
+export { applyModelToMany, applyPermissionToMany, renderBatchReport, memberDisplay } from "./batch.js";

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

@@ -0,0 +1,73 @@
+// dsh-session-conductor — 「跟随主代理」的取值来源
+//
+// 【这个文件解决什么】切换模型/权限时把参数留空表示「跟主代理一致」，这样新建一批成员后
+// 不用逐个查 Lead 当前用的什么。这里负责把「主代理当前到底是什么」查准：
+//   · 模型：优先请求级权威记录（会话日志里的 request/header，即**真实发出请求时用的值**），
+//     退而用本进程内观察到的最近一次请求；都读不到就如实报错，绝不用名册里的静态字段冒充
+//     （名册里那个值可能是创建时的旧值，与当前实际不符）。
+//   · 权限：取会话日志里最后一条 permission/preset（宿主折叠语义：最后一条即生效值）。
+import { peekLastRequestModel, readLastRequestModel } from "./switch.js";
+import { readMemberPermission } from "./permission.js";
+import { resolveLeader } from "./locate.js";
+
+/**
+ * 读 Team Lead 当前的模型与权限预设。
+ *
+ * @param {object} ctx 插件 context
+ * @param {{caller?: object}} [opts] 显式发起方（指令/工具执行时的 agent）
+ * @returns {Promise<{sessionId: string, leadSource: string, provider: string|null, model: string|null,
+ *                    modelSource: string|null, preset: string|null, sandbox: string|null, approval: string|null,
+ *                    warnings: string[]} | {error: string}>}
+ */
+export async function readLeaderRoute(ctx, { caller = null } = {}) {
+  const lead = resolveLeader(ctx, { caller });
+  if (lead?.error) return { error: lead.error };
+
+  const warnings = [];
+  let provider = null;
+  let model = null;
+  let modelSource = null;
+
+  // ① 请求级权威记录（日志里的 request/header）
+  try {
+    const { lastRequest } = await readLastRequestModel(lead.sessionId);
+    if (lastRequest?.provider && lastRequest?.model) {
+      provider = lastRequest.provider;
+      model = lastRequest.model;
+      modelSource = "请求级记录（会话日志 request/header）";
+    }
+  } catch (error) {
+    warnings.push(`读请求级记录失败：${String(error?.message ?? error)}`);
+  }
+  // ② 本进程内观察到的最近一次请求（日志未落盘时的兜底）
+  if (!provider) {
+    const live = peekLastRequestModel(lead.sessionId);
+    if (live?.provider && live?.model) {
+      provider = live.provider;
+      model = live.model;
+      modelSource = "本进程观察（日志尚未落盘）";
+      warnings.push("模型取自进程内观察，可能比日志更新；如与界面不一致请以界面为准");
+    }
+  }
+  if (!provider) {
+    return {
+      error: `读不到主代理（${lead.sessionId}）当前使用的模型：会话日志里没有 request/header，进程内也没有观察记录。请显式指定 provider/model`,
+    };
+  }
+
+  // ③ 权限预设（最后一条 preset 生效）
+  const perm = await readMemberPermission(lead.sessionId);
+  if (perm.error) warnings.push(`读主代理权限失败：${perm.error}`);
+
+  return {
+    sessionId: lead.sessionId,
+    leadSource: lead.source,
+    provider,
+    model,
+    modelSource,
+    preset: perm.error ? null : perm.preset,
+    sandbox: perm.error ? null : perm.sandbox,
+    approval: perm.error ? null : perm.approval,
+    warnings,
+  };
+}

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

@@ -199,7 +199,11 @@ export function collectTeamMembers(ctx, { caller: explicitCaller = null } = {})
   if (teams?.listMembers && caller) {
     try {
       for (const m of teams.listMembers(caller) ?? []) {
-        push(m?.id ?? m?.sessionId, m?.name, { provider: m?.provider, model: m?.model, source: "名册" });
+        // role/status 是宿主 TeamMemberView 的既有字段：批量操作要排除 Lead 本人，
+        // 也要跳过 provisioning/failed 这类不可操作的成员，所以必须带上。
+        push(m?.id ?? m?.sessionId, m?.name, {
+          provider: m?.provider, model: m?.model, role: m?.role, status: m?.status, source: "名册",
+        });
       }
     } catch {
       // 名册不可用：继续用 agents 列表兜底
@@ -215,3 +219,80 @@ export function collectTeamMembers(ctx, { caller: explicitCaller = null } = {})
   }
   return out;
 }
+
+/** 目标是否为「全部成员」：空、`*`、`all` 都算（大小写不敏感）。 */
+export function isAllTarget(target) {
+  const t = String(target ?? "").trim().toLowerCase();
+  return t === "" || t === "*" || t === "all";
+}
+
+/**
+ * 把一次操作的 target 解析成「一个或多个」目标。
+ *
+ * 【为什么要批量形态】批量给所有子代理统一模型/权限是高频需求（新建一批成员后统一对齐），
+ * 逐个传 sessionId 既慢又容易漏。约定：空 / `*` / `all` = 全部成员（**排除 Lead 本人**，
+ * 因为「所有子代理」的语义就是下属，不该把 Lead 自己也改掉）。
+ *
+ * @param {object} ctx 插件 context
+ * @param {string} target 原始 target
+ * @param {{caller?: object}} [opts] 显式发起方
+ * @returns {{all: boolean, targets: Array<{sessionId: string, member?: object, agent?: object|null, matched?: string}>} | {error: string}}
+ */
+export function resolveTargets(ctx, target, { caller: explicitCaller = null } = {}) {
+  const agents = ctx?.get?.("agents");
+  if (isAllTarget(target)) {
+    const members = collectTeamMembers(ctx, { caller: explicitCaller });
+    // 只取可操作的下属：排除 Lead，排除正在创建/已失败的成员
+    const usable = members.filter((m) => m.role !== "lead" && m.status !== "provisioning" && m.status !== "failed");
+    if (usable.length === 0) {
+      const why = members.length === 0
+        ? "名册里没有任何成员"
+        : `名册里有 ${members.length} 个条目，但没有可操作的下属（都排除了 Lead / provisioning / failed）`;
+      return { error: `没有可操作的目标成员（${why}）` };
+    }
+    return {
+      all: true,
+      targets: usable.map((m) => ({
+        sessionId: m.id,
+        member: m,
+        agent: agents?.get?.(m.id) ?? null,
+        matched: "全部",
+      })),
+    };
+  }
+  const found = findTargetAgent(ctx, target, { caller: explicitCaller });
+  if (found?.error) return { error: found.error };
+  return { all: false, targets: [found] };
+}
+
+/**
+ * 定位 Team Lead 会话（「跟随主代理」的落点）。
+ *
+ * 【为什么要专门找 Lead】「模型/权限留空 = 跟主代理一致」里的主代理指 Team Lead，
+ * 而不是发起这次调用的那个成员——由成员自己发起时，跟随它本身毫无意义。
+ * 宿主 TeamMemberView 的 role 字段能直接识别，不需要猜。
+ *
+ * @param {object} ctx 插件 context
+ * @param {{caller?: object}} [opts] 显式发起方
+ * @returns {{sessionId: string, agent: object|null, source: string} | {error: string}}
+ */
+export function resolveLeader(ctx, { caller: explicitCaller = null } = {}) {
+  const teams = ctx?.get?.("agentTeams");
+  const agents = ctx?.get?.("agents");
+  const caller = pickTeamCaller(ctx, explicitCaller);
+  if (!caller) return { error: "拿不到发起方，无法定位 Lead（可用 sessionId 显式指定目标）" };
+  let members = [];
+  try {
+    members = teams?.listMembers?.(caller) ?? [];
+  } catch (error) {
+    return { error: `读取名册失败：${String(error?.message ?? error)}` };
+  }
+  if (members.length === 0) return { error: "名册为空，无法定位 Lead（可用 sessionId 显式指定目标）" };
+  // 发起方自己就是 Lead：直接用（省一次 agents 查找）
+  const callerId = caller?.session?.id ?? null;
+  const selfRow = callerId ? members.find((m) => m?.id === callerId && m?.role === "lead") : null;
+  if (selfRow) return { sessionId: callerId, agent: caller, source: "发起方即 Lead" };
+  const leadRow = members.find((m) => m?.role === "lead");
+  if (!leadRow) return { error: "名册里没有 Lead 行（role=lead），无法定位主代理" };
+  return { sessionId: leadRow.id, agent: agents?.get?.(leadRow.id) ?? null, source: "名册 Lead 行" };
+}