@joekytc/dsh-swarm 0.1.2 → 0.2.0

package/lib/config.d.ts

@@ -31,7 +31,7 @@ export interface KanbanConfig {
         heartbeatIntervalSeconds: number;
         /** 协议违规护栏：连续 protocol_violation 阻塞 ≥ 此值后，下次违规直接 gave_up 不再恢复。默认 2。 */
         maxProtocolViolations: number;
-        /** 评审返工护栏：pt/dt 各自最大返工次数（超限 review/gave-up + [review-final]）。默认 pt=2 dt=3。 */
+        /** 评审返工护栏：pt/dt 各自最大返工次数（超限 review/gave-up + [review-final]）。默认 pt=3 dt=3。 */
         maxReworksPerRole: {
             pt: number;
             dt: number;
@@ -50,5 +50,12 @@ export interface KanbanConfig {
         contentMaxWidth: number;
         sseHeartbeatSeconds: number;
     };
+    gates: {
+        enabled: boolean;
+        /** 单条命令超时（ms）。默认 600000（10min，vitest 冷启动余量）。到点 SIGKILL，非实际耗时。 */
+        timeoutMs: number;
+        /** 命令黑名单子串（命中即拒执行）。纵深防御：派生命令由系统从 tdd 生成，正常不触黑名单。 */
+        forbidden: string[];
+    };
 }
 export declare const Config: Schema<KanbanConfig>;

package/lib/config.js

@@ -31,7 +31,7 @@ export const Config = Schema.object({
         heartbeatIntervalSeconds: Schema.number().default(300),
         maxProtocolViolations: Schema.number().min(1).default(2),
         maxReworksPerRole: Schema.object({
-            pt: Schema.number().min(1).default(2),
+            pt: Schema.number().min(1).default(3),
             dt: Schema.number().min(1).default(3),
         }),
     }),
@@ -50,4 +50,9 @@ export const Config = Schema.object({
         contentMaxWidth: Schema.number().min(320).max(960).default(780), // 看板最大宽度 780px
         sseHeartbeatSeconds: Schema.number().min(5).default(20),
     }),
+    gates: Schema.object({
+        enabled: Schema.boolean().default(true),
+        timeoutMs: Schema.number().min(1000).default(600000),
+        forbidden: Schema.array(Schema.string()).default(['rm -rf /', 'git push']),
+    }).default({ enabled: true, timeoutMs: 600000, forbidden: ['rm -rf /', 'git push'] }),
 });

package/lib/dispatcher/agent-runner.d.ts

@@ -1,23 +1,45 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { KanbanService } from '../domain/kanban-service.js';
-import type { KanbanConfig } from '../config.js';
+import type { ConfigProvider } from '../services/config-provider.js';
+import type { Role } from '../domain/types.js';
 import type { WikiVaultClient } from '../wiki/wiki-vault-client.js';
 import type { AgentModelOptions } from './dispatcher.js';
+/** 角色组合标记（Task 2，会话10事故根因A）：setup 成功组合角色工具面后写入，live 复用前校验。 */
+interface RoleCompositionMarker {
+    role: Role;
+    taskId: string;
+}
+/** 写入角色组合标记（setup 在 installRoleTools 成功后调用；导出仅供测试直接构造标记场景）。 */
+export declare function markRoleComposition(agent: unknown, marker: RoleCompositionMarker): void;
 /** 每任务一次性角色 agent：创建/resume、上下文组装、协议违规检测。 */
 export declare class AgentRunner {
     private readonly ctx;
     private readonly kanban;
-    private readonly config;
+    private readonly configProvider;
     private readonly wiki;
     private readonly defaultModel;
-    constructor(ctx: Context, kanban: KanbanService, config: KanbanConfig, wiki: WikiVaultClient, defaultModel?: AgentModelOptions);
+    constructor(ctx: Context, kanban: KanbanService, configProvider: ConfigProvider, wiki: WikiVaultClient, defaultModel?: AgentModelOptions);
     private buildContext;
     runTask(taskId: string): Promise<void>;
-    /** RC2：resume 前先查 agents registry 同名会话是否仍 live——live 则直接复用（后续 followup 续用），
-     *  避免 block→unblock→重跑同一会话时 resume 抛 "cannot prepare session while it is live"
-     *  （对齐 VOrchestrator.getVAgent 的 live 复用逻辑）。agents.get 未实现 → 防御回退 resume。 */
+    /** RC2：resume 前先查 agents registry 同名会话是否仍 live——live 且组合标记匹配（role+taskId 一致）才复用。
+     *  Task 2（会话10事故根因A）：此前对 live agent 盲复用——GUI 打开同名会话产生的默认组合 incarnation
+     *  没有角色 preset/kanban_complete 工具面（setup 被跳过），模型只能把交付塞 kanban_comment。
+     *  现在标记缺失/不匹配时按宿主能力降级（探明结论）：
+     *  - (i) dispose 不可行：AgentHandle.dispose 仅创建者持有（dsh-agent types/index.d.ts:155-158，
+     *    "ctx.agents.get(id) still returns a bare Agent"），无从释放他人 incarnation。
+     *  - (ii) 修复可行（生产主路径）：Agent.ctx 公开（runtime-types.d.ts:72）且经它访问的 tools 注册表
+     *    可枚举/可注册（ToolRuntime.get(name, scope) 返回该 scope 可见定义；register 经 traced ctx 落到
+     *    该 agent 的 scope 层）→ 重跑 setup 幂等补挂（effort/approval/sandbox/preset/角色工具/护栏），
+     *    补挂后必须验证 kanban_complete 可见才算修复成功。kanban_complete 是所有 runner 角色
+     *    （p/w/d/pt/dt）都注册的任务工具，且全局面只读子集不含它（main-session-tools.ts:134），
+     *    故「scope 内可见 kanban_complete」⟺「该 incarnation 经我方角色 setup 组合过」。
+     *  - (iii) 兜底：工具注册表不可达（异常宿主/测试桩）→ 抛错走 failTask。错误信息刻意不含
+     *    isInfraError 关键词 → attempts+1 计入重试预算：每次重派都会撞同一个 live 错误 incarnation
+     *    直至重试预算耗尽——有界，不会形成无限重派循环（若误标 infra 则 attempts 不递增才会无限）。
+     *  agents.get 未实现 → 回退 resume（原行为不回归）。 */
     private resumeOrReuse;
     /** M3(B)：D(execute) 目标仓库在会话工作空间外时，跑 D 前询问用户是否允许。
      *  经 ctx.userQuestions（GUI 弹窗）单次询问；无询问通道或拒绝 → 返回 false（由调用方 claim+block 等待人工放行）。 */
     private requestRepoPermission;
 }
