@joekytc/dsh-swarm 0.1.2 → 0.2.0

package/lib/routes/kanban-http.js

@@ -1,3 +1,4 @@
+import { buildLlmCatalog } from '../services/llm-catalog.js';
 import { serveKanbanEvents } from './kanban-sse.js';
 function json(res, status, body) {
     res.statusCode = status;
@@ -12,9 +13,10 @@ function readBody(req) {
         req.on('error', reject);
     });
 }
-/** 看板 HTTP 桥（Web GUI 浏览器半消费）：GET /kanban/board 读快照；POST /kanban/action 执行状态操作。
+/** 看板 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 function registerKanbanHttp(ctx, provider, config) {
+export function registerKanbanHttp(ctx, provider, configProvider, llm, config) {
     // 可选服务：经 ctx.get 读取（cordis 4 直接属性读取需 inject；get 不需要）
     const webServer = ctx.get('webServer');
     if (!webServer)
@@ -55,7 +57,8 @@ export function registerKanbanHttp(ctx, provider, config) {
                         json(res, 200, { ok: true });
                         return;
                     }
-                    // 整链硬删除（仅 human；GUI 二次确认）：purge 无事件流，客户端需自行 resync
+                    // 整链硬删除（仅 human；GUI 二次确认）：purge 无事件流，客户端需自行 resync。
+                    // E/F：删链后联动 dispatcher（游标同步钳回）+ V 编排 entry 清理，防运行中实例跳过后续新链事件。
                     if (body.type === 'delete') {
                         const chainId = String(body.chainId ?? '').trim();
                         if (!chainId) {
@@ -63,6 +66,8 @@ export function registerKanbanHttp(ctx, provider, config) {
                             return;
                         }
                         await provider.service.deleteChain(chainId, 'human');
+                        if (provider.onChainDeleted)
+                            await provider.onChainDeleted(chainId);
                         json(res, 200, { ok: true });
                         return;
                     }
@@ -149,6 +154,34 @@ export function registerKanbanHttp(ctx, provider, config) {
                     json(res, 200, { ok: true });
                     return;
                 }
+                // 配置读写：reset 是 POST，与 GET/PUT config 经 method 区分（reset 分支前置，防前缀遮蔽）
+                if (req.method === 'POST' && req.url?.startsWith('/kanban/config/reset')) {
+                    json(res, 200, configProvider.reset());
+                    return;
+                }
+                if (req.method === 'GET' && req.url?.startsWith('/kanban/config')) {
+                    json(res, 200, configProvider.snapshot());
+                    return;
+                }
+                if (req.method === 'PUT' && req.url?.startsWith('/kanban/config')) {
+                    const raw = JSON.parse((await readBody(req)) || '{}');
+                    // 归一化缺省字段，保证缺字段走 400 校验失败而非 500
+                    const snapshot = {
+                        wikiVault: { baseUrl: raw.wikiVault?.baseUrl ?? '', pagePrefix: raw.wikiVault?.pagePrefix ?? '' },
+                        roles: { models: raw.roles?.models ?? {} },
+                    };
+                    const r = configProvider.applyOverride(snapshot);
+                    if (!r.ok) {
+                        json(res, 400, { error: 'validation failed', fields: r.errors });
+                        return;
+                    }
+                    json(res, 200, { ok: true, effective: r.effective, sources: r.sources });
+                    return;
+                }
+                if (req.method === 'GET' && req.url?.startsWith('/kanban/llm-catalog')) {
+                    json(res, 200, await buildLlmCatalog(llm));
+                    return;
+                }
                 json(res, 404, { error: 'not found' });
             }
             catch (err) {

package/lib/routes/planning-driver.d.ts

@@ -1,7 +1,9 @@
 import { KanbanService } from '../domain/kanban-service.js';
 import type { SpecCard, SpecCardAttachment } from '../domain/types.js';
 import { type PrefixRoutes } from '../config.js';
-/** 阶段 0 规划引导：命令串从 config 派生（决策12），/openspec: 改名时文案自动跟随。 */
+/** 阶段 0 规划引导：命令串从 config 派生（决策12），/openspec: 改名时文案自动跟随。
+ *  提问节奏与 skills/grill-me/SKILL.md 对齐：官方 frontier 分轮制（整批问 + 推荐答案 + 答复后解锁下一轮）；
+ *  增强项：人话硬规则 + 过程风险登记；收敛产物仍为 planning_checklist_save（KB 清单是建链数据源）。 */
 export declare function buildPlanningGuidance(routes: PrefixRoutes): string;
 export declare function validateSpecCardForApproval(card: SpecCard): string[];
 export declare function buildPlanningContext(chainId: string, card: SpecCard, attachments: SpecCardAttachment[], routes?: PrefixRoutes): string;

