@joekytc/dsh-swarm 0.1.2 → 0.2.0

package/lib/roles/clean-fs-tools.js

@@ -0,0 +1,118 @@
+// src/roles/clean-fs-tools.ts
+// sandbox-menu-align Task 1（计划 /tmp/sandbox-menu-align-plan.md）：danger-full-access 会话
+// （P、D(execute)）的 write/edit/bash 工具菜单去毒。
+//
+// 为什么：宿主 dsh-tool-fs / dsh-tool-bash 在组合层把可选参数 sandbox_permissions / justification
+// 合入 write/edit/bash schema（dsh-tool-fs lib/index.js:617/771 schemaFields()、dsh-tool-bash
+// lib/index.js:285-289；广播与否只看组合默认沙箱模式 :1111，会话层 sandbox/mode 改不掉）。
+// 在 danger-full-access（权限天花板）会话里，escalation「必须严格更宽」无更宽可升——任何值
+// 都被 approveEscalation 拒绝，模型却仍从菜单看到这两个按钮，触发拒绝-重试循环
+// （2026-09-02 P 会话 30 连败事故根因）。plan-guard 的带参拦截保留为兜底网（toolsets.ts 不动），
+// 本文件是根治面：agent scope shadow 注册「无带毒参数的干净版」盖住宿主版本 + execute 剥参转发。
+//
+// 宿主探明结论（详见 .superpowers/sdd/sandbox-menu-align-plan/task-1-report.md）：
+// - 遮蔽语义（dsh-tools lib/index.js view/get + dsh-scope ScopedLayers）：scope 自身层注册在
+//   inherited（global + preset standing 祖先层）之后覆盖 visible map → agent scope 同名注册
+//   真实盖住宿主版本；「重复注册 fail」仅指同一层内（NamedEntries.insert），跨层 shadow 合法。
+//   agentPresets.mount 是 bindScopeParent（agent scope 挂为 preset standing scope 的 child），
+//   preset 里 tool-fs/tool-bash 的注册落在 standing 祖先层而非 agent own 层 → 本模块经
+//   agentCtx.tools.register 落 own 层，无同层冲突（Task 2 的 kanban_comment 遮蔽已实证该通道）。
+// - 转发通道：agentCtx.tools.get(name, agent) 返回该 scope 可见定义（shadow 注册前即宿主原定义，
+//   kanban-p/d 的 fs/bash 在 preset standing 祖先层，全局视角 get(name) 反而可能取不到）；
+//   直接调用 hostDef.execute(cleanArgs, exec) 与注册表 dispatchToolBody 的调用形态逐字一致
+//   （lib/index.js:3174 tool.execute(exec.arguments, exec)）。绕开 approval/escalation 前置管线
+//   安全：resolvePolicy 在两参皆缺时走 standingPolicy 路径（dsh-sandbox validateEscalationArgs
+//   对 (undefined, undefined) 放行）——即官方默认行为，escalation 管线本就不触发。
+// - guard 管线在 dispatch 前运行且 deny-only（registry pre-execute → guardReason → dispatch），
+//   转发是对宿主 execute 的普通函数调用，不存在 guard 二次绕过问题。
+// - justification 仅为 escalation 配套参数（dsh-sandbox：「justification is only valid together
+//   with sandbox_permissions」），与两参一并剥离 = 官方 standing 行为，无害。
+/** 需剥离的带毒参数（dsh-sandbox escalation 配对参数；写死避免依赖宿主内部导出）。 */
+export const ESCALATION_PARAM_KEYS = ['sandbox_permissions', 'justification'];
+/** 需去毒的宿主工具名单：write/edit（dsh-tool-fs）+ bash（dsh-tool-bash，schema 同样带毒）。 */
+const CLEAN_FS_TOOL_NAMES = ['write', 'edit', 'bash'];
+/** 本模块 shadow 的品牌标记（幂等判定：setup 重入/live 修复重跑 setup 时识别已挂 shadow）。
+ *  Symbol.for 跨模块实例一致；对象展开会复制自有可枚举 symbol 属性，标记随干净版定义存活。 */
+const CLEAN_FS_BRAND = Symbol.for('dsh-swarm.clean-fs-shadow');
+/** 从 agentCtx 解出工具注册表（缺 service = 测试桩/异常宿主 → undefined）。 */
+function toolsRuntimeOf(agentCtx) {
+    const tools = agentCtx.tools;
+    if (!tools || typeof tools.get !== 'function' || typeof tools.register !== 'function')
+        return undefined;
+    return tools;
+}
+/** 剥离 escalation 参数：净化后新对象返回；本就干净则原对象透传（零拷贝零改写）。 */
+export function stripEscalationArgs(args) {
+    if (!args || typeof args !== 'object' || Array.isArray(args))
+        return args;
+    const a = args;
+    const poisoned = ESCALATION_PARAM_KEYS.some((k) => a[k] !== undefined);
+    if (!poisoned)
+        return args;
+    const { sandbox_permissions: _sp, justification: _j, ...rest } = a;
+    return rest;
+}
+/**
+ * 给 danger-full-access 会话 shadow 注册去毒版 write/edit/bash。
+ *
+ * 行为契约：
+ * - 干净版 = 宿主定义浅拷贝 + parameters 去掉两带毒字段（JSON 深拷贝后删除，注册表保证 lossless JSON）
+ *   + execute 换成「剥参 → 转发宿主原工具 execute」。写逻辑零自实现，行为 100% 官方。
+ * - 宿主 schema 本就无带毒参数（无沙箱后端的组合，escalationModes 为空）→ 无需 shadow，跳过
+ *   （最小触碰面：不去盖一个本来就干净的版本）。
+ * - 转发失败面（宿主定义不可达 / 缺 execute / 同层注册冲突）→ 该工具不挂 + console.error 显形，
+ *   宿主带毒版本保持可见（fail-safe：绝不注册一个自实现写文件的半成品）。
+ * - 幂等：setup 重入（live 会话修复路径 resumeOrReuse 会重跑 setup）先以品牌标记识别已挂
+ *   shadow → 跳过；同层冲突抛错也被捕获显形，不炸 setup（宿主版本继续可见，plan-guard 兜底网仍在）。
+ *
+ * @param agentCtx agent setup 收到的 scoped ctx（agentCtx.tools 即该 scope 的注册表）
+ * @param agent Agent 实例（= dsh-tools scope key，exec.agent 同源；get 的 scope 视角参数）
+ */
+export function installCleanFsTools(agentCtx, agent) {
+    const tools = toolsRuntimeOf(agentCtx);
+    if (!tools)
+        return; // 无工具服务（测试桩）跳过；宿主版本自然保持可见
+    for (const name of CLEAN_FS_TOOL_NAMES) {
+        try {
+            // shadow 注册前取样：get(name, agent) 走该 agent scope 视角——own 层尚无同名时返回
+            // inherited（global + preset standing 祖先层）里的宿主原定义
+            const visible = tools.get(name, agent);
+            if (!visible || typeof visible !== 'object' || !visible.parameters || typeof visible.execute !== 'function') {
+                console.error('[dsh-swarm][clean-fs] host "' + name + '" not reachable via agent-scope registry — shadow skipped, host version stays visible');
+                continue;
+            }
+            if (visible[CLEAN_FS_BRAND])
+                continue; // 幂等：上次 setup 已挂 shadow
+            const props = visible.parameters.properties;
+            const poisoned = !!props && ESCALATION_PARAM_KEYS.some((k) => props[k] !== undefined);
+            if (!poisoned)
+                continue; // 宿主 schema 本就干净（无沙箱组合）→ 无需 shadow
+            // parameters 深拷贝去毒（注册表已保证 lossless JSON，JSON 往返安全）；
+            // 宿主编译态无 additionalProperties:false（parameterSchemaSpecToJsonSchema 开根），
+            // 模型惯性硬塞的带毒参数由 execute 剥参兜住，不会在宿主 execute 的 args 校验处炸出。
+            const parameters = JSON.parse(JSON.stringify(visible.parameters));
+            if (parameters['properties'] && typeof parameters['properties'] === 'object') {
+                for (const key of ESCALATION_PARAM_KEYS)
+                    delete parameters['properties'][key];
+            }
+            // 防御：宿主未来若把两参数标成必填，required 一并过滤（当前为可选，此过滤为空操作）
+            if (Array.isArray(parameters['required'])) {
+                parameters['required'] = parameters['required'].filter((k) => !ESCALATION_PARAM_KEYS.includes(k));
+            }
+            tools.register({
+                ...visible,
+                parameters,
+                [CLEAN_FS_BRAND]: true,
+                // 剥参后转发宿主原 execute：调用形态与注册表 dispatchToolBody 逐字一致（args, exec）。
+                // 禁止在此自实现任何写逻辑——行为漂移风险，宿主升级即失效。
+                execute(args, exec) {
+                    return visible.execute(stripEscalationArgs(args), exec);
+                },
+            });
+        }
+        catch (err) {
+            // fail-safe：单工具失败只降级该工具（宿主版本保持可见），不阻断其余工具与 setup
+            console.error('[dsh-swarm][clean-fs] shadow register failed for "' + name + '" — host version stays visible: ' + String(err));
+        }
+    }
+}

