dsh-session-conductor 1.3.13 → 1.3.17

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,13 @@ async function renderMemberList(ctx, invocation) {
   lines.push("要查**实际**在用什么（含历史请求，不只本次进程）或切换：");
   lines.push(`  /${COMMAND_NAME} <成员名或 sessionId>              ← 查实际模型`);
   lines.push(`  /${COMMAND_NAME} <成员名或 sessionId> <provider>/<模型>  ← 切换并回显查证`);
+  lines.push("");
+  lines.push("和别人对齐 / 批量：");
+  lines.push(`  /${COMMAND_NAME} * auto   ← 最常用：所有子代理都换成「我自己现在用的」模型`);
+  lines.push(`  /${COMMAND_NAME} <成员名> auto   ← 只让这一个成员换成我自己现在用的模型`);
+  lines.push(`  /${COMMAND_NAME} * <provider>/<模型>   ← 所有子代理换成一个指定的模型`);
+  lines.push("");
+  lines.push("* = 全部成员（不含我自己）；auto = 「跟我保持一致」，不用去查我用的是哪个模型。");
   return lines.join("\n");
 }
 
@@ -151,14 +160,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} * auto   ← 所有子代理换成我自己现在用的模型（最常用）\n  /${COMMAND_NAME} * <provider>/<模型>   ← 所有子代理换成指定模型`,
+        };
+      }
+      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/create-teammate.js

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

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

@@ -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,15 @@ 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";
+// 换名通道：新建成员 + 搬会话内容（成员名在宿主里不可变，只能走这条路）
+export { cloneMemberAs, transplantSessionLog, renderCloneMemberResult } from "./clone-member.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 行" };
+}

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

@@ -0,0 +1,138 @@
+// dsh-session-conductor — 权限预设指令 `/perm-switch` 与 AI 工具 `set_member_permission`
+//
+// 【为什么需要指令】子代理会话在界面上无法手动切换权限预设（界面只对主会话开放），
+// 而权限预设一旦指向当前不可用的值（典型：`auto` 在「自动审查」关闭后悬空），
+// 该成员就永久唤不醒，且宿主只报一句 `subagent/not-resumable`，完全指不到权限层。
+// 所以必须提供一条不经界面的入口：用户直接在聊天框切，AI 也能用工具切。
+//
+// 【三条形态】与 `/model-switch` 对齐：
+//   · /perm-switch                        → 列出成员与各自权限预设（并标出 auto 悬空告警）
+//   · /perm-switch <成员|sessionId>        → 查该成员的 preset / sandbox / approval
+//   · /perm-switch <成员|sessionId> <预设>  → 切换（追加 permission/preset 事件）
+//
+// 【注册方式照宿主官方范例】ctx.commands.register({ definitionId, name, description, input, handler })，
+// definitionId 用 @deepseek-ai/dsh-commands/brand 的 CommandDefinitionId() 包一层。
+// 全程动态导入宿主包：工作区自测环境没有 @deepseek-ai/* 依赖，静态导入会在导入期
+// ERR_MODULE_NOT_FOUND 并连累整个插件加载失败；拿不到就跳过注册并留痕。
+import { log } from "../../shared/log.js";
+import {
+  describeMemberPermission,
+  findTargetAgent,
+  renderMemberPermissionList,
+  readPresetCatalog,
+  switchMemberPermission,
+} from "./permission.js";
+import { resolveTargets, isAllTarget } from "./locate.js";
+import { readLeaderRoute } from "./lead.js";
+import { applyPermissionToMany, renderBatchReport } from "./batch.js";
+
+const COMMAND_NAME = "perm-switch";
+const DEFINITION_ID = "@deepseek-ai/dsh-session-conductor/command-perm-switch";
+
+/**
+ * 指令处理入口（导出便于单测直接驱动，不必走宿主）。
+ *
+ * @param {object} ctx 插件 context
+ * @param {{rawInput?: string, agent?: object}} invocation 宿主给的调用信息
+ * @returns {Promise<{kind: "success"|"error", text: string}>} 交给聊天框渲染
+ */
+export async function handlePermSwitchCommand(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 renderMemberPermissionList(ctx, invocation) };
+
+    const targetRaw = parts[0];
+    if (parts.length === 1) {
+      if (isAllTarget(targetRaw)) {
+        return {
+          kind: "error",
+          text: `批量操作需要指定预设：\n  /${COMMAND_NAME} * auto   ← 所有子代理换成我自己现在的权限预设（最常用）\n  /${COMMAND_NAME} * <预设名>   ← 所有子代理换成指定预设`,
+        };
+      }
+      const found = findTargetAgent(ctx, targetRaw, { caller });
+      if (found?.error) return { kind: "error", text: `找不到成员：${found.error}` };
+      return { kind: "success", text: (await describeMemberPermission(found)).join("\n") };
+    }
+
+    // 二参：切换（单个或全部）
+    let preset = parts[1];
+    let followedLead = null;
+    if (preset.toLowerCase() === "auto") {
+      const lead = await readLeaderRoute(ctx, { caller });
+      if (lead.error) return { kind: "error", text: `跟随主代理失败：${lead.error}` };
+      if (!lead.preset) {
+        return { kind: "error", text: `主代理（${lead.sessionId}）自己没有记录权限预设，无法跟随；请显式指定预设名` };
+      }
+      preset = lead.preset;
+      followedLead = lead;
+    }
+
+    const resolved = resolveTargets(ctx, targetRaw, { caller });
+    if (resolved?.error) return { kind: "error", text: `找不到成员：${resolved.error}` };
+
+    // 单个目标：沿用原有回执（含旋钮与可选预设）
+    if (!resolved.all && resolved.targets.length === 1) {
+      const found = resolved.targets[0];
+      const result = await switchMemberPermission(ctx, found.sessionId, preset);
+      if (result.error) return { kind: "error", text: `切换失败：${result.error}` };
+      const name = found.member?.name ? `${found.member.name}(${found.sessionId})` : found.sessionId;
+      const lines = [`已把成员 ${name} 的权限预设切成 ${result.to}`, `原预设：${result.from ?? "(未记录)"} ｜ 新事件 seq：${result.seq}`];
+      if (followedLead) lines.push(`预设来源：跟随主代理 ${followedLead.sessionId}`);
+      if (result.note) lines.push(`说明：${result.note}`);
+      lines.push(`当前旋钮：sandbox=${result.knobs?.sandbox ?? "(未记录)"} ｜ approval=${result.knobs?.approval ?? "(未记录)"}`);
+      const catalog = await readPresetCatalog(ctx);
+      if (!catalog.error) lines.push(`可选预设：${catalog.names.join(" / ")}`);
+      lines.push("该改动写在会话日志里，成员下次加载/唤醒时按折叠语义生效。");
+      return { kind: "success", text: lines.join("\n") };
+    }
+
+    // 全部目标：串行逐个切，回执带名单
+    const report = await applyPermissionToMany(ctx, resolved.targets, preset);
+    const extra = [];
+    if (followedLead) {
+      extra.push(`预设来源：跟随主代理 ${followedLead.sessionId}（${followedLead.preset}）`);
+      for (const w of followedLead.warnings ?? []) extra.push(`提示：${w}`);
+    }
+    extra.push("批量切换逐条写入各成员会话日志；单个成员失败不影响其余成员。");
+    return {
+      kind: "success",
+      text: renderBatchReport(`批量切换权限预设 → ${preset}`, report, extra),
+    };
+  } catch (error) {
+    return { kind: "error", text: `执行失败：${String(error?.message ?? error)}` };
+  }
+}
+
+/**
+ * 注册 `/perm-switch` 指令。
+ *
+ * @returns {Promise<boolean>} true = 已注册；false = 宿主 commands 服务或 brand 包不可用（已留痕）
+ */
+export async function registerPermSwitchCommand(ctx) {
+  const commands = ctx?.get?.("commands");
+  if (!commands || typeof commands.register !== "function") {
+    log(ctx, "权限指令未注册：ctx.commands 不可用（宿主未挂载 commands 服务）");
+    return false;
+  }
+  let CommandDefinitionId = null;
+  try {
+    const mod = await import("@deepseek-ai/dsh-commands/brand");
+    if (typeof mod?.CommandDefinitionId === "function") CommandDefinitionId = mod.CommandDefinitionId;
+  } catch { /* 工作区自测环境没有宿主依赖 → 走下面的返回 false */ }
+  if (!CommandDefinitionId) {
+    log(ctx, "权限指令未注册：拿不到 @deepseek-ai/dsh-commands/brand 的 CommandDefinitionId（缺宿主依赖）");
+    return false;
+  }
+  commands.register({
+    definitionId: CommandDefinitionId(DEFINITION_ID),
+    name: COMMAND_NAME,
+    description: "查看或切换成员（子代理）的权限预设；无参 = 列出成员与各自预设",
+    input: { hint: "[<成员名|sessionId> [<预设名>]]" },
+    recordInput: false,
+    handler: (invocation) => handlePermSwitchCommand(ctx, invocation),
+  });
+  return true;
+}