@jesonliu/lark-claudecode-bridge 1.3.6 → 1.3.8

package/dist/index.js

@@ -2,7 +2,7 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { basename, join, relative, resolve } from 'node:path';
-import { CONFIG_DIR, CONFIG_PATH, DEFAULT_CONTEXT_REMIND_TOKENS, loadConfig, sameApps } from './config.js';
+import { CONFIG_DIR, CONFIG_PATH, DEFAULT_CONTEXT_REMIND_TOKENS, INBOX_DIR, loadConfig, sameApps } from './config.js';
 import { DEFAULT_CLAUDE_DIR, initManagedClaudeDir, resolveClaudeDir } from './claude-config.js';
 import { buildTaskEnv } from './task-env.js';
 import { warnIfNoClaudeAuth } from './auth-precheck.js';
@@ -12,17 +12,19 @@ import { clearPidFile, writePidFile, stopExistingBridgeAndWait } from './web/lif
 import { AccessControl } from './access/access-control.js';
 import { FeishuGateway } from './gateway/feishu-gateway.js';
 import { ProgressCard, feishuErrorBody } from './gateway/progress-card.js';
-import { DECISION_TEXT, buildResultTailCard, buildWorkspaceSwitchedCard, resultChunkHeader, } from './gateway/card-builder.js';
+import { DECISION_TEXT, buildPlanTailCard, buildResultTailCard, buildWorkspaceSwitchedCard, planChunkHeader, resultChunkHeader, } from './gateway/card-builder.js';
 import { chunkText } from './util/chunk-text.js';
-import { runTask } from './executor/claude-executor.js';
+import { runTask, killResidentSession, killAllResidentSessions } from './executor/claude-executor.js';
 import { buildFileDiffCards } from './gateway/diff-card.js';
 import { collectFileDiff } from './util/workspace-diff.js';
 import { PermissionGate, DEFAULT_ALLOW_TOOLS_LIST, DEFAULT_DANGEROUS_COMMANDS, DEFAULT_ALLOW_ALL_TOOLS, } from './executor/permission-gate.js';
 import { discoverPlugins, resolvePluginPaths } from './executor/plugin-discovery.js';
-import { createGatewaySender, createNotifyServer, NOTIFY_SERVER_NAME } from './executor/notify-server.js';
+import { createGatewaySender, createNotifyServer, createNotifySenderSlot, NOTIFY_SERVER_NAME } from './executor/notify-server.js';
 import { BRIDGE_MCP_JSON, readMcpServersFromJsonFile } from './web/skills-mcp-api.js';
 import { FEISHU_NOTIFY_SOP_PROMPT, TOOL_HINT_PROMPT } from './notify-sop.js';
 import { ensureProfileSettingsFile, resolveAppProfile, resolveAppProfileModel } from './app-profile.js';
+import { MEMORY_PLUGIN_NAME, createMemoryProvider, ensureMemoryUserKeys, memoryEnvFor, } from './memory.js';
+import { stopManagedServer } from './memory-installer.js';
 import { isImageFile } from './util/file-types.js';
 import { FileTracker } from './util/file-tracker.js';
 import { SessionStore, migrateLegacySessions } from './session/session-store.js';
@@ -31,6 +33,9 @@ import { isLocalCommandRewrite, matchTrigger, rewriteByTrigger } from './session
 import { Semaphore, channelKey } from './session/channel.js';
 import { TranscriptWriter, sweepTranscripts } from './transcript/transcript-writer.js';
 import { nowBeijingISO } from './util/beijing-time.js';
+import { getRedactor } from './security/redact.js';
+import { DEFAULT_REDZONE_READ_SOURCES } from './security/paths.js';
+import { CANARY_ALERT_TEXT, SecurityAudit } from './security/audit.js';
 // 版本号收敛到 version.ts 单一来源（bin/lcb.ts 与 smoke 测试均引用）
 export { VERSION } from './version.js';
 // 任务总超时 4 小时（防挂死；确认等待、长编译均在正常范围）