package/lib/routes/planning-driver.js

@@ -1,14 +1,18 @@
 import { KanbanService } from '../domain/kanban-service.js';
 import { parsePrefix } from './prefix-router.js';
 import { DEFAULT_PREFIX_ROUTES } from '../config.js';
-/** 阶段 0 规划引导：命令串从 config 派生（决策12），/openspec: 改名时文案自动跟随。 */
+/** 阶段 0 规划引导：命令串从 config 派生（决策12），/openspec: 改名时文案自动跟随。
+ *  提问节奏与 skills/grill-me/SKILL.md 对齐：官方 frontier 分轮制（整批问 + 推荐答案 + 答复后解锁下一轮）；
+ *  增强项：人话硬规则 + 过程风险登记；收敛产物仍为 planning_checklist_save（KB 清单是建链数据源）。 */
 export function buildPlanningGuidance(routes) {
     return `
-# 阶段 0 规划对话（v2：需求澄清前置化）
-1. 需求澄清（grill-me）：一次只问一个问题，先澄清目的、约束、成功标准；逐项拷问假设直至用户"没有任何疑问"。
-2. 仓库事实（planning_prefetch）：调只读子代理采集目标仓库/资料/知识库事实（本地路径/分支/目标文件基线/既有实现），不凭空假设。
-3. 收敛（planning_checklist_save）：把结论写成结构化需求澄清清单（spec 六段 + manifest repo.files + 澄清问答 + 疑问点）存入 KB（KB 不可达自动兜底临时目录）。
-4. 收尾：提醒用户以 ${routes.openspec} 确认执行结束规划阶段——${routes.openspec} 会从清单建链并自动串行执行。
+# 阶段 0 规划对话（v4：grill-me frontier 分轮，与 skills/grill-me 对齐）
+1. 需求澄清（grill-me，frontier 分轮）：把计划映射为设计决策树——每轮只问当前前提已就绪的问题（frontier），整批问出：编号 + 每问附推荐答案；等用户全部答复后重算 frontier（已定决定向外推进、解锁依赖它的问题）再发下一轮，本轮答不了的依赖问题留到后续轮。先澄清目的、约束、成功标准，逐支拷问直至用户"没有任何疑问"。
+2. 人话硬规则：问题正文与选项必须通俗；术语避不开时首次出现括号一句话解释；发问前自检「不懂本仓库的人能直接回答吗」，不能就重写。
+3. 仓库事实（planning_prefetch）：事实自查是规划者的职责——调只读子代理采集目标仓库/资料/知识库事实（本地路径/分支/目标文件基线/既有实现），不凭空假设、不拿可自查的问题问用户；只把真正的决定留给用户。
+4. 风险登记：每轮答复中若发现真实风险或非阻塞关注点，随手记一行（描述 + 来源决定 + 缓解思路），收敛时并入澄清清单；没有就不写，禁止硬凑。
+5. 收敛（planning_checklist_save）：把结论写成结构化需求澄清清单（spec 六段 + manifest repo.files + 澄清问答 + 疑问点 + 风险点（若有））存入 KB（KB 不可达自动兜底临时目录）。
+6. 收尾：提醒用户以 ${routes.openspec} 确认执行结束规划阶段——${routes.openspec} 会从清单建链并自动串行执行。
 护栏：规划期只读仓库，禁止任何 git/源码写入；只写 KB 与临时目录。
 `;
 }

package/lib/routes/prefix-router.d.ts

@@ -1,6 +1,12 @@
 import { KanbanService } from '../domain/kanban-service.js';
 import type { PlanningChecklist } from '../domain/planning-checklist.js';
 import type { PrefixRoutes } from '../config.js';