+export {};

package/lib/dispatcher/agent-runner.js

@@ -1,8 +1,10 @@
 import { SessionId } from '@deepseek-ai/dsh-session';
-import { installRoleTools, buildReadOnlyWriteGuard, buildDTWriteGuard, buildPlanWriteGuard, registerDtTaskChain, unregisterDtTaskChain } from '../roles/toolsets.js';
+import { installRoleTools, buildReadOnlyWriteGuard, buildDTWriteGuard, buildPlanWriteGuard, buildKbWriteGuard, registerDtTaskChain, unregisterDtTaskChain } from '../roles/toolsets.js';
+import { ensureLocalKbRoot } from '../wiki/local-kb.js';
+import { installCleanFsTools } from '../roles/clean-fs-tools.js';
 import { buildModelCandidates, isModelUnavailableError } from './model-candidates.js';
-import { attachSessionToWorkspace, resolveOrCreateWorkspace } from './workspace-attach.js';
 import { toolName } from './session-events.js';
+import { attachSessionToWorkspace, resolveOrCreateWorkspace } from './workspace-attach.js';
 import { isPathInside, resolveTargetRepoDir } from './target-repo.js';
 import { injectGitCredentials, resolveGitPatFromCtx } from './git-credentials.js';
 /** M3(B)：目标仓库在会话工作空间外、已 claim+block 等待用户授权且尚未建会话的任务集合（key=taskId）。
@@ -14,14 +16,31 @@ const GOAL_MODE_KEYWORDS = ['/goal', '目标模式', 'goal mode'];
 function isInfraError(err) {
     return /cannot prepare session|while it is live|timeout|ETIMEDOUT|ECONNREFUSED|ECONNRESET|socket/i.test(String(err));
 }
+/** 组合标记存储：按 Agent 实例（incarnation）键控的进程内 WeakMap。
+ *  机制取舍（探明宿主 lib 后确定，详见 task-2-report）：
+ *  - 不用 session.append('kanban/role-composition')：自定义事件类型不在宿主 KNOWN_SESSION_EVENT_TYPES
+ *    （dsh-session/lib/types/known-event-types.js），持久化读路径 assertEventsSupported
+ *    （dsh-session-persistence/lib/index.js:1117）对未标 ignorable 的未知类型整份拒绝加载
+ *    （SessionFormatUnsupportedError）→ 会话日志变成无法 resume 的毒日志；且 append 公共 API
+ *    不暴露 ignorable 信封字段，无法规避。
+ *  - 不用 agentCtx.provide：cordis 服务 store 的 isolate 键解析到根作用域
+ *    （cordis/lib/index.js provide → ctx.root[symbols.isolate][name]），多 agent 同名 provide 冲突。
+ *  - WeakMap 按 incarnation 键控：GUI 重开同名会话是新 Agent 实例 → 查不到标记 → 不盲用；
+ *    实例被回收标记随 GC 消失，无泄漏。 */
+const roleCompositions = new WeakMap();
+/** 写入角色组合标记（setup 在 installRoleTools 成功后调用；导出仅供测试直接构造标记场景）。 */
+export function markRoleComposition(agent, marker) {
+    if (agent && typeof agent === 'object')
+        roleCompositions.set(agent, marker);
+}
 /** 每任务一次性角色 agent：创建/resume、上下文组装、协议违规检测。 */
 export class AgentRunner {
     ctx;
     kanban;
-    config;
+    configProvider;
     wiki;
     defaultModel;
-    constructor(ctx, kanban, config, wiki, defaultModel) { this.ctx = ctx; this.kanban = kanban; this.config = config; this.wiki = wiki; this.defaultModel = defaultModel; }
+    constructor(ctx, kanban, configProvider, wiki, defaultModel) { this.ctx = ctx; this.kanban = kanban; this.configProvider = configProvider; this.wiki = wiki; this.defaultModel = defaultModel; }
     buildContext(task, state, resume) {
         const parts = [`# Task ${task.id}: ${task.title}`, `assignee=${task.assignee} mode=${task.mode}`];
         // Q3：权限提示仅对受限角色显示（v 无写、d/execute 全权、p/w 全权但受工具级写护栏约束——写边界不靠 prompt 软约束）
@@ -35,6 +54,20 @@ export class AgentRunner {
         if (task.body)
             parts.push(`## Body
 ${task.body}`);
+        // W local KB 模式（D7/D8）：注入本地库根 + llm-wiki 用法 + 排序原则 + 交付约定（remote 模式不注入）。
+        // 库内复制/移动补句（Task 6 评审）：DIRECT cp/mv/mkdir 工具永远匹配不到 KB 目标（无 path/file_path
+        // 实参）会被护栏拒绝——必须显式指引 W 用 write 工具做库内复制/移动。
+        if (task.assignee === 'w' && this.configProvider.mode === 'local') {
+            const kbRoot = ensureLocalKbRoot();
+            parts.push('## 知识库（本地模式）', `- 本地库根：${kbRoot}（llm-wiki 原生结构；只读仓库源码，唯一可写区域为该库根）；库内复制/移动一律用 write 工具（cp/mv 会被护栏拒绝）`, '- 经 skill 工具加载 llm-wiki 完成查写（query/ingest/crystallize）；库未初始化时先按其 init 工作流初始化（幂等）', '- 检索排序原则：相关性优先 7 : 新鲜度 3', '- 交付：page_path = 库根下 wiki/** 相对路径（如 wiki/sources/ch_<chainId>/t_<taskId>.md）；kb_url = 空串', '- 本地模式不 ingest 外部 URL；wiki_search/wiki_read/wiki_write 不可用（未注册）');
+        }
+        // D/DT local 库根注入（审查修订 M3/M4）：Task 9 d:execute local 文案称「库根见运行时上下文」，
+        // 此处必须真的注入，否则 D 不知道去哪读计划；DT fs 写评审页同理。
+        if ((task.assignee === 'd' || task.assignee === 'dt') && this.configProvider.mode === 'local') {
+            parts.push('## 本地知识库（local KB mode）', `- 本地库根：${ensureLocalKbRoot()}`, task.assignee === 'd'
+                ? '- 实施计划原文 = 父任务交接 page_path（库根下 wiki/** 相对路径）→ 直接 fs 读 <库根>/<page_path>；KB 经验召回经 skill 工具加载 llm-wiki（本地库）'
+                : '- 评审页经 fs 写 <库根>/wiki/queries/ch_<chainId>/review/<name>.md（库根外一律只读）');
+        }
         // P1-1：规格卡六段 + 附件注入（经 Chain.specCardId），角色 agent 的输入契约，原汁原味
         const chain = state.chains.get(task.chainId);
         const specCard = chain?.specCardId ? state.specCards.get(chain.specCardId) : null;
@@ -139,7 +172,7 @@ ${task.body}`);
                 sessionCwd = await resolveOrCreateWorkspace(this.ctx, null, 'task ' + task.id + ' ' + task.assignee + '/' + task.mode);
             }
             if (!sessionCwd) {
-                await this.kanban.comment(taskId, `链未绑定工作区（Chain.workspaceDir 缺失且用户未提供工作区路径）。请重新 ${this.config.prefixRoutes.plan} 绑定主 agent 工作空间后重试。`, 'system');
+                await this.kanban.comment(taskId, `链未绑定工作区（Chain.workspaceDir 缺失且用户未提供工作区路径）。请重新 ${this.configProvider.getEffective().prefixRoutes.plan} 绑定主 agent 工作空间后重试。`, 'system');
                 await this.kanban.claimTask(taskId, 'system');
                 await this.kanban.blockTask(taskId, 'workspace-unknown: 链未绑定工作区（Chain.workspaceDir 缺失）', 'system');
                 return;
@@ -174,7 +207,7 @@ ${task.body}`);
                 // 里的 reasoningEffort 不被宿主消费，新建角色会话思考等级会落回宿主默认。改走 DSH agent/request
                 // waterfall 逐请求强制（宿主 installModelSelection 同机制），作用域仅本角色会话；
                 // effort 可由 per-role config 覆盖，默认 'high'（与 model-candidates.ts 默认一致）。
-                const effort = this.config.roles?.models?.[task.assignee]?.reasoningEffort ?? 'high';
+                const effort = this.configProvider.getEffective().roles?.models?.[task.assignee]?.reasoningEffort ?? 'high';
                 const scoped = agentCtx;
                 scoped.on('agent/request', async (_payload, next) => {
                     // 异常不吞：await next() 失败原样向上抛
@@ -208,15 +241,36 @@ ${task.body}`);
                         }
                     }
                 }
-                await installRoleTools(agentCtx, task.assignee, { kanban: this.kanban, wiki: this.wiki, taskId: task.id });
+                await installRoleTools(agentCtx, task.assignee, { kanban: this.kanban, wiki: this.wiki, taskId: task.id, kbMode: this.configProvider.mode });
+                // sandbox-menu-align Task 1：danger-full-access 会话（P、D(execute)）write/edit/bash 菜单去毒
+                // （agent scope shadow 注册干净版盖住宿主带毒版本 + execute 剥参转发，详见 src/roles/clean-fs-tools.ts）。
+                // 挂载点选在 setup 内、preset.mount 之后：shadow 需经 get(name, agent) 取 preset standing
+                // 祖先层里的宿主原定义（kanban-p/d 的 fs/bash 由 preset 提供），且必须在会话开始前完成注册。
+                // 仅 P 与 D(execute)：两者是 danger-full-access 天花板，escalation 参数无更宽可升（必被拒）；
+                // PT/DT 是 workspace-write（sandbox_permissions 扩权到天花板是合法功能，剥了破坏官方能力）；
+                // W 虽 fullAccess 但 I2 只读护栏全拒 write，shadow 无意义（最小挂载面，V 无执行工具不涉及）。
+                if (task.assignee === 'p' || isDExecute) {
+                    installCleanFsTools(agentCtx, agentCtx.agent);
+                }
+                // Task 2：组合标记——角色工具面成功组合后，把 { role, taskId } 记到进程内 WeakMap（键=Agent 实例）。
+                // 宿主探明：setup 收到的 agentCtx.agent 与发布后 agents.get(id) 返回的是同一 Agent 实例
+                // （dsh-agent types/index.d.ts:38 `agent?: Agent` 安装为 Agent.ctx own property），
+                // 故此处键入的实例即 resumeOrReuse 里 agents.get 命中的实例。agentCtx.agent 缺失（宿主变体）时
+                // 不写标记 → live 复用走工具面校验路径（kanban_complete 可见性），能力无损。
+                const liveAgent = agentCtx.agent;
+                if (liveAgent)
+                    markRoleComposition(liveAgent, { role: task.assignee, taskId: task.id });
                 // 只读评审角色（PT/DT）注册 ToolGuard：拦截 tracked source 写入 / git mutation / 含写标记 bash。
                 // 以 dsh-tools 类型为准：tools.guard(execution => reason|undefined)，execution.name/arguments 为实际字段。
                 if (task.assignee === 'pt' || task.assignee === 'dt') {
                     const repoRoot = dRepo ?? sessionCwd; // DT 评审目标仓库；PT 以会话工作区为只读边界
                     const toolsSvc = agentCtx.tools;
-                    // DT 额外叠加 wiki review namespace 收窄（projects/<chain>/review/）
+                    // DT 额外叠加 wiki review namespace 收窄（projects/<repoSlug>/<chain>/review/）；
+                    // local KB 模式（D7）：DT 改用 KB 写护栏（唯一可写区域=本地库根，评审页经 fs 写库根），
+                    // remote 模式仍用 DT 收窄护栏（库根外全只读 + review namespace）。
+                    const kbMode = this.configProvider.mode;
                     const guardFn = task.assignee === 'dt'
-                        ? buildDTWriteGuard(repoRoot, task.chainId)
+                        ? (kbMode === 'local' ? buildKbWriteGuard(ensureLocalKbRoot()) : buildDTWriteGuard(repoRoot, task.chainId))
                         : buildReadOnlyWriteGuard(repoRoot);
                     toolsSvc?.guard?.((e) => guardFn(e));
                 }
@@ -226,9 +280,14 @@ ${task.body}`);
                 // 挂载方式同 PT/DT：tools.guard 是注册方法（dsh-tools 类型），execution 以 { name, arguments } 传入。
                 if (task.assignee === 'p' || task.assignee === 'w') {
                     const toolsSvc = agentCtx.tools;
+                    // local KB 模式（D7）：W 改用 KB 写护栏（唯一可写区域=本地库根，交付页经 write 写库根），
+                    // remote 模式 W 仍只读护栏（fs 零写）；P 恒为 plan 写护栏（与 KB 模式无关）。
+                    const kbMode = this.configProvider.mode;
                     const guardFn = task.assignee === 'p'
                         ? buildPlanWriteGuard(sessionCwd)
-                        : buildReadOnlyWriteGuard(sessionCwd);
+                        : (kbMode === 'local' && task.assignee === 'w')
+                            ? buildKbWriteGuard(ensureLocalKbRoot())
+                            : buildReadOnlyWriteGuard(sessionCwd);
                     toolsSvc?.guard?.((e) => guardFn(e));
                 }
                 // M4：D(execute) 注入 git 凭据（repo-local http extraheader，GitLab glpat-* 用 oauth2 basic）。
@@ -253,11 +312,11 @@ ${task.body}`);
                 context = this.buildContext(task, state, hasRunHistory);
                 // 模型候选链（Task 12）：primary + fallbacks，model/provider 不可用时静默切换下一候选；
                 // 全部候选不可用 → block(model-unavailable) 抛给用户；非 model 错误 → failTask（原逻辑）。
-                const candidates = buildModelCandidates(this.config, task.assignee, this.defaultModel);
+                const candidates = buildModelCandidates(this.configProvider.getEffective(), task.assignee, this.defaultModel);
                 if (candidates.length === 0) {
                     // 无任何候选配置：不传 agentOptions（用部署默认），单次尝试
                     agent = hasRunHistory
-                        ? await this.resumeOrReuse(this.ctx.get('agents'), task.resumeSessionId ?? `kbn-${taskId}`, { setup })
+                        ? await this.resumeOrReuse(this.ctx.get('agents'), task.resumeSessionId ?? `kbn-${taskId}`, { setup, role: task.assignee, taskId: task.id })
                         : (await this.ctx.get('agents').create({
                             sessionId: SessionId(`kbn-${taskId}`),
                             meta: { cwd: sessionCwd },
@@ -272,7 +331,7 @@ ${task.body}`);
                             // hasRunHistory → resumeOrReuse 直接返回 AgentLike（内部已解包 .agent）；create 返回 { agent } 需解包。
                             // 统一归一化为 AgentLike，避免二次解包（h.agent=undefined → if(!agent) 误标 failed）。
                             const h = hasRunHistory
-                                ? await this.resumeOrReuse(agents, task.resumeSessionId ?? `kbn-${taskId}`, { agentOptions: candidate, setup })
+                                ? await this.resumeOrReuse(agents, task.resumeSessionId ?? `kbn-${taskId}`, { agentOptions: candidate, setup, role: task.assignee, taskId: task.id })
                                 : (await agents.create({ sessionId: SessionId(`kbn-${taskId}`), meta: { cwd: sessionCwd }, agentOptions: candidate, setup })).agent;
                             agent = h;
                             // 切换成功且非首选 → 发可审计 model/fallback 评论（记录证据，不弹用户）
@@ -315,6 +374,11 @@ ${task.body}`);
             }
             if (!agent)
                 return; // 防御：候选链耗尽已在上方 block(model-unavailable)/throw 处理
+            // Task 4（Bug C 告警）：本轮增量事件基线——agent 拿到之后、followup 之前记录。
+            // 0.1.2（DSH-0.1.2-A4-03）：Session.events 已移除 → followup 前记录 seq 基线，
+            // snapshotEvents(eventsBase) 即「本轮新增事件」（排除旧 incarnation 持久化事件），
+            // 供 protocol_violation 时识别 comment-only 收尾（交付滞留 comments，会话10事故形态）。
+            const eventsBase = Number(agent.session.seq);
             // 归组：角色会话 attach 到 cwd 对应工作区（无则询问创建；失败不阻断）
             const attachId = task.resumeSessionId ?? `kbn-${task.id}`;
             await attachSessionToWorkspace(this.ctx, attachId, sessionCwd, 'task ' + task.id + ' ' + task.assignee + '/' + task.mode);
@@ -323,50 +387,57 @@ ${task.body}`);
                 console.error('[dsh-swarm][debug] runner followup sent ' + taskId);
                 await agent.whenIdle();
                 console.error('[dsh-swarm][debug] runner whenIdle resolved ' + taskId);
-                // 修复轮 6：session.events 条目形态为 {type, data:{name}}，name 在 data 下，需经 toolName 读取
-                const used = agent.session.events.some((e) => {
-                    const n = toolName(e);
-                    return n === 'kanban_complete' || n === 'kanban_block';
-                });
-                if (!used) {
-                    // 防御：任务可能已被其他路径完成/归档（终态），此时 blockTask 会抛非法转换（done --task/blocked-->）
-                    const fresh = await this.kanban.snapshot();
-                    const cur = fresh.tasks.get(taskId);
-                    const terminal = cur && (cur.status === 'done' || cur.status === 'archived');
-                    if (terminal) {
-                        console.error('[dsh-swarm][debug] runner skip block ' + taskId + ' status=' + (cur ? cur.status : 'gone'));
+                // 终态判据（session 10 事故修复）：whenIdle resolve 后一次 snapshot，只看任务真实状态——
+                // 不再扫 session.events 全历史工具名（旧 incarnation 的 kanban_* 事件会污染判据，
+                // 「历史上调过工具名」≠「本轮成功提交」，骗过检查后卡永驻 running）。
+                // 确定态（done/archived/blocked/failed，TaskStatus 全集见 src/domain/types.ts）→ 防御日志 skip：
+                // blocked 上再 block 抛非法转换；failed 交调度器重派，不做 violation block。
+                // 非确定态（running/ready/todo/triage）→ protocol_violation 流程（证据链保留）。
+                const fresh = await this.kanban.snapshot();
+                const cur = fresh.tasks.get(taskId);
+                const settled = !!cur &&
+                    (cur.status === 'done' || cur.status === 'archived' || cur.status === 'blocked' || cur.status === 'failed');
+                if (settled) {
+                    console.error('[dsh-swarm][debug] runner skip block ' + taskId + ' status=' + (cur ? cur.status : 'gone'));
+                }
+                else {
+                    // 协议违规护栏：连续 protocol_violation 阻塞 ≥ maxProtocolViolations（默认 2）后，
+                    // 下一次违规直接 gave_up（不再恢复，走 [blocked-final] 证据链抛给主 agent）。任意角色（含 pt/dt）统一。
+                    const maxPV = this.configProvider.getEffective().dispatcher?.maxProtocolViolations ?? 2;
+                    const priorViolations = fresh.events.filter((e) => e.taskId === taskId && e.kind === 'task/blocked' &&
+                        String(e.payload['reason'] ?? '').startsWith('protocol_violation')).length;
+                    const finalBlock = priorViolations >= maxPV;
+                    const reason = finalBlock
+                        ? 'gave_up: protocol_violation after ' + maxPV + ' review cycles without complete/block'
+                        : 'protocol_violation: idle without complete/block';
+                    await this.kanban.blockTask(taskId, reason, 'system');
+                    // Task 4（Bug C 告警）：comment-only 收尾显形——放 block 之后（保证 block 一定先发生，
+                    // 告警只追加在已阻塞卡上，不影响终态判据与 [blocked-final] 证据链快照）。
+                    // 本轮增量事件命中 kanban_comment（经 toolName 兼容读取落盘/live 两形态）且未成功提交
+                    // （能走到这里即终态判据已确认非确定态）→ 交付内容很可能滞留 comments，显形告警。
+                    const commentOnly = agent.session.snapshotEvents(eventsBase).some((e) => toolName(e) === 'kanban_comment');
+                    if (commentOnly) {
+                        await this.kanban.comment(taskId, '[comment-only-closeout] 本轮仅用 kanban_comment 交付（无 complete/block）。交付内容可能滞留 comments（如角色工具缺失/会话被错误复用）；请人工核对 comments 与产物后解除阻塞重派。', 'system');
                     }
-                    else {
-                        // 协议违规护栏：连续 protocol_violation 阻塞 ≥ maxProtocolViolations（默认 2）后，
-                        // 下一次违规直接 gave_up（不再恢复，走 [blocked-final] 证据链抛给主 agent）。任意角色（含 pt/dt）统一。
-                        const maxPV = this.config.dispatcher?.maxProtocolViolations ?? 2;
-                        const priorViolations = fresh.events.filter((e) => e.taskId === taskId && e.kind === 'task/blocked' &&
-                            String(e.payload['reason'] ?? '').startsWith('protocol_violation')).length;
-                        const finalBlock = priorViolations >= maxPV;
-                        const reason = finalBlock
-                            ? 'gave_up: protocol_violation after ' + maxPV + ' review cycles without complete/block'
-                            : 'protocol_violation: idle without complete/block';
-                        await this.kanban.blockTask(taskId, reason, 'system');
-                        if (finalBlock) {
-                            // [blocked-final] 证据链：block 时间线 + 复核/评论时间线 + 最终 reason（system 确定性写入）
-                            const evs = fresh.events.filter((e) => e.taskId === taskId);
-                            const blockTimeline = evs
-                                .filter((e) => e.kind === 'task/blocked')
-                                .map((e) => `  - seq=${e.seq} at=${e.at} author=${e.author} reason=${String(e.payload['reason'] ?? '')}`)
-                                .join('\n');
-                            const reviewTimeline = evs
-                                .filter((e) => e.kind === 'task/commented')
-                                .map((e) => `  - seq=${e.seq} at=${e.at} author=${e.author}: ${String(e.payload['body'] ?? '')}`)
-                                .join('\n');
-                            await this.kanban.comment(taskId, [
-                                '[blocked-final] 协议违规超护栏，任务不再自动恢复（人工解除后仍按 gave_up 终态处理）。',
-                                '## block 时间线',
-                                blockTimeline,
-                                '## 复核/评论时间线',
-                                reviewTimeline || '  - (无复核评论)',
-                                '最终原因: ' + reason,
-                            ].join('\n'), 'system');
-                        }
+                    if (finalBlock) {
+                        // [blocked-final] 证据链：block 时间线 + 复核/评论时间线 + 最终 reason（system 确定性写入）
+                        const evs = fresh.events.filter((e) => e.taskId === taskId);
+                        const blockTimeline = evs
+                            .filter((e) => e.kind === 'task/blocked')
+                            .map((e) => `  - seq=${e.seq} at=${e.at} author=${e.author} reason=${String(e.payload['reason'] ?? '')}`)
+                            .join('\n');
+                        const reviewTimeline = evs
+                            .filter((e) => e.kind === 'task/commented')
+                            .map((e) => `  - seq=${e.seq} at=${e.at} author=${e.author}: ${String(e.payload['body'] ?? '')}`)
+                            .join('\n');
+                        await this.kanban.comment(taskId, [
+                            '[blocked-final] 协议违规超护栏，任务不再自动恢复（人工解除后仍按 gave_up 终态处理）。',
+                            '## block 时间线',
+                            blockTimeline,
+                            '## 复核/评论时间线',
+                            reviewTimeline || '  - (无复核评论)',
+                            '最终原因: ' + reason,
+                        ].join('\n'), 'system');
                     }
                 }
             }
@@ -387,14 +458,56 @@ ${task.body}`);
                 unregisterDtTaskChain(task.id);
         }
     }
-    /** RC2：resume 前先查 agents registry 同名会话是否仍 live——live 则直接复用（后续 followup 续用），
-     *  避免 block→unblock→重跑同一会话时 resume 抛 "cannot prepare session while it is live"
-     *  （对齐 VOrchestrator.getVAgent 的 live 复用逻辑）。agents.get 未实现 → 防御回退 resume。 */
+    /** RC2：resume 前先查 agents registry 同名会话是否仍 live——live 且组合标记匹配（role+taskId 一致）才复用。
+     *  Task 2（会话10事故根因A）：此前对 live agent 盲复用——GUI 打开同名会话产生的默认组合 incarnation
+     *  没有角色 preset/kanban_complete 工具面（setup 被跳过），模型只能把交付塞 kanban_comment。
+     *  现在标记缺失/不匹配时按宿主能力降级（探明结论）：
+     *  - (i) dispose 不可行：AgentHandle.dispose 仅创建者持有（dsh-agent types/index.d.ts:155-158，
+     *    "ctx.agents.get(id) still returns a bare Agent"），无从释放他人 incarnation。
+     *  - (ii) 修复可行（生产主路径）：Agent.ctx 公开（runtime-types.d.ts:72）且经它访问的 tools 注册表
+     *    可枚举/可注册（ToolRuntime.get(name, scope) 返回该 scope 可见定义；register 经 traced ctx 落到
+     *    该 agent 的 scope 层）→ 重跑 setup 幂等补挂（effort/approval/sandbox/preset/角色工具/护栏），
+     *    补挂后必须验证 kanban_complete 可见才算修复成功。kanban_complete 是所有 runner 角色
+     *    （p/w/d/pt/dt）都注册的任务工具，且全局面只读子集不含它（main-session-tools.ts:134），
+     *    故「scope 内可见 kanban_complete」⟺「该 incarnation 经我方角色 setup 组合过」。
+     *  - (iii) 兜底：工具注册表不可达（异常宿主/测试桩）→ 抛错走 failTask。错误信息刻意不含
+     *    isInfraError 关键词 → attempts+1 计入重试预算：每次重派都会撞同一个 live 错误 incarnation
+     *    直至重试预算耗尽——有界，不会形成无限重派循环（若误标 infra 则 attempts 不递增才会无限）。
+     *  agents.get 未实现 → 回退 resume（原行为不回归）。 */
     async resumeOrReuse(agents, sessionId, opts) {
         const live = agents.get?.(sessionId);
-        if (live)
-            return live;
-        const h = await agents.resume({ resumeSessionId: SessionId(sessionId), ...opts });
+        if (live) {
+            // 标记匹配（同 incarnation、同角色、同卡）→ 与 setup 组合完全一致 → 安全复用（原行为收窄版）
+            const marker = typeof live === 'object' && live !== null ? roleCompositions.get(live) : undefined;
+            if (marker && marker.role === opts.role && marker.taskId === opts.taskId)
+                return live;
+            // 标记缺失/不匹配 → 绝不盲用。工具注册表（live.ctx.tools，与 installRoleTools 同一访问路径）：
+            const liveCtx = live.ctx;
+            const toolsSvc = liveCtx ? liveCtx.tools : undefined;
+            if (toolsSvc?.get) {
+                if (toolsSvc.get('kanban_complete', live)) {
+                    // 工具面完备但标记缺失/不匹配：标记写入失败的历史 incarnation，或旧/手工数据把
+                    // resumeSessionId 指向同角色其它卡（注：2026-09-07 起 createReworkTask 不再继承源卡
+                    // resumeSessionId——返工卡走自己的 kbn-<id> 会话，此「跨卡复用」分支为 dead path 防御）——
+                    // 验证过工具面后复用，不重复补挂（重复 register 同名工具会被 dsh-tools 拒绝）。
+                    return live;
+                }
+                // GUI 默认组合 incarnation：缺 kanban_complete → 重跑 setup 幂等补挂后复用。
+                // setup 对 live ctx 的各步均可加：effort waterfall/approval+sandbox append（known 事件类型、
+                // latest-wins）/preset mount（bindings 覆盖）/角色工具（此前为默认组合，无同名冲突）/护栏。
+                await opts.setup(liveCtx);
+                if (toolsSvc.get('kanban_complete', live))
+                    return live; // 修复后必须验证到位，防静默半修复
+                throw new Error('live session composition repair failed: kanban_complete still missing after re-setup (session ' + sessionId + ')');
+            }
+            // (iii)：既无标记又无法访问工具注册表 → 拒绝盲复用（会复现事故），failTask 有界重试（见上）。
+            throw new Error('live session composition mismatch and unverifiable (no marker, no tool registry): ' + sessionId + ' — refusing blind reuse (incident root cause A)');
+        }
+        const { agentOptions, setup } = opts;
+        const resumeOpts = { resumeSessionId: SessionId(sessionId), setup };
+        if (agentOptions)
+            resumeOpts['agentOptions'] = agentOptions;
+        const h = await agents.resume(resumeOpts);
         return h.agent;
     }
     /** M3(B)：D(execute) 目标仓库在会话工作空间外时，跑 D 前询问用户是否允许。

package/lib/dispatcher/chain-auditor.js

@@ -159,7 +159,10 @@ export class ChainAuditor {
             if (workspaceDir && agent.session?.header?.cwd && !isPathInside(agent.session.header.cwd, workspaceDir)) {
                 continue;
             }
-            const hit = sessionWriteEvidence(String(agent.id), this.workspacesRoot, agent.session?.events ?? []);
+            // 0.1.2（DSH-0.1.2-A4-03）：Session.events 移除 → snapshotEvents() 优先，回退 events（旧宿主/测试）
+            const ses = agent.session;
+            const sessionEvents = ses?.snapshotEvents?.() ?? ses?.events ?? [];
+            const hit = sessionWriteEvidence(String(agent.id), this.workspacesRoot, sessionEvents);
             if (hit)
                 evidence.push(hit);
         }

package/lib/dispatcher/dispatcher.d.ts

@@ -1,8 +1,9 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { KanbanConfig } from '../config.js';
+import type { ConfigProvider } from '../services/config-provider.js';
 import { EventWaker } from './event-waker.js';
 import { Watchdog } from './watchdog.js';
 import type { KanbanService } from '../domain/kanban-service.js';
+import type { Task } from '../domain/types.js';
 export interface AgentModelOptions {
     provider: string;
     model: string;
@@ -22,7 +23,26 @@ export interface DispatcherDeps {
     stateFile: string;
     /** 修复轮 6：调度器运行日志文件（storageDir/dispatcher.log）。 */
     logFile: string;
+    /** Fix round 1：宿主 agents 注册表（ctx.get('agents')）——启动 reconcile 判别 kbn-<taskId>
+     *  会话是否仍 live（插件热重载豁免）；缺省/无 get 方法时按原行为收敛（保守）。 */
+    agents?: unknown;
+    /** 防线①：链级停滞探针（生产传 VOrchestrator；测试传桩）。缺省=看门狗关闭（行为同旧）。 */
+    stallProbe?: {
+        orchestrationOf(chainId: string): {
+            phase: string;
+        } | null;
+        isWakeInFlight(chainId: string): boolean;
+        wake(chainId: string): Promise<void>;
+    };
 }
+/** wakeImpl 装配（防线②，2026-09-04 mtmgp81q 死法教训）：wakeV 异常必须落盘 dispatcher.log——
+ *  原实现仅 console.error，无控制台运行时零痕迹（排障最大障碍）。吞异常是为防 withTimeout
+ *  超时后迟到的 rejection 变 unhandledRejection；onSettled（saveOrchs）无论成败都执行。 */
+export declare function makeWakeImpl(wakeV: (chainId: string) => Promise<void>, logFile: string, onSettled: () => void): (chainId: string) => Promise<void>;
+/** 防线①：链级进度看门狗阈值。tick=2000ms × 45 ticks = 90s 无进展即重唤醒（grill Q2 决议）。 */
+export declare const STALL_WATCHDOG_TICKS = 45;
+/** 防线①：链级重唤醒上限（grill Q3 决议：超限 [create-failed] + chain/blocked）。 */
+export declare const STALL_WATCHDOG_REWAKE_LIMIT = 3;
 /** 调度器：事件唤醒 V（R20 逐阶段建卡）+ 每任务一次性角色 agent + 心跳看门狗。
  *  - B1：failed 且 attempts<maxRetries 的任务重派（claim→running，AgentRunner resume 同一会话）；
  *        attempts≥maxRetries 熔断 blocked(gave_up)。
@@ -36,15 +56,54 @@ export declare class Dispatcher {
     private readonly maxRetries;
     private readonly stateFile;
     private readonly logFile;
+    private readonly agents;
+    private readonly stallProbe;
     private lastSeq;
+    private orphanReconciled;
     private inFlight;
+    private stallState;
     private timer;
     constructor(deps: DispatcherDeps);
     private ensureLastSeq;
     tick(): Promise<void>;
+    /** 防线①：链级进度看门狗（与 wakeVInner 内建 stall 互补，后者挂在 wakeVInner 内部，
+     *  异常退出/挂起/未触发时失效——2026-09-04 mtmgp81q）。只看最终事实：
+     *  executing 非 summary + 链上零非终态任务卡 + 无在途唤醒 + 本链无新看板事件，
+     *  持续 STALL_WATCHDOG_TICKS 个 tick → 重唤醒（≤STALL_WATCHDOG_REWAKE_LIMIT 次）→
+     *  仍停滞 → [create-failed] 评论（有锚点卡时）+ blockChain 终态（人工恢复=删链重跑）。 */
+    private chainStallWatchdog;
     start(intervalMs: number): void;
+    /** 整链硬删除联动（E）：purge 物理重排 events.jsonl seq，游标必须同步钳到当前 maxSeq。
+     *  否则删链后新建链的可唤醒事件（seq < 旧内存游标）被运行中实例永久跳过——A1 仅在启动时自愈，
+     *  覆盖不了运行中删链场景（2026-09-02 残留审计结论）。 */
+    onPurge(): Promise<void>;
     stop(): void;
 }
 /** 调度层装配：事件唤醒 V（R20 逐阶段建卡）+ 每任务一次性角色 agent + 心跳看门狗。
- *  仅在 agents 与 kanban 服务同时可用时由插件入口调用（不依赖可能已错过的 ready 事件）。 */
-export declare function startDispatcher(ctx: Context, config: KanbanConfig): void;
+ *  仅在 agents 与 kanban 服务同时可用时由插件入口调用（不依赖可能已错过的 ready 事件）。
+ *  Task 7：收 ConfigProvider——storageDir 取启动时快照；wiki/模型链经 getEffective() 调用时热读取。 */
+/** 启动 reconcile（F）：剔除事件流中已不存在的链的编排 entry（历史残留/外部 purge）。
+ *  原地删除并返回被移除的 chainId 列表（调用方负责持久化与日志）。 */
+export declare function reconcileOrchestrations<T>(orch: Map<string, T>, chains: Set<string>): string[];
+/** 启动 reconcile（G）：进程重启会杀死 runner 的 whenIdle 协程，上次遗留的 running 卡无人收尾，
+ *  看门狗默认 4h（staleTimeoutSeconds=14400）才回收——重启后立即把 running 孤儿卡收敛为 blocked
+ *  （system comment + blockTask），中断显形且可重派续跑（重派将 resume 同一会话，进度保留）。
+ *  状态机注：TaskStatus 无独立 'claimed' 态——claimTask 发 task/claimed 事件后投影即为 running，
+ *  扫描 running 即覆盖「claimed 未收尾」；todo/ready/triage 从未派发，done/blocked/failed/archived
+ *  已有归属或终态（且 failed 的处置归 B1 重派/熔断管辖），均不动。
+ *  Fix round 1（热重载兼容，双重判据）：收敛每张 running 卡前先查宿主 agents 注册表
+ *  ctx.get('agents').get('kbn-<taskId>')（session id 构造同 AgentRunner.resumeOrReuse，Task 2 同款探明）。
+ *  两个世界的分野：
+ *  - 进程重启：agents 注册表随宿主进程消亡，新进程内 kbn-<taskId> 必然查不到（undefined）
+ *    → 会话已死 → 全部收敛，语义与修复前一致；
+ *  - 插件热重载：宿主进程未死，dsh 插件重载重跑 startDispatcherInner → orphanReconciled 闸复位，
+ *    但宿主 agent 会话仍 live（注册表命中）→ 本进程真在跑，不是孤儿 → 跳过该卡，
+ *    避免把合法 running 卡误收敛为 blocked。
+ *  agents 服务缺失 / 无 get 方法（测试桩/异常宿主）→ 无法证明 live，按原行为收敛（保守）。
+ *  调用位置必须在游标自愈（ensureLastSeq）之后、事件消费之前：游标 rewind 会全量重放旧事件，
+ *  先收敛孤儿可保证本次 tick 消费的重放事件面对的是已收敛状态，且孤儿产生的 block 事件天然
+ *  落在本轮快照之外（下一轮才被消费唤醒 V 走阻塞复核），不与启动重放交错。
+ *  幂等：仅启动执行一次（调用方置闸）；对同一卡重复调用时状态机拒绝 running→blocked 之外的
+ *  非法转换，comment/block 失败均 try/catch 记日志跳过不抛（单卡失败不阻断其余收敛）。 */
+export declare function reconcileOrphanRunningTasks(kanban: KanbanService, tasks: Iterable<Task>, logFile: string, agents?: unknown): Promise<string[]>;
+export declare function startDispatcher(ctx: Context, configProvider: ConfigProvider): void;