@@ -58,7 +63,7 @@ const PLAN_DECISION_TEXT = {
     'plan-approve': '✅ 计划已批准，开始执行（后续写操作免确认）',
     'plan-revise': '📝 修改意见已提交',
     'plan-reject': '❌ 计划已放弃',
-    // plan-view-file 不消费挂起项，仅 toast「正在发送方案文件…」——文案不在此出现，留口供编译期完整性
+    // plan-view-file 不消费挂起项，仅 toast「正在重新发送计划内容卡片…」——文案不在此出现，留口供编译期完整性
     'plan-view-file': '',
 };
 /**
@@ -130,6 +135,23 @@ deps, opts = {}) {
     // plan 确认挂起项：requestId → 等待中的计划决策（plan-approve/revise/reject）。
     // 嵌入主卡片后回调侧无 cardId（主卡 messageId 由 ProgressCard 内部管理），改带 channelKey 定位活跃进度卡
     const planPending = new Map();
+    // 计划正文两段式多卡直发（与下方「结果回传两段式」完全同构）：~3000 字/块，非尾卡走文本
+    // 消息、尾卡走卡片，连发间隔 300ms 防飞书限流。planAsk 与 plan-view-file 回调（存量卡片
+    // 残留按钮，重发即「再看一遍」）共用
+    async function sendPlanContentCards(chatId, req) {
+        const chunks = chunkText(req.plan);
+        const total = chunks.length;
+        for (let i = 0; i < total; i++) {
+            if (i > 0)
+                await new Promise((r) => setTimeout(r, 300));
+            if (i === total - 1) {
+                await deps.gateway.sendCardTo(chatId, buildPlanTailCard(req, chunks[i], { index: total, total }, config.card?.width ?? 'default'));
+            }
+            else {
+                await deps.gateway.sendTextTo(chatId, `${planChunkHeader(req, i + 1, total)}\n\n${chunks[i]}`);
+            }
+        }
+    }
     // 提问挂起项：requestId → 等待中的问题答案（qa-pick 逐项收集，qa-submit 一次性 resolve）。
     // 嵌入主卡片后无 cardId，改带 channelKey 定位活跃进度卡
     const qaPending = new Map();
@@ -144,6 +166,10 @@ deps, opts = {}) {
     // 当前存活 query 的 MCP 状态拉取句柄（executor onQuery 注入、任务 finally 删除）：
     // /mcp 命令在任务运行中经此实时拉取；句柄随 query 结束失效，调用侧须 catch
     const activeQueries = new Map();
+    // 通道级 notify sender 槽（生命周期方案 A2）：常驻进程复用 spawn 时的 lcb-notify server
+    // 实例，发送目标（chatId 绑定 + sentPaths）经槽每任务换绑——同通道 FIFO 串行保证换绑
+    // 总在上一轮发送完成后发生
+    const notifySlots = new Map();
     // 触发词两段式（ask_detail）等待补充的挂起项：channelKey → 命中规则与原始消息。
     // 命中「需补充」规则时先追问不入队；同用户下一条非 / 消息视作补充内容，与 rewrite 合并后入队。
     // 超时（SUPPLEMENT_WAIT_MS）自动失效走原流程；任意本地命令（cmd.handled）即取消等待——
@@ -322,9 +348,10 @@ deps, opts = {}) {
         // currentWorkspace 语义：store 中已设置的工作区优先，否则 app 默认，最后全局默认——
         // 保证 /new、/status 回复与实际一致。用 || 而非 ??：archiveSession 为新通道建档时
         // workspaceName 存 ''（归档时不知工作区），空串必须回退默认，否则 inventory 键错位。
-        // 分身角色恒锁首个允许的工作区（config 已校验非空）：命令上下文、inventory 键与任务
-        // wsName 同源锁定，通道 state 旧存的 workspaceName 一律不采信
-        const currentWorkspace = app.role === 'deputy'
+        // 分身角色配置了工作区白名单时恒锁首个允许的工作区：命令上下文、inventory 键与任务
+        // wsName 同源锁定，通道 state 旧存的 workspaceName 一律不采信；未配置白名单 =
+        // 权限轴「全给」，与主机器人同规则（state 优先 → app 默认 → 全局默认）
+        const currentWorkspace = app.role === 'deputy' && app.allowedWorkspaces?.length
             ? app.allowedWorkspaces[0]
             : (st?.workspaceName || app.defaultWorkspace || config.defaults.workspace);
         // 2.4 触发词两段式补充（ask_detail）：上一条消息命中「需补充」规则且正在等待时，本条
@@ -436,11 +463,14 @@ deps, opts = {}) {
                 await deps.gateway.sendTextTo(msg.chatId, cmd.reply);
             }
             // 指针变更代际 bump：/new、/resume <n>、/ws use 都改写了 currentSessionId——
-            // 运行中/收尾窗口内任务的迟到归档据 pointerGen 放弃回写指针（archive 闭包比对）
+            // 运行中/收尾窗口内任务的迟到归档据 pointerGen 放弃回写指针（archive 闭包比对）。
+            // 同时作废该通道的常驻进程：换了续接目标，旧进程的会话上下文不再适用（忙进程不动，
+            // 运行中任务的中止由 /new 的 abort 负责，abort 会连带杀进程）
             if (cmd.pointerTouched) {
                 const rt = runtimes.get(key);
                 if (rt)
                     rt.pointerGen = (rt.pointerGen ?? 0) + 1;
+                killResidentSession(`${app.appId}:${key}`);
             }
             // /new 开启新会话：
             // 1) 清空旧代际排队消息（epoch 自增，旧任务入 executeTask 即 no-op）
@@ -534,6 +564,30 @@ deps, opts = {}) {
         // 白名单/黑名单经 getter 传入：gate 虽按通道永久复用，decide 时才经 getter 现读
         // config.permissions——热重载原地 mutate 同一 config 对象后，已有通道的下一个工具
         // 调用即生效（不再需要新通道/重启；0.17.0 静态快照导致改配置后旧通道不生效）
+        // 分身安全闸（R1/R2/Bash 三态）：仅 deputy 注入，主机器人行为零变化
+        const securityGuard = app.role === 'deputy'
+            ? {
+                cwd: workspacePath(wsName),
+                // 入站附件豁免根：与 gateway 下载目录共用单源常量（config.ts INBOX_DIR）——用户发给 bot 的
+                // 图片/文件必须可读可处理，属产品功能正确性；R1/Bash 探测豁免，R2 写边界不豁免
+                inboxRoot: INBOX_DIR,
+                redzone: () => config.security?.redzone?.read ?? DEFAULT_REDZONE_READ_SOURCES,
+                // 未配置工作区白名单 = 权限轴全给：写根 = 全部已配置工作区（R2 红线仍在：工作区外只读）
+                writeRoots: () => (app.allowedWorkspaces?.length ? app.allowedWorkspaces : config.workspaces.map((w) => w.name))
+                    .map((n) => workspacePath(n)),
+                bashMode: () => app.bashMode ?? 'confirm',
+            }
+            : undefined;
+        // 安全事件分流：审计落盘（always）+ 金丝雀向当前聊天告警（固定模板，节流在 gateway 侧）
+        const onSecurityEvent = (ev) => {
+            deps.audit?.write(app.appId, ev);
+            if (ev.kind !== 'canary') {
+                console.warn(tag, '[安全拦截]', JSON.stringify(ev));
+                return;
+            }
+            console.error(tag, '[安全告警] 🚨 金丝雀命中（防线疑似被穿透），已脱敏并告警');
+            void deps.gateway.sendTextTo(msg.chatId, CANARY_ALERT_TEXT).catch(() => { });
+        };
         let gate = gates.get(key);
         if (!gate) {
             gate = new PermissionGate({
@@ -541,6 +595,8 @@ deps, opts = {}) {
                 // ?? 而非 ||：显式 false（用户主动关闭全部免确认）不能被回落到缺省的 true
                 allowAllTools: () => config.permissions?.allowAllTools ?? DEFAULT_ALLOW_ALL_TOOLS,
                 dangerousCommands: () => config.permissions?.dangerousCommands ?? DEFAULT_DANGEROUS_COMMANDS,
+                ...(securityGuard ? { security: securityGuard } : {}),
+                onSecurityEvent,
                 ask: async (req) => {
                     // 工具确认嵌入当前任务的进度卡（按钮在计时行上方、正文收敛）——不再单独发确认卡：
                     // 独立确认卡与进度卡正文内容大量重复，且追加在进度卡下方会把进度卡顶出会话底部。
@@ -576,19 +632,24 @@ deps, opts = {}) {
                         });
                     });
                 },
-                // plan 确认（#3+#6）：不再单独发计划卡片组。计划正文先落盘到 ~/.lark-claudecode-bridge/claude/plans/
-                // （slug + 时间戳，方便后续 review 与 SOP 要求的 plan 本地归档），然后嵌入当前任务的进度卡：
-                // 卡片正文仅露 600 字预览 + 「查看完整方案」按钮（callback send_file 发送原 md 文件，不塞卡片正文
-                // ——飞书单卡 30KB 上限与可读性都不允许长方案铺在卡片里）；批准/放弃/按意见修改三按钮与意见输入框
-                // 仍在主卡片的内嵌 form 内。超时由本闭包自管：到点 clearPlan + resolve reject
+                // plan 确认（#3+#6）：计划正文与完整回复同款两段式多卡直发（sendPlanContentCards），
+                // 不搞「点按钮收文件」特例；原文另落盘 claude/plans/ 归档（slug + 时间戳，方便 review
+                // 与 SOP 要求的本地归档，不再有回调消费）。批准/放弃/按意见修改三按钮与意见输入框仍在
+                // 主卡片的内嵌 form 内。超时由本闭包自管：到点 clearPlan + resolve reject
                 planAsk: async (req) => {
                     const planReq = { requestId: randomUUID(), plan: req.plan, workspaceName: req.workspaceName };
-                    // 落盘计划原文：路径走 ensureRuntimeDirs 已建的 claude/plans 目录，文件名加时间戳避免并发冲突
-                    const planFilePath = writeRuntimeMarkdown(join('claude', 'plans'), req.workspaceName || 'plan', `# 执行计划 · ${req.workspaceName} · ${new Date().toLocaleString('zh-CN', { hour12: false })}\n\n${req.plan}\n`, `${tag}[计划落盘失败]（不影响流程，仅「查看完整方案」可能不可用）：`);
+                    // 落盘归档：文件名加时间戳避免并发冲突；失败仅影响归档，不影响直发与审批
+                    const planFilePath = writeRuntimeMarkdown(join('claude', 'plans'), req.workspaceName || 'plan', `# 执行计划 · ${req.workspaceName} · ${new Date().toLocaleString('zh-CN', { hour12: false })}\n\n${req.plan}\n`, `${tag}[计划归档落盘失败]（不影响流程）：`);
+                    if (planFilePath)
+                        console.log(tag, `[计划归档] ${planFilePath}`);
                     const progress = activeProgress.get(key);
                     if (!progress)
                         return { action: 'reject' }; // 进度卡不在 = 任务已结束/被 abort，按放弃处理
-                    progress.setPlan({ requestId: planReq.requestId, plan: req.plan, workspaceName: req.workspaceName, planFilePath });
+                    progress.setPlan({ requestId: planReq.requestId, plan: req.plan, workspaceName: req.workspaceName });
+                    // 正文直发放挂起开始前：raceFallback 兜底 WS 偶发挂起（此刻超时定时器尚未 arm，裸 await
+                    // 挂起即永不超时——同 ask 发卡约束）；raceFallback 永不 reject，失败/超时仅内部落日志，
+                    // 审批表单照常可用
+                    await raceFallback(sendPlanContentCards(msg.chatId, planReq), CARD_SEND_TIMEOUT_MS, undefined);
                     // 不再 sinkToBottom：plan 区嵌入主进度卡，flush 自然 PATCH，删旧卡重发只会让用户看到计划区跳一下
                     return new Promise((resolve) => {
                         const gc = setTimeout(() => {
@@ -607,7 +668,6 @@ deps, opts = {}) {
                             ownerId: msg.userId,
                             channelKey: key,
                             chatId: msg.chatId,
-                            planFilePath,
                         });
                     });
                 },
@@ -663,7 +723,14 @@ deps, opts = {}) {
         const toolHintEnabled = config.session?.toolHint !== false;
         const sentPaths = new Set();
         const sink = async () => { await activeProgress.get(key)?.sinkToBottom(); };
-        const notifySender = createGatewaySender({
+        // 槽式换绑（A2）：本任务的 sender（chatId 硬绑定 + sentPaths 去重集）挂进通道级槽——
+        // 常驻进程复用 spawn 时的 lcb-notify server 实例，经 delegate 路由到槽内当前 sender
+        let notifySlot = notifySlots.get(key);
+        if (!notifySlot) {
+            notifySlot = createNotifySenderSlot();
+            notifySlots.set(key, notifySlot);
+        }
+        notifySlot.setSender(createGatewaySender({
             chatId: msg.chatId,
             sentPaths,
             sendText: async (c, md) => {
@@ -682,7 +749,7 @@ deps, opts = {}) {
                 await deps.gateway.uploadAndSendFile(c, p);
                 await sink();
             },
-        });
+        }));
         activeProgress.set(key, progress);
         // 指针代际快照：任务运行期间 /new、/resume <n>、/ws use 都会 bump pointerGen，本任务
         // 收尾归档据此放弃回写指针（只入历史不覆盖用户选择）。定义在 try 外：catch 路径同样调用
@@ -697,10 +764,40 @@ deps, opts = {}) {
         try {
             await progress.start();
             const state = deps.store.getChannelState(key);
+            // A3 群聊会话自动滚动（双阈值，先到先滚，业务无感）：空闲超阈值（话题切换天然伴随
+            // 时间间隔）或轮次满阈值（兜底单话题超长）→ 指针置 null——即 /new 的现成一行语义，
+            // 本条消息就是新话题的首条。私聊不滚（手动 /new 管理最优）。滚动同样 bump epoch
+            // 对齐 /new 语义：旧代际排队消息按「新建会话」丢弃（指针写保护已有 pointerGen 兜底）。
+            // 有排队消息被丢弃时显式告知（静默吞用户消息不可接受）；滚动本身不发独立提示，
+            // 仅在本条回复尾部带一次轻注记（见下方成功路径，可配置关闭）
+            let rolled = false;
+            if (msg.chatType === 'group') {
+                const idleHours = config.session?.groupIdleResetHours ?? 4;
+                const maxTurns = config.session?.groupMaxTurns ?? 30;
+                const lastActiveMs = state?.lastActiveAt ? Date.parse(state.lastActiveAt) : NaN;
+                const idleHit = idleHours > 0 && Number.isFinite(lastActiveMs) && Date.now() - lastActiveMs > idleHours * 3_600_000;
+                const turnsHit = maxTurns > 0 && (state?.turnCount ?? 0) >= maxTurns;
+                if (idleHit || turnsHit) {
+                    deps.store.setCurrentSession(key, null, state?.workspaceName || wsName); // turnCount 随之清零
+                    const rtRoll = runtimes.get(key);
+                    const dropped = rtRoll?.queuedCount ?? 0;
+                    if (rtRoll) {
+                        rtRoll.epoch = (rtRoll.epoch ?? 0) + 1; // 本条已过代际检查，继续执行；后续旧代际排队消息入口 no-op
+                        rtRoll.queuedCount = 0;
+                    }
+                    rolled = true;
+                    console.log(tag, `[滚动] ${idleHit ? `空闲超 ${idleHours}h` : `轮次满 ${maxTurns}`}，群聊自动开启新话题：${key}`);
+                    if (dropped > 0) {
+                        await deps.gateway.sendTextTo(msg.chatId, `🗑️ 已开启新话题，${dropped} 条排队消息按旧话题取消（/resume 可找回此前讨论）`)
+                            .catch(() => { });
+                    }
+                }
+            }
             // 续接指针三态：undefined=旧版存量数据 → 回退 sessions[0]（旧语义 sessions[0] 即当前）；
             // null=/new 或 /ws use 已清指针 → 新开会话；字符串 → resume 该会话。
-            // 不能用 ??：null 会被 ?? 当成空值回退 sessions[0]，/new 的意图就被吞掉了
-            const pointer = state?.currentSessionId;
+            // 不能用 ??：null 会被 ?? 当成空值回退 sessions[0]，/new 的意图就被吞掉了。
+            // 滚动刚把指针置 null：本条直接开新会话（rolled 分支不用再读盘）
+            const pointer = rolled ? null : state?.currentSessionId;
             const resumeId = pointer === undefined ? state?.sessions?.[0]?.sessionId : pointer || undefined;
             const now = () => nowBeijingISO();
             // 落盘 · user：任务起点（prompt 全文 + resume 链上一轮 sessionId）
@@ -710,6 +807,15 @@ deps, opts = {}) {
             });
             // 任务级 env 现读构造（热生效）：apps[].env / claude.env 改动后下一条消息即用新值
             const taskEnv = buildTaskEnv(config, app, claudeDir);
+            // 长期记忆 ns env（§6.4/§6.6）：memory.enabled 时每条消息拼装下发——OPENVIKING_USER 按
+            // 消息级 userId 隔离（群聊同事话语不混入主人记忆；deputy 的 appId 天然不同即分身永不读
+            // 主人记忆）。?? 保留既有值：apps[].env 手配 OPENVIKING_* = 专家覆盖口。关段 = 零注入，
+            // 行为与无此段完全一致（可插拔验收）；常驻进程经配置指纹回收（env 变 → 指纹变 → 重建）
+            if (config.memory?.enabled) {
+                for (const [k, v] of Object.entries(memoryEnvFor(config.memory, app.appId, msg.userId, deps.memory?.userKeys()))) {
+                    taskEnv[k] ??= v;
+                }
+            }
             // 打点只列键名不列值（env 常含凭证，防日志泄漏）；值含 ${ 提示误配——env 值不做变量
             // 展开，${VAR} 会原样传给 CLI（变量展开只在 MCP 配置一侧，展开源正是这里注入的环境）
             const envKeys = [...new Set([...Object.keys(app.env ?? {}), ...Object.keys(config.claude?.env ?? {})])];
@@ -766,28 +872,64 @@ deps, opts = {}) {
                 // 机器人档案认证 settings 文件（--settings）：仅含认证键，命令行层压制生效目录 env
                 ...(profileSettingsPath ? { extraArgs: { settings: profileSettingsPath } } : {}),
                 // 进程内通知工具（send_text/send_image/send_file）：中间产物实时推给当前聊天。
-                // server 实例按任务构造，chatId 在 sender 闭包内硬绑定——模型无法选择接收者。
+                // server 实例按任务构造（挂通道槽 delegate，见上方槽式换绑），chatId 在 sender
+                // 闭包内硬绑定——模型无法选择接收者。
                 // 配置页 MCP（#12）一并注入：bridge 自管 servers.json 每任务现读（热生效），notify 后展开保名
-                mcpServers: { ...loadBridgeMcpServers(), [NOTIFY_SERVER_NAME]: createNotifyServer(notifySender) },
+                mcpServers: { ...loadBridgeMcpServers(), [NOTIFY_SERVER_NAME]: createNotifyServer(notifySlot.delegate) },
+                // A2 常驻进程池：同通道亲和复用 CLI 子进程（冷启动税摊薄为每会话一次）。
+                // 指纹 = 本任务现读的全部 spawn 输入（人设/模型/plan/env/MCP/插件/档案 settings/
+                // cwd/续接指针），任一变化 → executor 回收重建，保「每任务现读热生效」语义；
+                // 空闲回收与池上限策略同样每任务现读（热改配置下一条消息生效）
+                affinityKey: `${app.appId}:${key}`,
+                resident: config.session?.residentProcess !== false,
+                residentIdleMs: (config.session?.residentIdleMinutes ?? 60) * 60_000,
+                residentMax: config.session?.residentMaxProcesses ?? (app.concurrency ?? config.concurrency),
+                residentScope: app.appId,
                 // 插件：config.yaml 显式配置（开发期指源码目录）+ Claude 配置目录已启用的 marketplace
                 // 插件自动发现，同名显式优先；SDK 对无效路径静默跳过，实际加载以 init 清单（/plugins 命令）为准。
                 // managed 模式合并发现两处目录（自管 + 本机 ~/.claude）：按绝对 installPath 传 SDK，
                 // 用户本机已装插件无须重装；resolvePluginPaths 按 name 去重，当前生效目录优先。
                 // 分身角色按 allowed_plugins 白名单过滤（显式 app.plugins 始终保留——写在分身配置里
-                // 的就是要给的）；未配 allowed_plugins 时自动发现全剔除（分身不声明 = 不加载）
+                // 的就是要给的）；未配 allowed_plugins = 权限轴「全给」，自动发现插件全部加载。
+                // 记忆插件自动注入（§6.9）：memory.enabled 时 openviking-memory 以宿主基础设施身份
+                // 加入加载集，不受 deputy 白名单过滤——记忆是宿主给每个 bot 的恒定能力（同 notify
+                // server），不是主人分配给分身的业务插件。B0 实测教训：不注入则白名单分身静默金鱼记忆。
                 ...(() => {
                     const discovered = claudeDir === DEFAULT_CLAUDE_DIR
                         ? discoverPlugins(claudeDir)
                         : [...discoverPlugins(claudeDir), ...discoverPlugins(DEFAULT_CLAUDE_DIR)];
                     let merged = resolvePluginPaths(app.plugins, discovered);
-                    if (app.role === 'deputy') {
-                        merged = merged.filter((p) => app.plugins?.some((e) => e.name === p.name) || app.allowedPlugins?.includes(p.name));
+                    if (app.role === 'deputy' && app.allowedPlugins !== undefined) {
+                        merged = merged.filter((p) => app.plugins?.some((e) => e.name === p.name) || app.allowedPlugins.includes(p.name));
+                    }
+                    // 装配校验告警 ①（§6.9 L2）：deputy 白名单零命中——配了白名单但与发现集零交集，
+                    // 「以为在收权，实际连一个插件都没给」几乎必为配置错误（B0 实测：二号 bot 配
+                    // [library] 而该插件未启用 → 实际加载 0 插件，全程零提示）。在记忆注入前判定，
+                    // 避免注入的记忆插件掩盖零命中事实
+                    if (app.role === 'deputy' && app.allowedPlugins?.length && merged.length === 0) {
+                        console.warn(tag, `[memory] 分身 "${app.name}" 配置了 allowed_plugins（${app.allowedPlugins.join('、')}）`
+                            + ' 但与已发现插件零命中：自动发现插件实际加载 0 个。请检查插件名拼写，或确认插件已安装且在 '
+                            + 'settings.json enabledPlugins 中启用（/plugins 可查实际加载清单；方案 §6.9）');
+                    }
+                    // 记忆插件注入（§6.9 L1）：幂等合流——已显式配置或已过白名单时同名去重不重复加载；
+                    // 未发现（未安装/未启用）则注入无从谈起，落告警 ② 提示安装，不静默
+                    if (config.memory?.enabled && !merged.some((p) => p.name === MEMORY_PLUGIN_NAME)) {
+                        const found = discovered.find((p) => p.name === MEMORY_PLUGIN_NAME);
+                        if (found)
+                            merged.push({ name: found.name, path: found.path, source: 'discovered' });
+                        else {
+                            console.warn(tag, `[memory] memory.enabled=true 但插件 ${MEMORY_PLUGIN_NAME} 未被发现（未安装或 enabledPlugins 未启用）：`
+                                + '记忆召回/沉淀 hooks 不会生效。安装：claude plugin install openviking-memory@openviking'
+                                + '（或经配置页插件安装；详见 docs 方案 §6.9）');
+                        }
                     }
                     return merged.length ? { plugins: merged.map((p) => ({ path: p.path })) } : {};
                 })(),
                 // 分身技能白名单：透传 SDK Options.skills（官方上下文过滤器——未列出技能对模型不可见
                 // 且被 Skill 工具拒绝；非沙箱：技能文件仍在磁盘可被 Read/Bash 读到，用户已知悉此边界）
                 ...(app.role === 'deputy' && app.allowedSkills?.length ? { allowedSkills: app.allowedSkills } : {}),
+                // 分身计划批准不升级 acceptEdits：该模式会绕过 canUseTool，宿主安全闸（R1/R2）随之失效
+                ...(app.role === 'deputy' ? { planApproveEscalates: false } : {}),
                 canUseTool: (toolName, input, ctx) => gate.decide(toolName, input, wsName, ctx),
                 onQuery: (handle) => { activeQueries.set(key, { wsName, handle }); },
             }, {
@@ -818,20 +960,30 @@ deps, opts = {}) {
                     }
                     else if (e.kind === 'text') {
                         progress.markStarted();
-                        progress.appendText(e.content);
+                        // R3：流式正文块脱敏后再渲染/落盘（进度卡展示 + transcript 双消费点；
+                        // gateway 深度脱敏仍在其后兜底，双保险覆盖 transcript 这一本地落盘面）
+                        const streamRedaction = getRedactor(config.security).text(e.content);
+                        if (streamRedaction.hits.length) {
+                            deps.audit?.write(app.appId, { kind: 'redact', ruleIds: [...new Set(streamRedaction.hits)], source: 'stream' });
+                        }
+                        if (streamRedaction.canary)
+                            onSecurityEvent({ kind: 'canary', source: 'stream' });
+                        progress.appendText(streamRedaction.text);
                         // 落盘 · assistant：流式文本块全文（每块一行，天然增量）
                         deps.transcript?.assistant({
                             v: 1, ts: now(), kind: 'assistant', app: app.appId,
-                            chatId: msg.chatId, userId: msg.userId, text: e.content,
+                            chatId: msg.chatId, userId: msg.userId, text: streamRedaction.text,
                         });
                     }
                     else if (e.kind === 'tool-start') {
                         const [n, ...rest] = e.content.split(': ');
                         progress.markStarted();
-                        progress.toolStart(n, rest.join(': '));
+                        // 摘要（命令串/路径）同样过脱敏再落盘——命令回显可能带出先前输出中的秘密
+                        const summaryRedaction = getRedactor(config.security).text(rest.join(': '));
+                        progress.toolStart(n, summaryRedaction.text);
                         deps.transcript?.tool({
                             v: 1, ts: now(), kind: 'tool', app: app.appId,
-                            chatId: msg.chatId, userId: msg.userId, phase: 'start', tool: n, summary: rest.join(': '), ok: true,
+                            chatId: msg.chatId, userId: msg.userId, phase: 'start', tool: n, summary: summaryRedaction.text, ok: true,
                         });
                     }
                     else if (e.kind === 'tool-result') {
@@ -861,8 +1013,25 @@ deps, opts = {}) {
                 });
                 return;
             }
-            // finalText 提前算好：finish 携带字数，终态进度卡据此显示「完整回复已单独发送」提示行
-            const finalText = outcome.finalText?.trim() ?? '';
+            // finalText 提前算好：finish 携带字数，终态进度卡据此显示「完整回复已单独发送」提示行。
+            // R3：先脱敏再落盘/发送——transcript 写入（下方 result 事件）与结果卡都消费脱敏后文本，
+            // bridge 自己的落盘不再残留明文（方案 v3 §八.4：脱敏点在 transcript 之前，非发送点）
+            const finalRedaction = getRedactor(config.security).text(outcome.finalText?.trim() ?? '');
+            if (finalRedaction.hits.length) {
+                deps.audit?.write(app.appId, { kind: 'redact', ruleIds: [...new Set(finalRedaction.hits)], source: 'final' });
+            }
+            if (finalRedaction.canary)
+                onSecurityEvent({ kind: 'canary', source: 'final' });
+            const finalText = finalRedaction.text;
+            // A3 滚动轻注记：新话题首条回复尾部带一次（仅此一条，可配置关闭）——不发独立提示
+            // 消息（群聊里机器人自言自语就是噪音），失忆困惑由注记 + /resume 兜底；记忆层上线后
+            // 此注记可弱化/去除。注记只进回传文本，不进 transcript（传输层装饰，非模型产出）
+            const rollNote = rolled && config.session?.groupRollNotify !== false
+                ? '🍃 已开启新话题（此前讨论 /resume 可找回）'
+                : '';
+            const replyText = finalText
+                ? (rollNote ? `${finalText}\n\n---\n${rollNote}` : finalText)
+                : rollNote;
             await progress.finish('✅ 完成', finalText.length || undefined);
             archive(outcome.sessionId);
             deps.transcript?.result({
@@ -886,8 +1055,8 @@ deps, opts = {}) {
             // 消息限流）——不论长短都不再进进度卡正文（主卡只留提示行），彻底消除「折叠看不到全文」
             // 与「卡片/消息两边重复」（旧三段式 ≤400 终态自载的边界问题）。尾卡纯展示，想继续对话/
             // 提意见直接回复消息即可
-            if (finalText) {
-                const chunks = chunkText(finalText);
+            if (replyText) {
+                const chunks = chunkText(replyText);
                 const total = chunks.length;
                 const resultReq = {
                     charCount: finalText.length, workspaceName: wsName,
@@ -980,6 +1149,9 @@ deps, opts = {}) {
             activeQueries.delete(key);
             rt.abort = undefined;
             rt.busy = false;
+            // A3 滚动计数：任务收尾即一轮活跃（成功/出错/停止都消耗了上下文，均向阈值累积）；
+            // 指针与历史归档已在上文完成，markActivity 只记时间戳与轮次
+            deps.store.markActivity(key);
             release();
         }
     }
@@ -999,12 +1171,12 @@ deps, opts = {}) {
                     return { toast: { type: 'info', content: '仅任务发起人可操作计划' } };
                 }
                 const decision = action.value.decision;
-                // 「查看完整方案」（#6）：callback 触发 send_file 直接发原 md 文件，不消耗挂起项
+                // plan-view-file（存量卡片残留按钮）：计划正文已改为卡片直发（planAsk），此处等价重发
+                // 一遍内容卡片组——不消耗挂起项，可反复点击
                 if (decision === 'plan-view-file') {
-                    // 文件在 planAsk 时已落盘；这里直接 send_file（feishuGateway 走 file_type:stream，md 等任意后缀可发）
-                    void deps.gateway.uploadAndSendFile(plan.chatId, plan.planFilePath)
-                        .catch((e) => console.error('[查看方案发送失败]', action.value.requestId, e));
-                    return { toast: { type: 'info', content: '正在发送方案文件…' } };
+                    void sendPlanContentCards(plan.chatId, plan.req)
+                        .catch((e) => console.error('[计划内容重发失败]', action.value.requestId, e));
+                    return { toast: { type: 'info', content: '正在重新发送计划内容卡片…' } };
                 }
                 if (decision !== 'plan-approve' && decision !== 'plan-revise' && decision !== 'plan-reject') {
                     return { toast: { type: 'info', content: '该计划确认已被处理或已过期' } };
@@ -1125,10 +1297,12 @@ deps, opts = {}) {
                     return { toast: { type: 'info', content: '该工作区已是当前工作区' } };
                 }
                 applyWorkspaceSwitch(deps.store, wsc.channelKey, target);
-                // 等价 cmd.pointerTouched：切换清了续接指针，运行中/收尾窗口内任务的迟到归档不得回写
+                // 等价 cmd.pointerTouched：切换清了续接指针，运行中/收尾窗口内任务的迟到归档不得回写；
+                // 常驻进程同步作废（cwd 已随工作区变化，旧进程上下文不再适用）
                 const wsRt = runtimes.get(wsc.channelKey);
                 if (wsRt)
                     wsRt.pointerGen = (wsRt.pointerGen ?? 0) + 1;
+                killResidentSession(`${app.appId}:${wsc.channelKey}`);
                 // 同通道其余工作区卡置 stale：旧卡显示的当前项已过时，继续可点会诱导误切回旧工作区
                 for (const [id, e] of wsPending) {
                     if (e.channelKey === wsc.channelKey && id !== action.value.requestId)
@@ -1199,7 +1373,7 @@ deps, opts = {}) {
  * 读失败（文件被写坏的中间态等）沿用旧值不崩，并返回用户可读的错误消息（成功返回 null）——
  * 调用方（processMessage）据此在聊天里显式提示「本次沿用旧配置」，不再静默。
  */