package/lib/roles/skill-installer.d.ts

@@ -0,0 +1,6 @@
+export declare function packageSkillDir(): string;
+export declare function userSkillsRoot(): string;
+export declare function installLlWikiSkill(opts?: {
+    src?: string;
+    dstRoot?: string;
+}): 'installed' | 'exists' | 'skipped';

package/lib/roles/skill-installer.js

@@ -0,0 +1,32 @@
+// src/roles/skill-installer.ts
+// llm-wiki skill 自动安装（设计 §7 / D6）：DSH 的 dsh-tool-skill 只从 ~/.agents/skills/ 发现 skill，
+// 不扫插件包内 skills 目录（同 agent-presets 只认 $DSH_HOME/.agent-presets 的先例）。
+// 完整复制（含 deps/assets/tests 全部子目录）；幂等（SKILL.md 已存在跳过）；尽力而为（失败仅告警）。
+import { cpSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function packageSkillDir() {
+    return fileURLToPath(new URL('../../skills/llm-wiki-skill/', import.meta.url));
+}
+export function userSkillsRoot() {
+    return join(homedir(), '.agents', 'skills');
+}
+export function installLlWikiSkill(opts) {
+    const src = opts?.src ?? packageSkillDir();
+    const dst = join(opts?.dstRoot ?? userSkillsRoot(), 'llm-wiki-skill');
+    if (!existsSync(src))
+        return 'skipped';
+    if (existsSync(join(dst, 'SKILL.md')))
+        return 'exists';
+    try {
+        mkdirSync(dst, { recursive: true });
+        cpSync(src, dst, { recursive: true });
+        console.info('[dsh-swarm] llm-wiki-skill installed -> ' + dst);
+        return 'installed';
+    }
+    catch (err) {
+        console.warn('[dsh-swarm] llm-wiki-skill install skipped -> ' + dst + ': ' + String(err));
+        return 'skipped';
+    }
+}

package/lib/roles/toolsets.d.ts

@@ -2,7 +2,8 @@ import type { Context } from '@deepseek-ai/cordis';
 import { KanbanService } from '../domain/kanban-service.js';
 import type { WikiVaultClient } from '../wiki/wiki-vault-client.js';
 import type { Role } from '../domain/types.js';
-/** 判定 wiki 路径是否位于 DT 评审命名空间 projects/<chain>/review/（拒绝 ../、绝对路径、非 review 前缀）。 */
+/** 判定 wiki 路径是否位于 DT 评审命名空间 projects/<repoSlug>/<chainId>/review/
+ *  （repoSlug=[a-z0-9-]+ 通配，chainId 精确匹配；拒绝 ../、绝对路径、跨链、旧格式直挂根）。 */
 export declare function isReviewNamespacePath(pagePath: string, chainId: string): boolean;
 /**
  * 评审引擎决策（DT）：ocr（open-code-review Delegation 模式）优先；
@@ -25,6 +26,16 @@ export declare function buildReadOnlyWriteGuard(_repoRoot: string): (execution:
     name?: string;
     arguments?: unknown;
 }) => string | undefined;
+/** 本地模式 KB 写护栏（D7/D10）：全名只读拦截（base）之上，仅对「实际写目标全部为
+ *  库根内绝对路径」的写操作豁免。目标提取不到 / 相对路径 / 越界 → 维持 base 拒绝（fail-closed）。
+ *  仅 local 模式对 W/DT 装配；remote 模式仍用 buildReadOnlyWriteGuard（库根写也被拒）。
+ *  审查修订（C2）：extractWriteTargets 保持既有双参签名（cmd, redirectRe），按入口分流
+ *  传 BASH_REDIRECT_TARGET_RE / CODE_REDIRECT_TARGET_RE（与 buildPlanWriteGuard 同款）——
+ *  单参调用会在首个写意图命令上 TypeError。 */
+export declare function buildKbWriteGuard(kbRoot: string): (execution: {
+    name?: string;
+    arguments?: unknown;
+}) => string | undefined;
 /** P 专用写护栏（Q3）：读全放行；git mutation 一律拒绝；写仅允许目标仓库 openspec/changes 目录。
  *  直接 fs 写工具 → 路径经 resolve 归一化后须落在 <workspaceRoot>/openspec/changes/ 之下（相邻段对判定）；
  *  bash/run_code 写标记命令 → 命令文本须含 `openspec/changes` 子串，且提取出的实际写目标（重定向
@@ -42,6 +53,7 @@ export declare function installRoleTools(agentCtx: Context, role: Role, deps: {
     kanban: KanbanService;
     wiki: WikiVaultClient;
     taskId?: string;
+    kbMode?: 'remote' | 'local';
 }): Promise<void>;
 export declare function registerDtTaskChain(taskId: string, chainId: string): void;
 export declare function unregisterDtTaskChain(taskId: string): void;

package/lib/roles/toolsets.js

@@ -1,5 +1,6 @@
 import { resolve } from 'node:path';
 import { KanbanService } from '../domain/kanban-service.js';
+import { isInsideKbRoot } from '../wiki/local-kb.js';
 import { buildKanbanTools } from '../tools/kanban-tools.js';
 import { buildSpecCardTools } from '../tools/spec-card-tools.js';
 import { buildWikiTools } from '../tools/wiki-tools.js';
@@ -25,6 +26,29 @@ const GIT_READ_VERBS = new Set(['status', 'log', 'show', 'diff', 'rev-parse', 'l
  *  可直接执行任意文件写 API）∪ 原地编辑器 -i（sed -i / perl -i / awk -i inplace：可越过重定向直达
  *  源码原地改写，P 写护栏硬约束须识别，与 BASH_WRITE_RE 同源）。 */
 const GUARD_WRITE_INTENT_RE = /(?:\b(?:touch|mkdir|rm|rmdir|mv|cp|tee|truncate|install|ln|dd|chmod|chown|make|cmake)\b|\b(?:sed|perl|awk)\s+-i\b|\b(?:node|python|python3|perl|ruby|php|sh|bash)\s+-[ec]\b|(?<!2)>>|(?<!2)(?<!>)>)/i;
+/** run_code（JS/TS/Python 程序）重定向写意图：仅带空格形态 \s>>?（run_code 内嵌 shell 字符串的
+ *  `echo x > f` 重定向，与 BASH_WRITE_RE 的带空格形态同源）。对 run_code 必须与 bash 的
+ *  GUARD_WRITE_INTENT_RE 分离（planguard-falsepositive 根治）：
+ *  1) 无空格 `>` 规则移除——JS 里 `=>`（箭头函数）、`remaining>0`（比较）是运算符而非重定向，
+ *     误判致 P 会话 openspec 裸 edit 随机被拒（15 次误报实证，2026-09-03）；
+ *  2) GUARD 写动词（touch/mkdir/rm/…）与解释器 -c/-e、原地编辑器 -i 移除——真文件写由
+ *     CODE_WRITE_RE 补回覆盖（writeFile/mkdir/unlink/open 写模式/os./pathlib/shutil），
+ *     内嵌 shell 裸动词由 CODE_SHELL_VERB_RE 补回覆盖（Fix round 1），内嵌 shell 重定向由
+ *     本正则覆盖。三层分工与 accepted-risk 见 CODE_SHELL_VERB_RE 注释。 */
+const CODE_REDIRECT_WRITE_RE = /\s>>?/;
+/** run_code 内嵌 shell 裸动词写意图（Fix round 1，评审 Important）：CODE_WRITE_RE 只含文件写
+ *  API，不含裸 shell 动词——run_code 字符串派发的 shell 命令（`child_process.exec('cp /tmp/x
+ *  src/foo.ts')`）会绕过写护栏。词表对齐 GUARD_WRITE_INTENT_RE 动词清单中 CODE_WRITE_RE 未覆盖
+ *  的部分（rm/mkdir 已由 CODE_WRITE_RE 覆盖不重复；touch/rmdir/make/cmake 按评审定版不纳入）。
+ *  word boundary 形态：JS 里作为独立词出现即拦（copy/cpSync/mkdirSync 等复合词不误伤），
+ *  误伤率与 GUARD 复用旧版一致可接受。三层分工：内嵌 shell 动词由本词表覆盖；重定向由
+ *  CODE_REDIRECT_WRITE_RE（带空格 \s>>?）覆盖；JS/Python 文件写 API 由 CODE_WRITE_RE 覆盖。
+ *  accepted-risk：内嵌 shell 无空格重定向（`exec('cat t>src/y')`）与 JS 运算符（=>、比较）
+ *  在正则上不可分辨——无空格 `>` 规则一旦保留即复活 planguard-falsepositive 运算符误报
+ *  （15 次实证），GUARD 复用旧版拦得住它但误报面更大，取舍为放行（accepted-risk）；
+ *  run_code 带空格比较 `a > b` 且同 code 含 openspec/changes 路径时仍可能误拒（残余面小，
+ *  失败可恢复——模型改用 write 工具重试即可）。 */
+const CODE_SHELL_VERB_RE = /\b(?:cp|mv|tee|dd|chmod|chown|ln|install|truncate)\b/i;
 /** 剥去 shell 重定向目标 token 外壳的一层引号（' " `）（F3：引号包裹的 plan 路径被 I1 误拒修复）。
  *  仅剥对称外壳一层；剥完仍走 resolve+isPlanPath，.. / 绝对路径逃逸不被削弱。 */
 function stripShellQuotes(tok) {
@@ -35,11 +59,12 @@ function stripShellQuotes(tok) {
     return tok;
 }
 /** I1：从 bash/run_code 写意图命令提取实际写目标路径。
- *  返回重定向（>/>> 后首个非重定向 token，fd2 以 lookbehind 豁免）与 writeFileSync(/appendFileSync(
- *  首个字符串实参；提取不到返回空数组（调用方据此 fail-closed 或放行）。 */
-function extractWriteTargets(cmd) {
+ *  redirectRe 按入口分流：bash 传 BASH_REDIRECT_TARGET_RE（无空格形态），run_code 传
+ *  CODE_REDIRECT_TARGET_RE（带空格形态）——两形态各自命名，禁止共享开关参数。
+ *  另提取 writeFileSync(/appendFileSync( 首个字符串实参；提取不到返回空数组（调用方据此
+ *  fail-closed 或放行）。 */
+function extractWriteTargets(cmd, redirectRe) {
     const out = [];
-    const redirectRe = /(?:(?<!2)>>|(?<!2)(?<!>)>)\s*([^\s;&|<>]+)/g;
     let m;
     while ((m = redirectRe.exec(cmd)) !== null) {
         if (m[1])
@@ -50,15 +75,37 @@ function extractWriteTargets(cmd) {
         if (m[2])
             out.push(m[2]);
     }
+    // 双模式 D7：动词目标提取——必须捕获动词后【全部】路径实参（只取首个会让
+    // `mkdir -p <kb>/x /repo/y` 漏检第二个目标 → 护栏越权放行，审查 C2）。
+    // cp/mv/rm 的源+目标全部入列：任一在库根外即整体拒绝（fail-closed，accepted-risk：
+    // 库根内合法 cp/mv 改用 write 工具完成）。
+    const verbRe = /\b(?:touch|mkdir|tee|cp|mv|rm|install)\b([^;&|<>]*)/g;
+    while ((m = verbRe.exec(cmd)) !== null) {
+        for (const tok of m[1].split(/\s+/)) {
+            if (!tok || tok.startsWith('-'))
+                continue;
+            out.push(stripShellQuotes(tok));
+        }
+    }
     return out;
 }
-/** 判定 wiki 路径是否位于 DT 评审命名空间 projects/<chain>/review/（拒绝 ../、绝对路径、非 review 前缀）。 */
+/** bash 重定向目标提取（无空格形态）：`>file`/`>>file` 是 bash 合法写重定向，必须识别为写目标；
+ *  fd2 stderr 豁免沿用 lookbehind（重定向符前（首个 > 前）字符非 '2' 才算，2>/dev/null、2>&1、
+ *  2>>err.log 不命中），且禁止从 >> 的第二个 > 起匹配。仅用于 bash 入口。 */
+const BASH_REDIRECT_TARGET_RE = /(?:(?<!2)>>|(?<!2)(?<!>)>)\s*([^\s;&|<>]+)/g;
+/** run_code 重定向目标提取（带空格形态）：run_code 是 JS/TS/Python 程序代码，无空格 `>` 是
+ *  运算符（箭头 =>、比较 remaining>0），旧版无空格形态会把 `>0` 的 "0" 提取成写目标 →
+ *  isPlanPath("0")=false → openspec 裸 edit 随机误拒（15 次误报实证）。故只认带空格重定向
+ *  （run_code 内嵌 shell 字符串 `echo x > /tmp/f`），与 CODE_REDIRECT_WRITE_RE 同源。 */
+const CODE_REDIRECT_TARGET_RE = /\s>>?\s*([^\s;&|<>]+)/g;
+/** 判定 wiki 路径是否位于 DT 评审命名空间 projects/<repoSlug>/<chainId>/review/
+ *  （repoSlug=[a-z0-9-]+ 通配，chainId 精确匹配；拒绝 ../、绝对路径、跨链、旧格式直挂根）。 */
 export function isReviewNamespacePath(pagePath, chainId) {
     const p = String(pagePath ?? '');
     if (!p || p.startsWith('/') || p.includes('..'))
         return false;
-    const prefix = `projects/${chainId}/review/`;
-    return p.startsWith(prefix);
+    const chain = chainId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^projects\\/[a-z0-9-]+\\/${chain}\\/review\\/`).test(p);
 }
 /**
  * 评审引擎决策（DT）：ocr（open-code-review Delegation 模式）优先；
@@ -84,7 +131,7 @@ export function buildDTWriteGuard(repoRoot, chainId) {
             const args = execution?.arguments ?? {};
             const pagePath = String(args && typeof args === 'object' ? args['pagePath'] ?? '' : '');
             if (!isReviewNamespacePath(pagePath, chainId))
-                return 'wiki-write-outside-review-namespace: DT may only write projects/<chain>/review/';
+                return 'wiki-write-outside-review-namespace: DT may only write projects/<repoSlug>/<chain>/review/';
         }
         return base(execution);
     };
@@ -102,14 +149,54 @@ export function buildReadOnlyWriteGuard(_repoRoot) {
             const cmd = String(args && typeof args === 'object' ? (args['command'] ?? args['code'] ?? '') : '');
             // bash 用 BASH_WRITE_RE（写动词 + git mutation + 带空格重定向）∪ GUARD_WRITE_INTENT_RE
             // （无空格重定向 + 解释器 -c/-e）——全名拦截，写标记即拒，无论目标是否在 repo 内。
-            // run_code 用 JS/Python 文件写 API 标记（CODE_WRITE_RE）。
-            const writeRe = name === 'run_code' ? CODE_WRITE_RE : BASH_WRITE_RE;
-            if (cmd && (writeRe.test(cmd) || GUARD_WRITE_INTENT_RE.test(cmd)))
+            // run_code 与 bash 分离（planguard-falsepositive 根治）：CODE_WRITE_RE（文件写 API）
+            // ∪ CODE_SHELL_VERB_RE（内嵌 shell 裸动词，exec cp/mv 不再绕过）∪
+            // CODE_REDIRECT_WRITE_RE（带空格重定向）——无空格 > 在 JS 里是运算符（=>、比较），
+            // 不能复用 GUARD_WRITE_INTENT_RE（P 会话 15 次误报实证）。
+            const isWrite = name === 'run_code'
+                ? CODE_WRITE_RE.test(cmd) || CODE_SHELL_VERB_RE.test(cmd) || CODE_REDIRECT_WRITE_RE.test(cmd)
+                : BASH_WRITE_RE.test(cmd) || GUARD_WRITE_INTENT_RE.test(cmd);
+            if (cmd && isWrite)
                 return 'write-to-repo-source-denied: ' + name + ' with write marker';
         }
         return undefined;
     };
 }
+/** 本地模式 KB 写护栏（D7/D10）：全名只读拦截（base）之上，仅对「实际写目标全部为
+ *  库根内绝对路径」的写操作豁免。目标提取不到 / 相对路径 / 越界 → 维持 base 拒绝（fail-closed）。
+ *  仅 local 模式对 W/DT 装配；remote 模式仍用 buildReadOnlyWriteGuard（库根写也被拒）。
+ *  审查修订（C2）：extractWriteTargets 保持既有双参签名（cmd, redirectRe），按入口分流
+ *  传 BASH_REDIRECT_TARGET_RE / CODE_REDIRECT_TARGET_RE（与 buildPlanWriteGuard 同款）——
+ *  单参调用会在首个写意图命令上 TypeError。 */
+export function buildKbWriteGuard(kbRoot) {
+    const base = buildReadOnlyWriteGuard(kbRoot);
+    const isKbTarget = (t) => isInsideKbRoot(kbRoot, t);
+    return (execution) => {
+        const baseReason = base(execution);
+        if (!baseReason)
+            return undefined;
+        const name = String(execution?.name ?? '');
+        const args = execution?.arguments ?? {};
+        const a = args && typeof args === 'object' ? args : {};
+        if (DIRECT_WRITE_TOOLS.has(name)) {
+            const target = String(a['path'] ?? a['file_path'] ?? '');
+            if (target && isKbTarget(target))
+                return undefined;
+            return baseReason;
+        }
+        if (name === 'bash' || name === 'run_code') {
+            const cmd = String(a['command'] ?? a['code'] ?? '');
+            if (!cmd)
+                return baseReason;
+            // 双参签名 + 按入口分流 redirect 正则（审查 C2）；targets 为空 = 写意图但提取不到目标 → fail-closed 拒绝
+            const targets = extractWriteTargets(cmd, name === 'bash' ? BASH_REDIRECT_TARGET_RE : CODE_REDIRECT_TARGET_RE);
+            if (targets.length > 0 && targets.every(isKbTarget))
+                return undefined;
+            return baseReason;
+        }
+        return baseReason;
+    };
+}
 /** P 专用写护栏（Q3）：读全放行；git mutation 一律拒绝；写仅允许目标仓库 openspec/changes 目录。
  *  直接 fs 写工具 → 路径经 resolve 归一化后须落在 <workspaceRoot>/openspec/changes/ 之下（相邻段对判定）；
  *  bash/run_code 写标记命令 → 命令文本须含 `openspec/changes` 子串，且提取出的实际写目标（重定向
@@ -140,6 +227,14 @@ export function buildPlanWriteGuard(workspaceRoot) {
         const args = execution?.arguments ?? {};
         const a = args && typeof args === 'object' ? args : {};
         if (DIRECT_WRITE_TOOLS.has(name)) {
+            // Fix（2026-09-02 P 会话 30 连败事故）：P 会话为 danger-full-access（天花板），官方 write/edit
+            // schema 仍广播可选参数 sandbox_permissions，模型误填后任何值都触发官方 approveEscalation
+            // "not strictly wider" 拒绝（escalation 必须严格更宽，天花板无更宽可升）。此处工具级拦截：
+            // 带该参数即拒并返回自解释文案（模型一轮纠偏改用裸 file_path+content），先于路径判定（参数
+            // 本身即非法，与目标无关）。
+            if (a['sandbox_permissions'] !== undefined) {
+                return 'plan-guard: 本会话已是 danger-full-access（权限天花板），禁止附带 sandbox_permissions（任何值都会被拒绝，且无需升级）。请直接用 file_path + content 裸写 openspec/changes/ 下的目标文件，不要重试被拒的带参调用。';
+            }
             const target = String(a['path'] ?? a['file_path'] ?? '');
             if (isPlanPath(target))
                 return undefined;
@@ -163,11 +258,14 @@ export function buildPlanWriteGuard(workspaceRoot) {
                 if (!verb || !GIT_READ_VERBS.has(verb))
                     return 'plan-guard: P 禁止 git 操作';
             }
-            // THEN 写意图：增强写标记（含无空格重定向与解释器 -c/-e 单行）且不含 plan 路径 → 拒绝。
-            // run_code 额外用文件写 API 标记（CODE_WRITE_RE，fs.writeFileSync 等）；保留 GUARD 动词/解释器
-            // 覆盖（touch/mkdir/rm/… 与 python -c 内联单行）不回归。
+            // THEN 写意图：bash 用增强写标记（含无空格重定向与解释器 -c/-e）且不含 plan 路径 → 拒绝。
+            // run_code 与 bash 分离（planguard-falsepositive 根治，2026-09-03）：CODE_WRITE_RE（文件
+            // 写 API）∪ CODE_SHELL_VERB_RE（内嵌 shell 裸动词，Fix round 1）∪ CODE_REDIRECT_WRITE_RE
+            // （带空格重定向）——无空格 > 在 JS 里是运算符（=>、比较 remaining>0），
+            // GUARD_WRITE_INTENT_RE 复用致 openspec 裸 edit 随机误拒（15 次实证）；GUARD 动词/
+            // 解释器对 run_code 移除的论证见 CODE_REDIRECT_WRITE_RE / CODE_SHELL_VERB_RE 注释。
             const isWrite = name === 'run_code'
-                ? CODE_WRITE_RE.test(cmd) || GUARD_WRITE_INTENT_RE.test(cmd)
+                ? CODE_WRITE_RE.test(cmd) || CODE_SHELL_VERB_RE.test(cmd) || CODE_REDIRECT_WRITE_RE.test(cmd)
                 : GUARD_WRITE_INTENT_RE.test(cmd);
             if (isWrite) {
                 if (!isPlanCmd(cmd))
@@ -175,7 +273,8 @@ export function buildPlanWriteGuard(workspaceRoot) {
                 // I1：含 plan 标记仍须验证实际写目标——重定向 >/>> 目标与 writeFileSync(/appendFileSync(
                 // 首个字符串实参，逐条 resolve + isPlanPath（与 write/edit 入口同款判定，杀 M1 同款
                 // openspec/changes/../.. 穿越写源码，补齐 bash/run_code 入口）。任一条目标不通过 → 拒绝。
-                const targets = extractWriteTargets(cmd);
+                // 重定向形态按入口分流：bash 无空格（>f 合法写），run_code 带空格（无空格 > 是运算符）。
+                const targets = extractWriteTargets(cmd, name === 'run_code' ? CODE_REDIRECT_TARGET_RE : BASH_REDIRECT_TARGET_RE);
                 if (targets.length === 0) {
                     // 快速防线：命令同时含 openspec/changes 与 .. 但目标解析不出（无法提取）→ fail-closed 拒绝
                     if (cmd.includes('..'))
@@ -191,10 +290,34 @@ export function buildPlanWriteGuard(workspaceRoot) {
         return undefined;
     };
 }
+/** 工具注册表解析：直取 ctx.tools（官方语义），失败回退 ctx.get('tools')（cordis 服务路径，
+ *  与 v-orchestrator setup 取 agentPresets 同款）。宿主/ cordis 版本混装（web profile 实证
+ *  0.1.1-rc.2 包 + 4.0.1/4.0.2 peer 并存）下直取路径可能静默 undefined（旧语义），回退路径
+ *  保证角色工具面仍能注册。两者皆空时必须告警——静默跳过=角色裸奔且无痕。 */
+function resolveToolRegistry(agentCtx) {
+    const direct = agentCtx.tools;
+    if (direct && typeof direct.register === 'function')
+        return direct;
+    const fallback = agentCtx.get?.('tools');
+    if (fallback && typeof fallback.register === 'function') {
+        console.error('[dsh-swarm][debug] tool registry via ctx.get fallback (direct .tools missing)');
+        return fallback;
+    }
+    return undefined;
+}
+function safeKeys(ctx) {
+    try {
+        return Object.keys(ctx).slice(0, 12).join(',');
+    }
+    catch {
+        return '<unkeyed>';
+    }
+}
 /** 按角色在 agent scope 注册工具面（P1-3 统一注册策略）：
  *  所有 kanban 工具从 T9 工厂选取 + getCaller 闭包（actor=role、boundTaskId=taskId）。
  *  can() 权限兜底仍保留在工具 execute 内（纵深防御第二道）。 */
 export async function installRoleTools(agentCtx, role, deps) {
+    const kbMode = deps.kbMode ?? 'remote';
     console.error('[dsh-swarm][debug] installRoleTools role=' + role + ' task=' + deps.taskId);
     const caller = () => ({ actor: role, boundTaskId: deps.taskId });
     const allKanban = buildKanbanTools(deps.kanban, caller);
@@ -211,23 +334,28 @@ export async function installRoleTools(agentCtx, role, deps) {
         dt: ['kanban_show', 'kanban_chain', 'kanban_list', 'kanban_complete', 'kanban_block', 'kanban_heartbeat', 'kanban_comment'],
     };
     const want = new Set(namesFor[role]);
-    const registry = agentCtx.tools;
-    if (!registry)
-        return; // 无工具服务（测试桩）跳过
+    const registry = resolveToolRegistry(agentCtx);
+    if (!registry) {
+        console.error('[dsh-swarm][error] tool registry unavailable — role tools NOT registered (silent capability loss risk) role=' + role + ' task=' + (deps.taskId ?? '-') + ' ctxKeys=' + safeKeys(agentCtx));
+        return; // 保持返回不抛：本轮先取证，全角色 fail-fast 另行决策
+    }
     for (const tool of allKanban) {
         const name = tool.name;
         if (name && want.has(name))
             registry.register(tool);
     }
     if (role === 'w') {
-        for (const tool of buildWikiTools(deps.wiki, caller))
-            registry.register(tool);
+        if (kbMode === 'remote') {
+            for (const tool of buildWikiTools(deps.wiki, caller))
+                registry.register(tool);
+        }
+        // local（D2）：wiki 三原语不注册，W 经 skill 工具（preset 提供）自治查写；prefetch/spec 视图保留
         // 设计表 §3：W 对规格卡只读（spec_card_view）
         for (const tool of buildSpecCardTools(deps.kanban, caller)) {
             if (tool.name === 'spec_card_view')
                 registry.register(tool);
         }
-        const worker = new WikiWorker(deps.kanban, deps.wiki, { pagePrefix: 'projects/' });
+        const worker = new WikiWorker(deps.kanban, deps.wiki, { pagePrefix: 'projects/', kbMode: deps.kbMode });
         const getTask = async (taskId) => {
             const state = await deps.kanban.snapshot();
             const t = state.tasks.get(taskId);
@@ -240,10 +368,12 @@ export async function installRoleTools(agentCtx, role, deps) {
     }
     else if (role === 'd') {
         // D：只读 KB——注册 wiki_read + wiki_search（均走 can('wiki-read')=w/d 只读兜底）；规格卡只读
-        for (const tool of buildWikiTools(deps.wiki, caller)) {
-            const name = tool.name;
-            if (name === 'wiki_read' || name === 'wiki_search')
-                registry.register(tool);
+        if (kbMode === 'remote') {
+            for (const tool of buildWikiTools(deps.wiki, caller)) {
+                const name = tool.name;
+                if (name === 'wiki_read' || name === 'wiki_search')
+                    registry.register(tool);
+            }
         }
         for (const tool of buildSpecCardTools(deps.kanban, caller)) {
             if (tool.name === 'spec_card_view')
@@ -270,10 +400,12 @@ export async function installRoleTools(agentCtx, role, deps) {
             if (tool.name === 'spec_card_view')
                 registry.register(tool);
         }
-        for (const tool of buildWikiTools(deps.wiki, caller)) {
-            const n = tool.name;
-            if (n === 'wiki_read' || n === 'wiki_search' || n === 'wiki_write')
-                registry.register(tool);
+        if (kbMode === 'remote') {
+            for (const tool of buildWikiTools(deps.wiki, caller)) {
+                const n = tool.name;
+                if (n === 'wiki_read' || n === 'wiki_search' || n === 'wiki_write')
+                    registry.register(tool);
+            }
         }
     }
     else if (role === 'v') {
@@ -319,7 +451,7 @@ export function buildSubagentTreeGuard(deps = {}) {
             return undefined;
         // 仅真实子代理（parentSession 为 kbn- 前缀）受全局护栏约束；DT 父会话自身
         // parentSession 是主会话或缺失（非 kbn- 前缀），chainId 解析不到 → 空，若误拦
-        // 会把 DT 评审写入（wiki_write projects/<chain>/review/...）拒掉 → 直接放行。
+        // 会把 DT 评审写入（wiki_write projects/<repoSlug>/<chain>/review/...）拒掉 → 直接放行。
         const parent = header.parentSession;
         if (typeof parent !== 'string' || !parent.startsWith('kbn-'))
             return undefined;

package/lib/roles/wiki-worker.d.ts

@@ -8,6 +8,7 @@ export declare class WikiWorker {
     private readonly cfg;
     constructor(kanban: KanbanService, wiki: WikiVaultClient, cfg: {
         pagePrefix: string;
+        kbMode?: 'remote' | 'local';
     });
     executePrefetch(task: Task, mode: 'file' | 'external' | 'kb', source: string): Promise<{
         ref: string;

package/lib/roles/wiki-worker.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { buildRepoSlug } from '../domain/memory.js';
 function workspaceOf(chainId, taskId) {
     return join(process.env.DSH_HOME ?? process.cwd(), 'storages', 'kanban', 'workspaces', chainId, taskId);
 }
@@ -26,15 +27,22 @@ export class WikiWorker {
                 throw new Error('prefetch source outside workspace: ' + source);
             return { ref: source || ref };
         }
-        // kb 模式：知识库查询产物（wiki-vault search/read 由 wiki 工具执行，agent 落盘 ws/prefetch-kb.md）
+        // kb 模式：知识库查询产物。local 模式（D2）不走 wiki 工具——明确指引改用 skill 加载 llm-wiki。
+        if (this.cfg.kbMode === 'local') {
+            throw new Error('prefetch_kb unavailable in local KB mode: use the skill tool to load llm-wiki for KB search instead');
+        }
+        // remote：知识库查询产物（wiki-vault search/read 由 wiki 工具执行，agent 落盘 ws/prefetch-kb.md）
         const ref = join(ws, 'prefetch-kb.md');
         if (!source.startsWith(ws) && source !== '')
             throw new Error('prefetch source outside workspace: ' + source);
         return { ref: source || ref };
     }
     async syncToWiki(task, sourceRef) {
+        const chain = (await this.kanban.snapshot()).chains.get(task.chainId);
+        if (!chain?.workspaceDir)
+            throw new Error('syncToWiki requires chain.workspaceDir: ' + task.chainId);
         const content = readFileSync(sourceRef, 'utf8'); // 原汁原味：不压缩不蒸馏
-        const pagePath = this.cfg.pagePrefix + task.chainId + '/' + task.id + '.md';
+        const pagePath = `${this.cfg.pagePrefix}${buildRepoSlug(chain.workspaceDir)}/${task.chainId}/${task.id}.md`;
         await this.wiki.write(pagePath, content);
         return { kb_url: this.wikiBase() + '/#/page/' + pagePath, page_path: pagePath };
     }

package/lib/routes/kanban-http.d.ts

@@ -1,6 +1,9 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { KanbanConfig } from '../config.js';
 import type { KanbanProvider } from '../services/kanban-provider.js';
-/** 看板 HTTP 桥（Web GUI 浏览器半消费）：GET /kanban/board 读快照；POST /kanban/action 执行状态操作。
+import type { ConfigProvider } from '../services/config-provider.js';
+import type { LlmRuntimeLike } from '../services/llm-catalog.js';
+/** 看板 HTTP 桥（Web GUI 浏览器半消费）：GET /kanban/board 读快照；POST /kanban/action 执行状态操作；
+ *  GET/PUT /kanban/config + POST /kanban/config/reset 配置读写；GET /kanban/llm-catalog 模型目录。
  *  仅在 webServer 服务存在时挂载（CLI/headless/测试裸 Context 不挂）。 */
-export declare function registerKanbanHttp(ctx: Context, provider: KanbanProvider, config?: Pick<KanbanConfig, 'ui'>): void;
+export declare function registerKanbanHttp(ctx: Context, provider: KanbanProvider, configProvider: ConfigProvider, llm: LlmRuntimeLike, config?: Pick<KanbanConfig, 'ui'>): void;