+/** 防线D：/openspec: 建链后同步等待首张任务卡的最长时长与轮询间隔（fail-open：超时返回 pending，
+ *  由链级看门狗接管）。可变对象供测试注入短值（vitest 文件级隔离）。 */
+export declare const OPENSPEC_FIRST_CARD: {
+    timeoutMs: number;
+    pollIntervalMs: number;
+};
 export interface PrefixRouteResult {
     kind: 'plan' | 'openspec' | 'learning' | 'none';
     chainId?: string;
@@ -9,6 +15,16 @@ export interface PrefixRouteResult {
     brief?: string;
     guidance?: string;
     error?: string;
+    /** /openspec: 建链结果；false=被护栏拦截（reason 说明原因），未建任何链/卡。 */
+    approved?: boolean;
+    reason?: string;
+    /** 防线D：建链后同步等待的首卡结果。{taskId,status}=V 已建卡；{pending:true}=等待超时（fail-open，看门狗接管）。 */
+    firstCard?: {
+        taskId: string;
+        status: string;
+    } | {
+        pending: true;
+    };
 }
 export declare function parsePrefix(message: string, cfg: PrefixRoutes): PrefixRouteResult;
 /** v2：/plan: 零副作用——不建链/规格卡/任务卡，仅返回路由结果（workspaceDir/sessionId 由 main-session-tools 捕获）。 */

package/lib/routes/prefix-router.js

@@ -1,5 +1,8 @@
 import { KanbanService, buildChainTitle } from '../domain/kanban-service.js';
 import { buildLearningBrief, resolveLearningChainId } from '../domain/memory.js';
+/** 防线D：/openspec: 建链后同步等待首张任务卡的最长时长与轮询间隔（fail-open：超时返回 pending，
+ *  由链级看门狗接管）。可变对象供测试注入短值（vitest 文件级隔离）。 */
+export const OPENSPEC_FIRST_CARD = { timeoutMs: 120_000, pollIntervalMs: 1_000 };
 export function parsePrefix(message, cfg) {
     const trimmed = message.trim();
     if (trimmed.startsWith(cfg.plan))
@@ -19,6 +22,23 @@ export async function handleOpenspecRoute(message, service, cfg, planning, owner
     const parsed = parsePrefix(message, cfg);
     if (parsed.kind !== 'openspec')
         return parsed;
+    // 护栏前移（fail-fast）：无 workspaceDir 的链会让 V 在 getVAgent 抛 workspace-unknown
+    // 且被 dispatcher 静默吞掉（链上零任务 → 无任何后续事件重试）→ 空壳链死锁。
+    // 典型成因：主 agent 进程重启后 planningBySession 重建，仅重存清单未重走 /plan:，
+    // workspaceDir 为 null。此处禁止建链建卡，引导用户先 /plan: 重新捕获工作区。
+    if (!planning.workspaceDir || !planning.workspaceDir.trim()) {
+        return {
+            kind: 'openspec', approved: false, reason: 'workspace-unknown', rest: parsed.rest,
+            guidance: [
+                '## 建链被拦截：workspaceDir 缺失（workspace-unknown）',
+                '当前规划上下文没有目标仓库工作区（多为主 agent 重启后清单内存重建所致）。',
+                '处理步骤（严格顺序）：',
+                '1. 重新发送 ' + cfg.plan + ' <需求描述> 让主 agent 捕获工作区（必要时按提示注册工作区）；',
+                '2. 清单仍在时重发 ' + cfg.openspec + ' 确认即可建链；清单丢失则重新澄清后再确认。',
+                '禁止：在无工作区时建链建卡；猜测工作区路径。',
+            ].join('\n'),
+        };
+    }
     const chain = await service.createChain({
         title: buildChainTitle(planning.checklist.requirementName ?? planning.requirementName ?? null, parsed.rest, planning.checklist.spec.problem),
         ownerSessionId, workspaceDir: planning.workspaceDir,
@@ -27,7 +47,22 @@ export async function handleOpenspecRoute(message, service, cfg, planning, owner
     await service.addSpecCardAttachment(card.id, { name: '需求澄清清单(仓库事实)', kind: 'file-prefetch', ref: planning.checklist.manifest.repo.localPath }, 'v');
     await service.addSpecCardAttachment(card.id, { name: '需求澄清清单(完整资料)', kind: 'kb', ref: planning.checklistRef }, 'v');
     await service.approveSpecCard(card.id, 'human');
-    return { kind: 'openspec', chainId: chain.id, specCardId: card.id, rest: parsed.rest };
+    const firstCard = await waitFirstCard(service, chain.id);
+    return { kind: 'openspec', chainId: chain.id, specCardId: card.id, rest: parsed.rest, firstCard };
+}
+/** 防线D：轮询看板等首张任务卡（任意 assignee/mode，V 首轮建 p 卡）。成功即返；
+ *  超时 fail-open 返回 {pending:true}——不挂死工具调用，失败面由链级看门狗兜底。 */
+async function waitFirstCard(service, chainId) {
+    const deadline = Date.now() + OPENSPEC_FIRST_CARD.timeoutMs;
+    for (;;) {
+        const state = await service.snapshot();
+        const t = [...state.tasks.values()].filter((x) => x.chainId === chainId).at(-1);
+        if (t)
+            return { taskId: t.id, status: t.status };
+        if (Date.now() >= deadline)
+            return { pending: true };
+        await new Promise((r) => setTimeout(r, Math.min(OPENSPEC_FIRST_CARD.pollIntervalMs, Math.max(1, deadline - Date.now()))));
+    }
 }
 /** /learning 零副作用引导文案：命令串从 config 派生（决策12），歧义/未找到时注入主 agent。 */
 export function buildLearningGuidance(routes) {
@@ -35,7 +70,7 @@ export function buildLearningGuidance(routes) {
         '## 经验蒸馏指令（' + routes.learning + '）',
         '消化上方「链上下文 + 机械信号证据包」，蒸馏 1-3 条可复用经验（返工根因 / 阻塞原因 / 审计教训）。',
         '每条约成 LearningEntry（title 一句话≤80 字符；lesson 教训；evidence 必须填本链 chain id 作机械证据；tags 自由标签）。',
-        '调 planning_learning_save：scope=chain 存需求级 projects/<chainId>/learnings/；仓库通用经验用 scope=project（自动归入目标仓库项目级）。',
+        '调 planning_learning_save：scope=chain 存需求级 projects/<repoSlug>/<chainId>/learnings/；仓库通用经验用 scope=project（projects/<repoSlug>/learnings/，repoSlug 由链 workspaceDir 派生）。',
         '无值得沉淀的经验时，明确回复「无新经验」，不要硬凑。',
     ].join('\n');
 }

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

@@ -0,0 +1,42 @@
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { EditableSnapshot, SourceMap } from '../domain/config-override.js';
+import type { KanbanConfig } from '../config.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        swarmConfig: ConfigProvider;
+    }
+}
+export type ApplyResult = {
+    ok: true;
+    effective: EditableSnapshot;
+    sources: SourceMap;
+    changed: string[];
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare class ConfigProvider extends Service {
+    private readonly baseline;
+    private readonly overrideFile;
+    private readonly auditFile;
+    private override;
+    private effective;
+    private sources;
+    constructor(ctx: Context, baseline: KanbanConfig, storageDir: string);
+    getEffective(): KanbanConfig;
+    getSources(): SourceMap;
+    get mode(): 'remote' | 'local';
+    snapshot(): {
+        effective: EditableSnapshot;
+        sources: SourceMap;
+    };
+    applyOverride(snapshot: EditableSnapshot): ApplyResult;
+    reset(): {
+        effective: EditableSnapshot;
+        sources: SourceMap;
+    };
+    private readOverride;
+    private writeOverride;
+    private appendAudit;
+    private diffKeys;
+}

package/lib/services/config-provider.js

@@ -0,0 +1,94 @@
+import { Service } from '@deepseek-ai/cordis';
+import { readFileSync, writeFileSync, renameSync, existsSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { mergeConfig, computeSources, projectEditable, validateConfig, diffOverride, } from '../domain/config-override.js';
+export class ConfigProvider extends Service {
+    baseline;
+    overrideFile;
+    auditFile;
+    override;
+    effective;
+    sources;
+    constructor(ctx, baseline, storageDir) {
+        super(ctx, 'swarmConfig');
+        this.baseline = baseline;
+        this.overrideFile = join(storageDir, 'config-override.json');
+        this.auditFile = join(storageDir, 'config-audit.log');
+        this.override = this.readOverride();
+        this.effective = mergeConfig(baseline, this.override);
+        this.sources = computeSources(this.override);
+    }
+    getEffective() { return this.effective; }
+    getSources() { return this.sources; }
+    // mode 派生自 effective.wikiVault.baseUrl；运行期改 baseUrl 需重启 dsh 使客户端注册面同步（D11 不可热切换）：
+    // 注册期冻结（dispatcher、main-session-tools 客户端构造）与运行期活读（agent-runner guard、kanban-provider 交付闸）
+    // 分属两类读取点，中途 applyOverride 改 baseUrl 会产生混合态（后果 fail-closed 可见，不静默）。
+    get mode() { return (this.effective.wikiVault?.baseUrl ?? '').trim() ? 'remote' : 'local'; }
+    snapshot() {
+        return { effective: projectEditable(this.effective), sources: this.sources };
+    }
+    applyOverride(snapshot) {
+        const errors = validateConfig(snapshot);
+        if (errors.length)
+            return { ok: false, errors };
+        const next = diffOverride(this.baseline, snapshot);
+        const changed = this.diffKeys(this.override, next);
+        this.writeOverride(next);
+        if (changed.length)
+            this.appendAudit(changed);
+        this.override = next;
+        this.effective = mergeConfig(this.baseline, next);
+        this.sources = computeSources(next);
+        return { ok: true, effective: projectEditable(this.effective), sources: this.sources, changed };
+    }
+    reset() {
+        const next = {};
+        this.writeOverride(next);
+        this.override = next;
+        this.effective = mergeConfig(this.baseline, next);
+        this.sources = computeSources(next);
+        return { effective: projectEditable(this.effective), sources: this.sources };
+    }
+    readOverride() {
+        try {
+            if (!existsSync(this.overrideFile))
+                return {};
+            const raw = JSON.parse(readFileSync(this.overrideFile, 'utf8'));
+            return raw ?? {};
+        }
+        catch (err) {
+            console.warn('[dsh-swarm] config-override.json 损坏，回退基线: ' + String(err));
+            return {};
+        }
+    }
+    writeOverride(next) {
+        mkdirSync(dirname(this.overrideFile), { recursive: true });
+        const tmp = this.overrideFile + '.tmp-' + Date.now();
+        writeFileSync(tmp, JSON.stringify(next, null, 2));
+        renameSync(tmp, this.overrideFile);
+    }
+    appendAudit(changed) {
+        const line = new Date().toISOString() + ' | ' + changed.join(', ') + '\n';
+        try {
+            mkdirSync(dirname(this.auditFile), { recursive: true });
+            appendFileSync(this.auditFile, line);
+        }
+        catch { /* 审计失败不阻断 */ }
+    }
+    diffKeys(prev, next) {
+        const keys = new Set();
+        for (const k of ['baseUrl', 'pagePrefix']) {
+            if (prev.wikiVault?.[k] !== next.wikiVault?.[k])
+                keys.add('wikiVault.' + k);
+        }
+        for (const role of ['v', 'p', 'w', 'd', 'pt', 'dt']) {
+            for (const f of ['provider', 'model', 'reasoningEffort']) {
+                const a = prev.roles?.models?.[role]?.[f];
+                const b = next.roles?.models?.[role]?.[f];
+                if (a !== b)
+                    keys.add(`roles.models.${role}.${f}`);
+            }
+        }
+        return [...keys];
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { GateCommand } from '../domain/gate-policy.js';
+export interface GateResult {
+    command: string;
+    exitCode: number | null;
+    durationMs: number;
+    output: string;
+    truncated: boolean;
+}
+export interface GateRunReport {
+    ok: boolean;
+    results: GateResult[];
+    failure?: {
+        command: string;
+        code: 'NONZERO' | 'TIMEOUT' | 'FORBIDDEN' | 'SPAWN_FAIL';
+        detail: string;
+    };
+}
+export declare function runOne(cmd: GateCommand, timeoutMs: number): Promise<GateResult & {
+    timedOut?: boolean;
+}>;
+export declare function runGateCommands(commands: GateCommand[], cfg: {
+    timeoutMs: number;
+    forbidden: string[];
+}, run?: typeof runOne): Promise<GateRunReport>;

package/lib/services/gate-runner.js

@@ -0,0 +1,87 @@
+// src/services/gate-runner.ts
+/** kanban_complete 实测闸执行层（services 层唯一允许 child_process 之处之一）：
+ * spawn bash -c 执行 GateCommand，带超时整组 SIGKILL（detached 独立进程组，连孙进程一起杀，
+ * 防其持住 stdio 管道导致 close 不触发、Promise 挂死）、输出 256KB 截断、
+ * 黑名单子串预检（纵深防御，命中即不执行）。
+ * 命令串行执行，任一失败（FORBIDDEN/TIMEOUT/SPAWN_FAIL/NONZERO）立即返回，后续命令不再执行。 */
+import { spawn } from 'node:child_process';
+const MAX_OUTPUT = 256 * 1024;
+/** exit 后 close 迟迟不触发（如整组击杀失败、孙进程仍持管道）时的兜底 resolve 宽限 */
+const EXIT_GRACE_MS = 1000;
+export function runOne(cmd, timeoutMs) {
+    return new Promise((resolve) => {
+        const started = Date.now();
+        const child = spawn('bash', ['-c', cmd.command], {
+            cwd: cmd.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32', // 独立进程组：超时按组 SIGKILL，防孙进程持管道挂死
+        });
+        let out = '';
+        let truncated = false;
+        let timedOut = false;
+        let settled = false;
+        let exitGrace;
+        const finish = (exitCode, output) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (exitGrace !== undefined)
+                clearTimeout(exitGrace);
+            resolve({ command: cmd.command, exitCode, durationMs: Date.now() - started, output, truncated, timedOut });
+        };
+        const killGroup = () => {
+            if (child.pid === undefined) {
+                child.kill('SIGKILL');
+                return;
+            }
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch {
+                child.kill('SIGKILL');
+            }
+        };
+        const timer = setTimeout(() => { timedOut = true; killGroup(); }, timeoutMs);
+        const collect = (chunk) => {
+            if (out.length >= MAX_OUTPUT) {
+                truncated = true;
+                return;
+            }
+            out += chunk.toString('utf8');
+            if (out.length > MAX_OUTPUT) {
+                out = out.slice(0, MAX_OUTPUT);
+                truncated = true;
+            }
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.on('error', (err) => {
+            finish(null, String(err));
+        });
+        // close 需 stdio 管道全部关闭；exit 先到而 close 迟迟不来时按宽限兜底 resolve（尽力收集已到输出）
+        child.on('exit', (code) => {
+            exitGrace = setTimeout(() => finish(code, out), EXIT_GRACE_MS);
+        });
+        child.on('close', (code) => {
+            finish(code, out);
+        });
+    });
+}
+export async function runGateCommands(commands, cfg, run = runOne) {
+    const results = [];
+    for (const cmd of commands) {
+        if (cfg.forbidden.some((f) => cmd.command.includes(f))) {
+            return { ok: false, results, failure: { command: cmd.command, code: 'FORBIDDEN', detail: '黑名单命中（纵深防御，不执行）' } };
+        }
+        const r = await run(cmd, cfg.timeoutMs);
+        results.push({ command: r.command, exitCode: r.exitCode, durationMs: r.durationMs, output: r.output, truncated: r.truncated });
+        if (r.timedOut)
+            return { ok: false, results, failure: { command: r.command, code: 'TIMEOUT', detail: `超时（${cfg.timeoutMs}ms）` } };
+        if (r.exitCode === null)
+            return { ok: false, results, failure: { command: r.command, code: 'SPAWN_FAIL', detail: r.output } };
+        if (r.exitCode !== 0)
+            return { ok: false, results, failure: { command: r.command, code: 'NONZERO', detail: `退出码 ${r.exitCode}` } };
+    }
+    return { ok: true, results };
+}

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

@@ -1,6 +1,7 @@
 import { Service, type Context } from '@deepseek-ai/cordis';
 import { KanbanService } from '../domain/kanban-service.js';
 import type { KanbanConfig } from '../config.js';
+import type { ConfigProvider } from './config-provider.js';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         kanban: KanbanProvider;
@@ -12,5 +13,8 @@ export declare class KanbanProvider extends Service {
     runner: {
         runTask(taskId: string): Promise<void>;
     } | null;
-    constructor(ctx: Context, config: KanbanConfig);
+    /** 整链硬删除后的联动钩子（由 startDispatcher 装配注入）：dispatcher 游标同步 + V 编排 entry 清理。
+     *  purge 物理重排 events seq，若不同步则删链后新建链的可唤醒事件被运行中实例永久跳过。 */
+    onChainDeleted: ((chainId: string) => Promise<void> | void) | null;
+    constructor(ctx: Context, config: KanbanConfig, configProvider: ConfigProvider);
 }

package/lib/services/kanban-provider.js

@@ -1,14 +1,52 @@
 import { Service } from '@deepseek-ai/cordis';
 import { homedir } from 'node:os';
+import { spawn } from 'node:child_process';
 import { KanbanService } from '../domain/kanban-service.js';
 import { FileEventStore } from '../domain/event-store.js';
+import { deriveGatePlan, isGatePlan, branchMatches } from '../domain/gate-policy.js';
+import { runGateCommands } from './gate-runner.js';
 export class KanbanProvider extends Service {
     service;
     /** T32 fix：GUI retry 的任务执行器（由 startDispatcher 装配后注入；webServer 先于 agents 就绪时可为 null）。 */
     runner = null;
-    constructor(ctx, config) {
+    /** 整链硬删除后的联动钩子（由 startDispatcher 装配注入）：dispatcher 游标同步 + V 编排 entry 清理。
+     *  purge 物理重排 events seq，若不同步则删链后新建链的可唤醒事件被运行中实例永久跳过。 */
+    onChainDeleted = null;
+    // Task 6：经 configProvider getter 读 effective 配置——配置面板改 wikiVault.baseUrl 后 kb_url 前缀校验热生效。
+    constructor(ctx, config, configProvider) {
         super(ctx, 'kanban');
         const dir = config.storageDir.replace('$DSH_HOME', process.env.DSH_HOME ?? homedir());
-        this.service = new KanbanService(new FileEventStore(dir), config.wikiVault?.baseUrl);
+        this.service = new KanbanService(new FileEventStore(dir), () => configProvider.getEffective().wikiVault?.baseUrl);
+        // P1 实测闸装配（组合根）：complete 前派生 GatePlan → 分支一致性核对 → 实测执行。
+        // hook 绝不 throw：意外异常记日志并返回 null（零感知 skip，fail-open 与分支不一致语义一致）。
+        this.service.setGateHook(async (task, handoff) => {
+            try {
+                // 热读取（同 wikiVault.baseUrl 先例，getEffective）：配置面板改 gates 后无需重建即生效。
+                const cfg = configProvider.getEffective().gates ?? { enabled: true, timeoutMs: 600000, forbidden: ['rm -rf /', 'git push'] };
+                const plan = deriveGatePlan({ assignee: task.assignee, mode: task.mode, handoff, config: { enabled: cfg.enabled } });
+                if (!isGatePlan(plan))
+                    return null; // skip：disabled/非 D/旧卡/路径违规
+                const wt = plan.commands[0].cwd;
+                // 分支一致性核对（防报假 worktree 绕闸）：查询失败或与 metadata.branch 不一致 → skip 零感知。
+                const current = await new Promise((resolve) => {
+                    const child = spawn('git', ['-C', wt, 'rev-parse', '--abbrev-ref', 'HEAD'], { stdio: ['ignore', 'pipe', 'pipe'] });
+                    let out = '';
+                    child.stdout.on('data', (c) => { out += c.toString('utf8'); });
+                    child.on('error', () => resolve(null));
+                    child.on('close', (code) => resolve(code === 0 ? out.trim() || null : null));
+                });
+                if (!branchMatches(current, handoff.metadata?.['branch']))
+                    return null;
+                const report = await runGateCommands(plan.commands, { timeoutMs: cfg.timeoutMs, forbidden: cfg.forbidden });
+                const detail = report.ok
+                    ? plan.commands.map((c) => c.command).join(' && ') + ' exit 0'
+                    : `${report.failure.code}: ${report.failure.command} — ${report.failure.detail}\n${(report.results.at(-1)?.output ?? '').slice(-2000)}`;
+                return { ok: report.ok, detail };
+            }
+            catch (error) {
+                console.error('[dsh-swarm] gate hook failed (zero-awareness skip): ' + String(error));
+                return null;
+            }
+        });
     }
 }

package/lib/services/llm-catalog.d.ts

@@ -0,0 +1,35 @@
+export interface CatalogProvider {
+    id: string;
+    name: string;
+}
+export interface CatalogModel {
+    id: string;
+    name: string;
+    efforts: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export interface LlmCatalog {
+    providers: CatalogProvider[];
+    models: Record<string, CatalogModel[]>;
+}
+export interface LlmRuntimeLike {
+    listProviders(): Array<{
+        id: string;
+        name: string;
+    }>;
+    listModels(provider: string): Promise<Array<{
+        id: string;
+        name: string;
+    }>>;
+    resolveModelInfo(provider: string, model: string): Promise<{
+        reasoning?: {
+            efforts?: Array<{
+                id: string;
+                name: string;
+            }>;
+        };
+    }>;
+}
+export declare function buildLlmCatalog(llm: LlmRuntimeLike): Promise<LlmCatalog>;

package/lib/services/llm-catalog.js

@@ -0,0 +1,19 @@
+export async function buildLlmCatalog(llm) {
+    const providers = llm.listProviders().map((p) => ({ id: p.id, name: p.name }));
+    const models = {};
+    for (const p of providers) {
+        const list = await llm.listModels(p.id);
+        const entries = [];
+        for (const m of list) {
+            let efforts = [];
+            try {
+                const info = await llm.resolveModelInfo(p.id, m.id);
+                efforts = (info.reasoning?.efforts ?? []).map((e) => ({ id: e.id, name: e.name }));
+            }
+            catch { /* effort 解析失败 → 空 */ }
+            entries.push({ id: m.id, name: m.name, efforts });
+        }
+        models[p.id] = entries;
+    }
+    return { providers, models };
+}

package/lib/tools/kanban-tools.js

@@ -1,4 +1,5 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
+import {} from '@deepseek-ai/dsh-util-values';
 import { KanbanService } from '../domain/kanban-service.js';
 import { can } from '../domain/permissions.js';
 function guard(action, caller, task = null) {

package/lib/tools/main-session-tools.d.ts

@@ -1,5 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { KanbanConfig } from '../config.js';
+import type { PrefixRoutes } from '../config.js';
+import type { ConfigProvider } from '../services/config-provider.js';
 import { type PlanningToolDeps } from './planning-tools.js';
 import type { PlanningChecklist } from '../domain/planning-checklist.js';
 /** v2 规划上下文（/plan: 捕获 → planning_checklist_save 回写 → /openspec: 建链）。模块级内存，随插件进程存活。 */
@@ -13,8 +14,22 @@ export interface PlanningContext {
     requirementName: string | null;
 }
 export declare const planningBySession: Map<string, PlanningContext>;
+export declare const KANBAN_HANDOFF_RULE: (routes: PrefixRoutes) => string;
+/** 防线③：/openspec: 成功后的逐链确定性叙述规则（2026-09-04 mtmgp81q：模型口播 ch_1_mtjrhkrf
+ *  与工具结果 ch_1_mtmgp81q 脱节）。逐字引用锚点 + firstCard 成败结论；整包缓存回放仍可能
+ *  绕过 prompt 层——最终防线是链级看门狗（防线①）。 */
+export declare function buildOpenspecNarrationRule(r: {
+    chainId: string;
+    specCardId: string;
+    firstCard?: {
+        taskId: string;
+        status: string;
+    } | {
+        pending: true;
+    };
+}): string;
 export declare function buildSpawnPrefetch(ctx: Context): PlanningToolDeps['spawnPrefetch'] | undefined;
 /** v2 主会话工具面：/plan: 捕获规划上下文（零副作用）→ planning_checklist_save 回写 → /openspec: 用清单建链。
  *  工具面 = kanban_route + 只读 kanban 子集 + spec_card_view + planning 工具；
  *  无 spec_card_edit/approve、无 kanban_create/complete/block（主会话越权写由工具面裁剪 + prefetch 子代理只读护栏双保险）。 */
-export declare function registerMainSessionTools(ctx: Context, config: KanbanConfig): void;
+export declare function registerMainSessionTools(ctx: Context, configProvider: ConfigProvider): void;