-export function createConfigReloader(config, configPath) {
+export function createConfigReloader(config, configPath, opts = {}) {
     return () => {
         let fresh;
         try {
@@ -1232,8 +1406,10 @@ export function createConfigReloader(config, configPath) {
         config.workspaces = fresh.workspaces;
         config.defaults = fresh.defaults;
         // 权限白名单/黑名单热应用：通道级 gate 复用，但经 getter 在 decide 时现读 config.permissions，
-        // 此处原地替换后已有通道的下一个工具调用即用新名单
+        // 此处原地替换后已有通道的下一个工具调用即用新名单。安保段（红区/脱敏/金丝雀）同款 getter
+        // 现读 → 热生效；脱敏器按配置键 memo，键变化自动重编译
         config.permissions = fresh.permissions;
+        config.security = fresh.security;
         config.claude = fresh.claude;
         config.server = fresh.server;
         config.slashCommands = fresh.slashCommands;
@@ -1242,6 +1418,13 @@ export function createConfigReloader(config, configPath) {
         // 卡片宽度热应用：gateway 的 cardWidth getter 与各处发卡传参都现读 config.card，
         // 原地替换后下一条消息的所有卡片即用新宽度（0.x 遗漏导致改宽度须重启的修复）
         config.card = fresh.card;
+        // 长期记忆段热应用（§6.6）：OPENVIKING_* env 下发与记忆插件注入均每任务现读 config.memory，
+        // 原地替换后下一条消息即生效；常驻进程经配置指纹回收（env/plugins 变化 → 指纹变 → 重建）。
+        // 段变化时通知调用方（startBridge 据此后台重签 user key——account/root key 改动会使旧 key 失配）
+        const memoryChanged = JSON.stringify(fresh.memory ?? null) !== JSON.stringify(config.memory ?? null);
+        config.memory = fresh.memory;
+        if (memoryChanged)
+            opts.onMemoryChanged?.(fresh.memory);
         // managed 模式 claude.env 热生效：inherit 由每任务 buildTaskEnv 并入子进程 env 即可；
         // managed 走托管 settings.json 通道（CLI 侧 settings.json env 优先于进程 env），
         // 此处即时重写盘保证两通道同值——不写盘则手改 env 会被盘上旧值覆盖而静默失效
@@ -1264,6 +1447,8 @@ export function createConfigReloader(config, configPath) {
                 // 机器人级厂商档案热生效：executeTask 每任务经 app-profile.ts 现读解析
                 config.apps[i].profile = fa.profile;
                 config.apps[i].profileModel = fa.profileModel;
+                // 分身 Bash 三态热生效：gate 在 decide 时经 getter 现读 app.bashMode
+                config.apps[i].bashMode = fa.bashMode;
             });
         }
         return null;
@@ -1287,8 +1472,41 @@ export async function startBridge(configPath = CONFIG_PATH) {
         if (removed > 0)
             console.log(`[transcripts] 已清理 ${removed} 个过期落盘文件`);
     }
+    // 长期记忆（§6.6 B1）：启动时 Admin API 签发 per-bot user key——api_key 模式才实际签发，
+    // dev 模式服务端禁用 Admin API（身份经 OPENVIKING_USER → X-OpenViking-User header 隔离，
+    // 跳过即正解）；memory 段热重载变化时后台重签（account/root key 改动会使旧 key 失配）。
+    // key 只进内存缓存与子进程 env，永不落日志/配置页
+    const memoryUserKeys = new Map();
+    const refreshMemoryKeys = async () => {
+        if (!config.memory?.enabled) {
+            memoryUserKeys.clear();
+            return;
+        }
+        const outcomes = await ensureMemoryUserKeys(config.memory, config.apps.map((a) => a.appId));
+        memoryUserKeys.clear();
+        for (const o of outcomes.values()) {
+            if (o.userKey) {
+                memoryUserKeys.set(o.appId, o.userKey);
+                console.log(`[memory] bot ${o.appId}：user key 已签发（api_key 模式）`);
+            }
+            else if (o.error)
+                console.warn(`[memory] bot ${o.appId}：user key ${o.error}`);
+            else
+                console.log(`[memory] bot ${o.appId}：${o.skipped}`);
+        }
+    };
+    if (config.memory?.enabled)
+        await refreshMemoryKeys();
+    const memoryProvider = createMemoryProvider(config, memoryUserKeys);
     // reloader 共享：所有 bridge 持有同一 config 对象引用，mutate 一处全员可见
-    const reloadConfig = createConfigReloader(config, configPath);
+    const reloadConfig = createConfigReloader(config, configPath, {
+        onMemoryChanged: (memory) => {
+            if (memory?.enabled)
+                void refreshMemoryKeys();
+            else
+                memoryUserKeys.clear();
+        },
+    });
     // 旧版（≤0.3.x）缺省独立目录的一次性迁移提示：目录还在则其中历史会话不再可 /resume
     //（本版起所有机器人统一 ~/.claude，会话无法跨数据目录 resume）。不做自动迁移（双目录合并无安全做法）
     for (const app of config.apps) {
@@ -1299,6 +1517,8 @@ export async function startBridge(configPath = CONFIG_PATH) {
         }
     }
     // 每 app 一对 gateway+bridge：长连接/会话池/并发闸/Claude Code 环境/落盘目录全部 per-app 隔离
+    // 安全面审计：单实例按 appId 分文件落盘（CONFIG_DIR/security/audit-<appId>.jsonl）
+    const securityAudit = new SecurityAudit(join(CONFIG_DIR, 'security'));
     const runners = config.apps.map((app) => {
         const tag = `[app:${app.name}]`;
         const gateway = new FeishuGateway(app, {
@@ -1307,6 +1527,13 @@ export async function startBridge(configPath = CONFIG_PATH) {
             strictGroupMention: config.apps.length > 1,
             // 卡片宽度热生效：getter 现读 config.card（reloader 原地 mutate 同一对象）
             cardWidth: () => config.card?.width ?? 'default',
+            // R3 出站脱敏（恒开，全部机器人）：getter 现读 config.security → 热重载即生效
+            redactor: () => getRedactor(config.security),
+            onSecurityEvent: (ev) => {
+                securityAudit.write(app.appId, ev);
+                if (ev.kind !== 'redact')
+                    console.warn(tag, '[安全事件]', ev.kind);
+            },
         });
         const deps = {
             gateway: {
@@ -1327,6 +1554,8 @@ export async function startBridge(configPath = CONFIG_PATH) {
             store: SessionStore.load(join(CONFIG_DIR, `sessions.${app.appId}.json`)),
             executor: runTask,
             transcript: new TranscriptWriter(join(CONFIG_DIR, 'transcripts', app.appId)),
+            audit: securityAudit,
+            memory: memoryProvider,
         };
         return { app, gateway, bridge: createBridge(config, app, deps, { reloadConfig }) };
     });
@@ -1352,6 +1581,10 @@ export async function startBridge(configPath = CONFIG_PATH) {
         webHandle?.close();
         for (const r of runners)
             r.gateway.close();
+        // 常驻 CLI 子进程一并回收（优雅退出，不赖 stdio 断连兜底）
+        killAllResidentSessions();
+        // B3 受管 OpenViking 服务一并关停（embedded 模式随 LCB 生命周期；独立手动服务不受影响）
+        stopManagedServer();
         clearPidFile();
         process.exit(0);
     };