@joekytc/dsh-swarm 0.3.6 → 0.3.8

package/lib/domain/kanban-service.js

@@ -51,6 +51,9 @@ function reworkChecklistSection(issues) {
     }
     return lines.join('\n');
 }
+/** 同一任务实测闸打回上限（累计计数）：超过后 blockTask 转人工。
+ * gate fail 不走 failTask、attempts 不递增（仅会话死亡路径 +1），故按 gate-failed 事件数自建计数。 */
+export const MAX_GATE_BOUNCES = 3;
 /** 看板领域门面：三界面（工具/CLI/UI）统一路由的唯一入口。 */
 export class KanbanService {
     state;
@@ -65,9 +68,13 @@ export class KanbanService {
     // W2/W3 完成互链登记钩子（dispatcher 注入：拿 page_path → 机械写三方互链，失败不阻塞完成）
     onTaskCompletedHook = null;
     // 实测闸钩子（装配层注入：gate-policy 派生 + gate-runner 实测执行 + 分支核对）。
-    // null=未启用（行为不变）；hook 返回 null=跳过（零感知，无 gate 事件）。
+    // 三态（PR1 互证）：null=不适用（静默零事件，行为不变）；{skipped,reason}=警报放行；
+    // {ok,detail}=真跑（ok=false → gate-failed + throw 打回，同会话修复重交）。
     // **无 actor 参数——human 无豁免**（2026-09-02 决议收紧）。
     gateHook = null;
+    // 评审证据核验钩子（PR2，非阻塞）：仅 DT 卡 complete 时调用，结果只发 review/evidence-check 事件留痕
+    // （differs/could-not-replay 不阻塞 complete、不改 verdict——转人工信号走事件流）。
+    evidenceCheckHook = null;
     constructor(store, getKbUrlBase) {
         this.store = store;
         this.getKbUrlBase = getKbUrlBase ?? null;
@@ -99,6 +106,10 @@ export class KanbanService {
     setGateHook(hook) {
         this.gateHook = hook;
     }
+    /** 注入评审证据核验钩子（PR2；null=关闭，行为与旧版一致）。 */
+    setEvidenceCheckHook(hook) {
+        this.evidenceCheckHook = hook;
+    }
     /** 订阅持久化后的看板事件；返回解除订阅函数。listener 异常不影响已落盘状态。 */
     subscribe(listener) {
         this.listeners.add(listener);
@@ -272,15 +283,42 @@ export class KanbanService {
         // v2 断代：w:file 交付键随旧 w1 预取阶段移除，manifest 校验块同步删除
         // （validatePrefetchManifest 仍保留于 prefetch-manifest.ts，供清单 schema 校验复用）。
         // 实测闸：hook 由装配层注入（gate-policy 派生 + gate-runner 实测执行 + 分支核对），
-        // hook 返回 null=跳过（未启用/非 D/旧卡/分支不一致）。**无 human 豁免**（2026-09-02 决议收紧）；
-        // ok=false → gate-failed 事件 + 拒绝 complete（卡留 running，throw 经工具边界回 D 会话）。
+        // 三态语义见 GateHookVerdict。**无 human 豁免**（2026-09-02 决议收紧）；
+        // ok=false → gate-failed 事件 + 拒绝 complete（卡留 running，throw 经工具边界回 D 会话）；
+        // 累计打回 ≥MAX_GATE_BOUNCES → blockTask 转人工（防同会话无限循环；人工 unblock 不重置计数——语义取舍见台账）。
         if (this.gateHook) {
             const verdict = await this.gateHook(t, handoff);
             if (verdict !== null) {
-                await this.emit({ chainId: t.chainId, taskId, kind: verdict.ok ? 'task/gate-passed' : 'task/gate-failed',
-                    payload: { detail: verdict.detail }, author: 'system', at: Date.now() });
-                if (!verdict.ok)
-                    throw new Error('gate failed: ' + verdict.detail);
+                if ('skipped' in verdict) {
+                    // 警报放行：留痕后照常 completed（④ 诚实纯文档场景不被打扰，谎报由 DT/人工下游兜底）
+                    await this.emit({ chainId: t.chainId, taskId, kind: 'task/gate-skipped', payload: { reason: verdict.reason }, author: 'system', at: Date.now() });
+                }
+                else {
+                    await this.emit({ chainId: t.chainId, taskId, kind: verdict.ok ? 'task/gate-passed' : 'task/gate-failed',
+                        payload: { detail: verdict.detail }, author: 'system', at: Date.now() });
+                    if (!verdict.ok) {
+                        const bounces = this.state.events.filter((e) => e.taskId === taskId && e.kind === 'task/gate-failed').length;
+                        const escalated = bounces >= MAX_GATE_BOUNCES;
+                        if (escalated) {
+                            await this.blockTask(taskId, `gave_up: gate bounced ${bounces} times — 转人工核对`, 'system');
+                        }
+                        // throw 文案区分升级态（评审 Minor）：blocked 后 D 会话不应误以为还能重试
+                        throw new Error('gate failed' + (escalated ? '（已转人工核对，请勿盲目重试）' : '') + ': ' + verdict.detail);
+                    }
+                }
+            }
+        }
+        // PR2 评审证据核验（非阻塞，仅 DT）：结果发 review/evidence-check 汇总事件（先于 completed）。
+        // hook 异常不阻断 complete；differs/could-not-replay 不改 verdict——转人工信号走事件流。
+        if (this.evidenceCheckHook && t.assignee === 'dt') {
+            try {
+                const summary = await this.evidenceCheckHook(t, handoff);
+                if (summary && summary.results.length > 0) {
+                    await this.emit({ chainId: t.chainId, taskId, kind: 'review/evidence-check', payload: { results: summary.results }, author: 'system', at: Date.now() });
+                }
+            }
+            catch (error) {
+                console.error('[dsh-swarm] evidence check failed (non-blocking): ' + String(error));
             }
         }
         await this.emit({ chainId: t.chainId, taskId, kind: 'task/completed', payload: { ...handoff }, author: actor, at: Date.now() });

package/lib/domain/review-evidence.js

@@ -45,7 +45,9 @@ export function validateReviewEvidence(role, handoff) {
         const tcOk = ev.typecheck && typeof ev.typecheck === 'object';
         if (!buildOk && !tcOk)
             missing.push('review_evidence.build/typecheck');
-        if (ev.lint === undefined)
+        // PR1 对齐 build 口径（上方 buildOk/typecheckOk）：lint 必须为结构化对象；null/字符串/数字拒收（lint:null 曾溜闸）。
+        const lintOk = ev.lint && typeof ev.lint === 'object';
+        if (!lintOk)
             missing.push('review_evidence.lint');
         const diffOk = ev.diff && typeof ev.diff === 'object' && Object.keys(ev.diff).length > 0;
         if (!diffOk)

package/lib/domain/types.d.ts

@@ -22,6 +22,12 @@ export interface ReviewIssue {
     fix?: string;
     /** 对账标记：true=上一轮遗留 issue 的对账条目；false/缺省=本轮新问题。收敛闸据此判定旧账是否清零（漏标=false=视为新问题，方向安全）。 */
     legacy?: boolean;
+    /** 重放取证（PR2，可选）：评审者声称跑过的命令 + 原始输出存档（绝对路径，首行 [exit code: N]）+ 声明退出码。 */
+    evidence?: {
+        file: string;
+        command: string;
+        exit: number;
+    };
 }
 /** TDD 硬要求证据（评审时收集的测试相关元信息）。 */
 export interface TddEvidence {
@@ -53,7 +59,7 @@ export interface ReviewEvidence {
         kbUrl: string;
     };
 }
-export type EventKind = 'chain/created' | 'chain/executing' | 'chain/completed' | 'chain/aborted' | 'chain/blocked' | 'chain/root-task-set' | 'chain/audit-warning' | 'chain/audit-confirmed' | 'chain/title-updated' | 'chain/im-delivery-failed' | 'spec-card/created' | 'spec-card/edited' | 'spec-card/approved' | 'task/created' | 'task/claimed' | 'task/heartbeat' | 'task/commented' | 'task/completed' | 'task/blocked' | 'task/unblocked' | 'task/archived' | 'task/gate-passed' | 'task/gate-failed' | 'task/failed' | 'task/renamed' | 'review/passed' | 'review/failed' | 'review/gave-up' | 'review/waived' | 'chain/reopened';
+export type EventKind = 'chain/created' | 'chain/executing' | 'chain/completed' | 'chain/aborted' | 'chain/blocked' | 'chain/root-task-set' | 'chain/audit-warning' | 'chain/audit-confirmed' | 'chain/title-updated' | 'chain/im-delivery-failed' | 'spec-card/created' | 'spec-card/edited' | 'spec-card/approved' | 'task/created' | 'task/claimed' | 'task/heartbeat' | 'task/commented' | 'task/completed' | 'task/blocked' | 'task/unblocked' | 'task/archived' | 'task/gate-passed' | 'task/gate-failed' | 'task/gate-skipped' | 'task/failed' | 'task/renamed' | 'review/passed' | 'review/failed' | 'review/gave-up' | 'review/waived' | 'review/evidence-check' | 'chain/reopened';
 export interface SpecCardSections {
     problem: string;
     solution: string;

package/lib/roles/toolsets.d.ts

@@ -54,33 +54,40 @@ export declare function unregisterDtTaskChain(taskId: string): void;
 export interface SubagentGuardDeps {
     /** kbn-<taskId> → chainId 同步解析（缺省用 module 缓存；测试注入用）。 */
     getTaskChainId?(taskId: string): string | undefined;
+    /** 会话 preset 读取（生产由 dispatcher 注入 session-preset.ts 的统一实现；缺省回落 header
+     *  ——创建事实，仅供测试/未接线场景保留既有行为）。 */
+    readPreset?(agent: unknown): string;
 }
-/** 全局子代理写护栏：仅 DT 角色会话的"子代理"（agentPreset === 'kanban-dt' 且
+/** 全局子代理写护栏：仅 DT 角色会话的"子代理"（preset === 'kanban-dt' 且
  *  header.parentSession 为 kbn-<taskId> 前缀）应用 buildDTWriteGuard。判据：parentSession
  *  缺失或非 kbn- 前缀 → 放行（DT 父会话自身或无关会话；DT 父会话只读由 agent.ctx guard
  *  兜底，双保险）。repoRoot 取子代理 header.cwd（继承 DT 会话 cwd=评审目标仓库）；缺省
  *  '/'（写标记全拦的保守形态）。chainId 从 parentSession（kbn-<taskId>）解析；解析不到
- *  → 空（wiki_write fail-closed 全拒，源码写拦截不受影响）。 */
+ *  → 空（wiki_write fail-closed 全拒，源码写拦截不受影响）。
+ *  preset 判定经 deps.readPreset（统一实现）：子代理继承父组合，引擎真相同样有答案；
+ *  header.parentSession 仍是创建事实（子代理会话由 agent-runner 建，不存在空白期改 preset 的窗口）。 */
 export declare function buildSubagentTreeGuard(deps?: SubagentGuardDeps): (execution: {
     name?: string;
     arguments?: unknown;
     agent?: unknown;
 }) => string | undefined;
-/** 蜂群模式主会话硬闸：全局 guard，按 header.agentPreset==='swarm'
- *  精准判定（先例 buildSubagentTreeGuard）。swarm 会话 = 扩权参数教学拦截（宿主 bash/write/edit
+/** 蜂群模式主会话硬闸：全局 guard，按会话 preset==='swarm'
+ *  精准判定（先例 buildSubagentTreeGuard）。**必须用统一 preset 读面**：web「蜂群模式」标签会话的
+ *  header 落宿主默认 'ptc'（2026-09-17 实测），只读 header 会让本闸对目标会话整体失效。
+ *  swarm 会话 = 扩权参数教学拦截（宿主 bash/write/edit
  *  schema 广播 sandbox_permissions/justification，模型带参重试会触发天花板会话 approveEscalation
  *  死循环——独立 DT 同款拦截）+ git 反选（与独立 DT 共用 GIT_MUTATION_VERBS/dualVerbGitDenyReason，
  *  buildPlanWriteGuard 同款分段提取判定，跳过 git 全局选项、提取不到动词 fail-closed，先行判定——
  *  git 变更动词多数同时命中只读基座的写标记，须以 swarm-guard 文案优先返回）+ 只读基座
  *  （buildReadOnlyWriteGuard：直接写工具全名拦截 + bash/run_code 写标记）。其余会话恒放行
  *  （角色会话自有 agent scope 护栏兜底，双保险不叠加）。 */
-export declare function buildSwarmSessionGuard(): (execution: {
+export declare function buildSwarmSessionGuard(deps?: SubagentGuardDeps): (execution: {
     name?: string;
     arguments?: unknown;
     agent?: unknown;
 }) => string | undefined;
 /** 独立评审（standalone DT）全局硬闸。独立会话判定（同时成立）：
- *  header.agentPreset === 'kanban-dt'、未经角色组合标记（!isRoleComposed）、parentSession
+ *  会话 preset === 'kanban-dt'（经 deps.readPreset 统一读面）、未经角色组合标记（!isRoleComposed）、parentSession
  *  非 kbn- 前缀（与 buildSubagentTreeGuard 判据对齐：有 kbn- parentSession 的是链上系
  *  DT 子代理，交由该 guard 管——其 incarnation 可能无组合标记、宿主 id 也可能非 kbn-
  *  前缀，漏判会把链评审写入误当独立模式拒掉）、且（能从 execution.agent 取到 session
@@ -96,10 +103,25 @@ export declare function buildSwarmSessionGuard(): (execution: {
  *     落盘是 git 自身行为，BASH_WRITE_RE 无此二动词天然放行，无需特判）；
  *  3. wiki_write（独立模式）→ 仅放行 projects/<repo>/reviews/<主题>-<日期>/ 命名空间；
  *  4. wiki_write（非独立会话）→ 链上组合会话（isRoleComposed）放行（自有 agent-scope
- *     guard 管，链命名空间写入绝不被本 guard 误拦）；其余（main/swarm/未知 GUI）拒绝
- *     ——评审工具全局注册后 wiki_write 收紧到评审会话；
+ *     guard 管，链命名空间写入绝不被本 guard 误拦）；swarm 主会话与 W preset 会话放行
+ *     （2026-09-16 放宽，写面由工具内路径白名单约束）；其余（main/未知 GUI）拒绝
+ *     ——评审工具全局注册后 wiki_write 收紧到评审/知识会话；
  *  5. 其余工具（read/glob/grep/ocr_review/wiki_read/wiki_search 等）→ 放行。 */
-export declare function buildStandaloneDtGuard(): (execution: {
+/** wiki_write 会话级放行 preset 默认白名单：与 config.ts wikiWritePresets 默认值同源，
+ *  仅供 guard deps 未接线（测试/裸调用）时兜底；生产经 dispatcher 注入热读配置。
+ *  'ptc'：普通（PTC 模式）会话亦可写 wiki 命名空间——写面本身由 wiki_write 工具内的
+ *  五类命名空间白名单硬约束；2026-09-17 起 preset 判定走统一读面（session-preset.ts），
+ *  'ptc' 不再是「蜂群会话被误读成 ptc」的兜底，而是显式放行普通会话。 */
+export declare const DEFAULT_WIKI_WRITE_PRESETS: ReadonlyArray<string>;
+export interface StandaloneDtGuardDeps {
+    /** wiki_write 放行 preset 白名单热读（dispatcher 注入 () => getEffective().wikiWritePresets；
+     *  缺省回落 DEFAULT_WIKI_WRITE_PRESETS——测试与未接线场景保持默认行为）。 */
+    getWikiWritePresets?: () => ReadonlyArray<string>;
+    /** 会话 preset 读取（生产由 dispatcher 注入 session-preset.ts 的统一实现；缺省回落 header
+     *  ——创建事实，仅供测试/未接线场景保留既有行为）。 */
+    readPreset?(agent: unknown): string;
+}
+export declare function buildStandaloneDtGuard(deps?: StandaloneDtGuardDeps): (execution: {
     name?: string;
     arguments?: unknown;
     agent?: unknown;
@@ -107,7 +129,8 @@ export declare function buildStandaloneDtGuard(): (execution: {
 /** 独立评审工具全局注册：ocr_review + wiki 三原语（wiki_read/wiki_search/wiki_write）。
  *  独立评审不经 agent-runner 角色组合，角色工具面不存在，故在插件全局 ctx 注册；
  *  caller 固定 actor='dt'（can('wiki-write','dt')=true），wiki_write 的会话级收紧由
- *  buildStandaloneDtGuard 完成（链上组合会话放行，main/swarm/未知 GUI 拒绝）。
+ *  buildStandaloneDtGuard 完成（链上组合会话/swarm 主会话/W preset 会话放行，
+ *  main/未知 GUI 拒绝）。
  *  wiki 客户端按 kbMode 构造（与 registerMainSessionTools 同源：remote 优先 ctx.get('wiki')
  *  注入（测试 mock），生产热读取 getEffective().wikiVault；local 走 LocalWikiClient）。
  *  local 模式不注册 wiki_write：LocalWikiClient.abs 只接受 wiki/** 形态，而 wiki_write

package/lib/roles/toolsets.js

@@ -5,6 +5,7 @@ import { isInsideKbRoot, ensureLocalKbRoot } from '../wiki/local-kb.js';
 import { LocalWikiClient } from '../wiki/local-kb-client.js';
 import { isStandaloneReviewNamespacePath } from '../domain/ocr-review.js';
 import { isRoleComposed } from '../dispatcher/agent-runner.js';
+import { headerPresetOf } from '../dispatcher/session-preset.js';
 import { ESCALATION_PARAM_KEYS } from './clean-fs-tools.js';
 export { isRoleComposed };
 import { buildKanbanTools } from '../tools/kanban-tools.js';
@@ -437,16 +438,19 @@ function extractSessionHeader(agent) {
     const h = a?.session?.header;
     return h && typeof h === 'object' ? h : undefined;
 }
-/** 全局子代理写护栏：仅 DT 角色会话的"子代理"（agentPreset === 'kanban-dt' 且
+/** 全局子代理写护栏：仅 DT 角色会话的"子代理"（preset === 'kanban-dt' 且
  *  header.parentSession 为 kbn-<taskId> 前缀）应用 buildDTWriteGuard。判据：parentSession
  *  缺失或非 kbn- 前缀 → 放行（DT 父会话自身或无关会话；DT 父会话只读由 agent.ctx guard
  *  兜底，双保险）。repoRoot 取子代理 header.cwd（继承 DT 会话 cwd=评审目标仓库）；缺省
  *  '/'（写标记全拦的保守形态）。chainId 从 parentSession（kbn-<taskId>）解析；解析不到
- *  → 空（wiki_write fail-closed 全拒，源码写拦截不受影响）。 */
+ *  → 空（wiki_write fail-closed 全拒，源码写拦截不受影响）。
+ *  preset 判定经 deps.readPreset（统一实现）：子代理继承父组合，引擎真相同样有答案；
+ *  header.parentSession 仍是创建事实（子代理会话由 agent-runner 建，不存在空白期改 preset 的窗口）。 */
 export function buildSubagentTreeGuard(deps = {}) {
+    const readPreset = deps.readPreset ?? headerPresetOf;
     return (execution) => {
         const header = extractSessionHeader(execution?.agent);
-        if (!header || header.agentPreset !== 'kanban-dt')
+        if (!header || readPreset(execution?.agent) !== 'kanban-dt')
             return undefined;
         // 仅真实子代理（parentSession 为 kbn- 前缀）受全局护栏约束；DT 父会话自身
         // parentSession 是主会话或缺失（非 kbn- 前缀），chainId 解析不到 → 空，若误拦
@@ -461,18 +465,21 @@ export function buildSubagentTreeGuard(deps = {}) {
         return buildDTWriteGuard(repoRoot, chainId)(execution);
     };
 }
-/** 蜂群模式主会话硬闸：全局 guard，按 header.agentPreset==='swarm'
- *  精准判定（先例 buildSubagentTreeGuard）。swarm 会话 = 扩权参数教学拦截（宿主 bash/write/edit
+/** 蜂群模式主会话硬闸：全局 guard，按会话 preset==='swarm'
+ *  精准判定（先例 buildSubagentTreeGuard）。**必须用统一 preset 读面**：web「蜂群模式」标签会话的
+ *  header 落宿主默认 'ptc'（2026-09-17 实测），只读 header 会让本闸对目标会话整体失效。
+ *  swarm 会话 = 扩权参数教学拦截（宿主 bash/write/edit
  *  schema 广播 sandbox_permissions/justification，模型带参重试会触发天花板会话 approveEscalation
  *  死循环——独立 DT 同款拦截）+ git 反选（与独立 DT 共用 GIT_MUTATION_VERBS/dualVerbGitDenyReason，
  *  buildPlanWriteGuard 同款分段提取判定，跳过 git 全局选项、提取不到动词 fail-closed，先行判定——
  *  git 变更动词多数同时命中只读基座的写标记，须以 swarm-guard 文案优先返回）+ 只读基座
  *  （buildReadOnlyWriteGuard：直接写工具全名拦截 + bash/run_code 写标记）。其余会话恒放行
  *  （角色会话自有 agent scope 护栏兜底，双保险不叠加）。 */
-export function buildSwarmSessionGuard() {
+export function buildSwarmSessionGuard(deps = {}) {
+    const readPreset = deps.readPreset ?? headerPresetOf;
     return (execution) => {
         const header = extractSessionHeader(execution?.agent);
-        if (!header || header.agentPreset !== 'swarm')
+        if (!header || readPreset(execution?.agent) !== 'swarm')
             return undefined;
         const name = String(execution?.name ?? '');
         const args = execution?.arguments ?? {};
@@ -565,7 +572,7 @@ function dualVerbGitDenyReason(verb, rest, deny) {
     }
 }
 /** 独立评审（standalone DT）全局硬闸。独立会话判定（同时成立）：
- *  header.agentPreset === 'kanban-dt'、未经角色组合标记（!isRoleComposed）、parentSession
+ *  会话 preset === 'kanban-dt'（经 deps.readPreset 统一读面）、未经角色组合标记（!isRoleComposed）、parentSession
  *  非 kbn- 前缀（与 buildSubagentTreeGuard 判据对齐：有 kbn- parentSession 的是链上系
  *  DT 子代理，交由该 guard 管——其 incarnation 可能无组合标记、宿主 id 也可能非 kbn-
  *  前缀，漏判会把链评审写入误当独立模式拒掉）、且（能从 execution.agent 取到 session
@@ -581,23 +588,32 @@ function dualVerbGitDenyReason(verb, rest, deny) {
  *     落盘是 git 自身行为，BASH_WRITE_RE 无此二动词天然放行，无需特判）；
  *  3. wiki_write（独立模式）→ 仅放行 projects/<repo>/reviews/<主题>-<日期>/ 命名空间；
  *  4. wiki_write（非独立会话）→ 链上组合会话（isRoleComposed）放行（自有 agent-scope
- *     guard 管，链命名空间写入绝不被本 guard 误拦）；其余（main/swarm/未知 GUI）拒绝
- *     ——评审工具全局注册后 wiki_write 收紧到评审会话；
+ *     guard 管，链命名空间写入绝不被本 guard 误拦）；swarm 主会话与 W preset 会话放行
+ *     （2026-09-16 放宽，写面由工具内路径白名单约束）；其余（main/未知 GUI）拒绝
+ *     ——评审工具全局注册后 wiki_write 收紧到评审/知识会话；
  *  5. 其余工具（read/glob/grep/ocr_review/wiki_read/wiki_search 等）→ 放行。 */
-export function buildStandaloneDtGuard() {
+/** wiki_write 会话级放行 preset 默认白名单：与 config.ts wikiWritePresets 默认值同源，
+ *  仅供 guard deps 未接线（测试/裸调用）时兜底；生产经 dispatcher 注入热读配置。
+ *  'ptc'：普通（PTC 模式）会话亦可写 wiki 命名空间——写面本身由 wiki_write 工具内的
+ *  五类命名空间白名单硬约束；2026-09-17 起 preset 判定走统一读面（session-preset.ts），
+ *  'ptc' 不再是「蜂群会话被误读成 ptc」的兜底，而是显式放行普通会话。 */
+export const DEFAULT_WIKI_WRITE_PRESETS = ['swarm', 'kanban-w', 'ptc'];
+export function buildStandaloneDtGuard(deps = {}) {
+    const readPreset = deps.readPreset ?? headerPresetOf;
     return (execution) => {
         const header = extractSessionHeader(execution?.agent);
         const name = String(execution?.name ?? '');
         const agent = execution?.agent;
         const sessionId = typeof agent?.id === 'string' ? agent.id : undefined;
+        const preset = readPreset(execution?.agent);
         // 链上系 DT 子代理（parentSession 为 kbn-<taskId> 前缀）：交由 buildSubagentTreeGuard 管，
         // 本 guard 不按独立模式收紧、也不在非独立分支拒其 wiki_write（链评审目录写入归该 guard 校验）。
         const isDtChainSubagent = !!header
-            && header.agentPreset === 'kanban-dt'
+            && preset === 'kanban-dt'
             && typeof header.parentSession === 'string'
             && header.parentSession.startsWith('kbn-');
         const standalone = !!header
-            && header.agentPreset === 'kanban-dt'
+            && preset === 'kanban-dt'
             && !isRoleComposed(execution?.agent)
             && !isDtChainSubagent
             && !(sessionId !== undefined && sessionId.startsWith('kbn-'));
@@ -648,7 +664,16 @@ export function buildStandaloneDtGuard() {
         if (name === 'wiki_write') {
             if (isRoleComposed(execution?.agent) || isDtChainSubagent)
                 return undefined;
-            return 'wiki-write-restricted-to-reviewer-sessions: wiki_write 仅限交付评审官（DT）评审会话使用';
+            // 放宽（2026-09-16）：swarm 主会话与 W preset 会话可写 wiki——can('wiki-write') 本就含 w
+            // （permissions.ts），写面由 wiki_write 工具内 assertAllowedWikiPagePath 五类命名空间
+            // 白名单硬约束；local 模式 wiki_write 未全局注册，无工具面即无暴露面。
+            // 放行面配置化（硬规则 6）：白名单经 deps 热读 config.wikiWritePresets，宿主 preset
+            // 体系演化/部署自定义模式 id 时改配置即可；config 缺字段回 []（fail-closed，仅内置默认兜底测试）。
+            const allowed = deps.getWikiWritePresets?.() ?? DEFAULT_WIKI_WRITE_PRESETS;
+            if (preset !== '' && allowed.includes(preset))
+                return undefined;
+            // 诊断尾巴：报错带实际 preset（或"无"），用户重试一次即可定位会话模式判定缺口
+            return 'wiki-write-restricted-to-reviewer-sessions: wiki_write 仅限 DT 评审会话 / W 角色 / swarm 主会话使用（当前会话 preset=' + (preset || '无') + '）';
         }
         return undefined;
     };
@@ -656,7 +681,8 @@ export function buildStandaloneDtGuard() {
 /** 独立评审工具全局注册：ocr_review + wiki 三原语（wiki_read/wiki_search/wiki_write）。
  *  独立评审不经 agent-runner 角色组合，角色工具面不存在，故在插件全局 ctx 注册；
  *  caller 固定 actor='dt'（can('wiki-write','dt')=true），wiki_write 的会话级收紧由
- *  buildStandaloneDtGuard 完成（链上组合会话放行，main/swarm/未知 GUI 拒绝）。
+ *  buildStandaloneDtGuard 完成（链上组合会话/swarm 主会话/W preset 会话放行，
+ *  main/未知 GUI 拒绝）。
  *  wiki 客户端按 kbMode 构造（与 registerMainSessionTools 同源：remote 优先 ctx.get('wiki')
  *  注入（测试 mock），生产热读取 getEffective().wikiVault；local 走 LocalWikiClient）。
  *  local 模式不注册 wiki_write：LocalWikiClient.abs 只接受 wiki/** 形态，而 wiki_write

package/lib/services/evidence-replay.d.ts

@@ -0,0 +1,28 @@
+import { type runOne } from './gate-runner.js';
+import { type EvidenceState } from '../domain/evidence-check.js';
+export interface EvidenceCheckResult {
+    title: string;
+    severity: string;
+    state: EvidenceState;
+    detail: string;
+}
+/** 沿父链找最近 execute 卡的 worktree_dir（重放 cwd=被评审代码所在处）。 */
+export declare function resolveTargetWorktree(parents: Array<{
+    assignee: string;
+    mode: string;
+    metadata?: Record<string, unknown>;
+}>): string | null;
+interface ReplayCfg {
+    replayEnabled: boolean;
+    timeoutMs: number;
+    allowPrefixes: string[];
+    /** 黑名单子串预检（沿用 gates.forbidden 纵深，评审 Important：不得清空）。 */
+    forbidden?: string[];
+    worktreeDir: string | null;
+    readFile: (p: string) => Promise<string | null>;
+    run?: typeof runOne;
+}
+export declare function checkIssueEvidence(input: {
+    issues: unknown;
+} & ReplayCfg): Promise<EvidenceCheckResult[]>;
+export {};

package/lib/services/evidence-replay.js

@@ -0,0 +1,79 @@
+// src/services/evidence-replay.ts
+/** DT 评审证据三级核验编排（PR2）：L1 缺证标记 → L2 纸面核对（零执行）→ L3 重放（默认关，非沙箱）。
+ * 非阻塞：任何结果只返回留痕数据，不改 verdict、不 throw。 */
+import { readFile } from 'node:fs/promises';
+import { runGateCommands } from './gate-runner.js';
+import { isAllowedCommand, paperCheck, parseIssueEvidence } from '../domain/evidence-check.js';
+/** 沿父链找最近 execute 卡的 worktree_dir（重放 cwd=被评审代码所在处）。 */
+export function resolveTargetWorktree(parents) {
+    for (const p of parents) {
+        if (p.assignee === 'd' && p.mode === 'execute') {
+            const wt = p.metadata?.['worktree_dir'];
+            if (typeof wt === 'string' && wt.trim())
+                return wt;
+        }
+    }
+    return null;
+}
+export async function checkIssueEvidence(input) {
+    const list = Array.isArray(input.issues) ? input.issues : [];
+    const forbidden = input.forbidden ?? ['rm -rf /', 'git push'];
+    const out = [];
+    for (const rawIssue of list) {
+        // 评审 Important：per-issue 容错——被核验者塞 null/标量元素不得让整批核验无痕消失
+        if (typeof rawIssue !== 'object' || rawIssue === null) {
+            out.push({ title: '(invalid issue entry)', severity: 'unknown', state: 'could-not-replay', detail: 'issues 数组含非对象元素 — needs-human 核对' });
+            continue;
+        }
+        const issue = rawIssue;
+        const title = String(issue['title'] ?? '(untitled)');
+        const severity = String(issue['severity'] ?? 'low');
+        const ev = parseIssueEvidence(issue['evidence']);
+        if (!ev) {
+            const serious = severity === 'critical' || severity === 'high';
+            out.push(serious
+                ? { title, severity, state: 'could-not-replay', detail: 'no evidence provided (critical/high) — needs-human 核对' }
+                : { title, severity, state: 'not-provided', detail: 'no evidence attached' });
+            continue;
+        }
+        // L2 纸面核对（零执行）
+        let content = null;
+        try {
+            content = await input.readFile(ev.file);
+        }
+        catch {
+            content = null;
+        }
+        const paper = paperCheck(content, ev.exit);
+        if (paper === 'matches') {
+            out.push({ title, severity, state: 'matches', detail: `paper check ok: ${ev.file}` });
+            continue;
+        }
+        // L3 重放（对不上才动用；默认关）
+        if (!input.replayEnabled) {
+            out.push({ title, severity, state: 'could-not-replay', detail: `paper ${paper}; replay disabled by config — needs-human` });
+            continue;
+        }
+        if (!isAllowedCommand(ev.command, input.allowPrefixes)) {
+            out.push({ title, severity, state: 'could-not-replay', detail: `command not allowlisted: ${ev.command}` });
+            continue;
+        }
+        if (!input.worktreeDir) {
+            out.push({ title, severity, state: 'could-not-replay', detail: 'no target worktree resolved' });
+            continue;
+        }
+        const cmd = { command: ev.command, cwd: input.worktreeDir, source: 'tdd' };
+        const report = await runGateCommands([cmd], { timeoutMs: input.timeoutMs, forbidden }, input.run);
+        // 评审 Important：TIMEOUT/SPAWN_FAIL/FORBIDDEN ≠ 假证据——超时/派生失败/黑名单命中落 could-not-replay，
+        // 仅真实执行（含非零退出）与声明不符才判 differs（四态语义准确性）
+        if (report.failure && report.failure.code !== 'NONZERO') {
+            out.push({ title, severity, state: 'could-not-replay', detail: `replay ${report.failure.code}: ${report.failure.detail} — needs-human` });
+            continue;
+        }
+        const rerun = report.results.at(-1)?.exitCode;
+        out.push(rerun !== null && rerun === ev.exit
+            ? { title, severity, state: 'matches', detail: `replay confirmed exit ${rerun}` }
+            : { title, severity, state: 'differs', detail: `replay exit=${rerun} ≠ claimed ${ev.exit} — 假证据疑点，needs-human` });
+    }
+    return out;
+}

package/lib/services/gate-evidence.d.ts

@@ -0,0 +1,2 @@
+import type { GateRunReport } from './gate-runner.js';
+export declare function writeGateLog(dir: string, taskId: string, report: GateRunReport): Promise<string>;

package/lib/services/gate-evidence.js

@@ -0,0 +1,21 @@
+// src/services/gate-evidence.ts
+/** gate 实测日志落盘（PR1 P3 存档）：pass 也留原始输出，事后可翻账对质（issue #2 verify.sh 模式的 D 侧落点）。
+ * 追加写（每轮一条时间戳头），单文件 per task，路径进 gate detail 供 agent/human 引用。 */
+import { mkdir, appendFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function writeGateLog(dir, taskId, report) {
+    const logDir = join(dir, 'gate-logs');
+    await mkdir(logDir, { recursive: true });
+    const path = join(logDir, `${taskId}.log`);
+    const lines = [`== ${new Date().toISOString()} ok=${report.ok}`];
+    for (const r of report.results) {
+        lines.push(`-- ${r.command}`);
+        lines.push(`exit=${r.exitCode} durationMs=${r.durationMs} truncated=${r.truncated}`);
+        if (r.output)
+            lines.push(r.output);
+    }
+    if (report.failure)
+        lines.push(`-- failure: ${report.failure.code}: ${report.failure.detail}`);
+    await appendFile(path, lines.join('\n') + '\n');
+    return path;
+}

package/lib/services/im-delivery.d.ts

@@ -72,6 +72,10 @@ export interface BotChoice {
     via: BotVia;
     fallbackSaved?: boolean;
 }
+/** 应答 → 候选 botId（宽松匹配，宁缺勿错）：
+ *  ① 令牌精确相等；② 与令牌互相包含（仅当令牌足够长，防 3~5 字符误命中）。
+ *  多义（>=2 个候选命中）或无法识别 → 空串（调用方 fail-closed 不投，绝不猜）。 */
+export declare function matchBotAnswer(options: BotAskOption[], raw: string): string;
 /** 机器人决策链：显式配置 → 唯一机器人 → 会话 preset 命中 → 默认机器人 → 交互选择。
  *  每环都 fail-closed（宁可不投也不投错对象）；探针不可用只失去自动匹配能力，不阻断投递。 */
 export declare function chooseBot(im: DshImLike, cfg: {

package/lib/services/im-delivery.js

@@ -32,6 +32,33 @@ function resolveDshIm(ctx, log) {
 function askLabel(o) {
     return o.label ? `${o.label}（${o.botId}）` : o.botId;
 }
+/** 归一：去空白（含全角空格）+ 小写（GUI 可能回传带装饰/大小写变化的文本）。 */
+function normAnswer(s) {
+    return s.replace(/[\s\u3000]/g, '').toLowerCase();
+}
+/** 一个候选的全部可识别令牌：botId / 展示 label 全文 / label 的展示名段（去 ·模式·离线 与 （botId）后缀）。 */
+function idTokens(o) {
+    const out = [normAnswer(o.botId)];
+    if (o.label) {
+        const n = normAnswer(o.label);
+        out.push(n.split('（')[0], n.split('·')[0]);
+    }
+    return [...new Set(out.filter((t) => t.length > 0))];
+}
+/** 应答 → 候选 botId（宽松匹配，宁缺勿错）：
+ *  ① 令牌精确相等；② 与令牌互相包含（仅当令牌足够长，防 3~5 字符误命中）。
+ *  多义（>=2 个候选命中）或无法识别 → 空串（调用方 fail-closed 不投，绝不猜）。 */
+export function matchBotAnswer(options, raw) {
+    const target = normAnswer(raw);
+    if (!target)
+        return '';
+    const exact = options.find((o) => idTokens(o).includes(target));
+    if (exact)
+        return exact.botId;
+    const partial = options.filter((o) => idTokens(o).some((t) => t.length >= 6 && (t.includes(target) || target.includes(t))));
+    const uniq = [...new Set(partial.map((o) => o.botId))];
+    return uniq.length === 1 ? uniq[0] : '';
+}
 /** 多机器人且无法自动决策时的 fail-closed 报错：列候选（有探针数据则带模式与连接态）。 */
 function botCandidatesError(ids, probed) {
     const byId = new Map(probed.map((b) => [b.botId, b]));
@@ -212,10 +239,11 @@ function buildBotAsk(ctx, agent, log) {
             const pick = ans.answers?.find((a) => a.id === 'im-bot');
             const typed = pick?.custom?.trim() ?? '';
             const selected = pick?.selected?.[0]?.trim() ?? '';
-            // 自由文本也接受，但必须是候选之一——防手写错 id 投到未知对象。
-            const botId = options.find((o) => askLabel(o) === selected || o.botId === selected || o.botId === typed)?.botId ?? '';
+            // 选中标签与自由文本都接受，但必须唯一落到候选之一——防手写错 id 投到未知对象。
+            const botId = matchBotAnswer(options, selected) || matchBotAnswer(options, typed);
             if (!botId) {
-                log('[im-delivery] 机器人交互已应答但未映射到候选（selected 与候选不符）');
+                // 只记候选 id 与用户可见文本（公开标识，无敏感载荷），便于下次定位映射失败。
+                log(`[im-delivery] 机器人交互已应答但未映射到候选: selected=${JSON.stringify(selected).slice(0, 120)} custom=${JSON.stringify(typed).slice(0, 120)} candidates=${options.map((o) => o.botId).join(',')}`);
                 return null;
             }
             const setDefault = (ans.answers?.find((a) => a.id === 'im-bot-default')?.selected ?? []).includes(ASK_SET_DEFAULT_LABEL);

package/lib/services/kanban-provider.d.ts

@@ -16,5 +16,6 @@ export declare class KanbanProvider extends Service {
     /** 整链硬删除后的联动钩子（由 startDispatcher 装配注入）：dispatcher 游标同步 + V 编排 entry 清理。
      *  purge 物理重排 events seq，若不同步则删链后新建链的可唤醒事件被运行中实例永久跳过。 */
     onChainDeleted: ((chainId: string) => Promise<void> | void) | null;
+    private readonly gateLogDir;
     constructor(ctx: Context, config: KanbanConfig, configProvider: ConfigProvider);
 }