@joekytc/dsh-swarm 0.1.2 → 0.3.0

package/lib/services/config-provider.js

@@ -0,0 +1,92 @@
+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 使客户端注册面同步（不可热切换）：
+    // 注册期冻结（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 };
+    }
+    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}`);
+            }
+        }
+        if (prev.reviewEngine?.mode !== next.reviewEngine?.mode)
+            keys.add('reviewEngine.mode');
+        for (const f of ['provider', 'model']) {
+            if (prev.reviewEngine?.managed?.[f] !== next.reviewEngine?.managed?.[f])
+                keys.add('reviewEngine.managed.' + 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/im-delivery.d.ts

@@ -0,0 +1,94 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { KanbanService } from '../domain/kanban-service.js';
+import type { BoardState } from '../domain/types.js';
+import type { ConfigProvider } from './config-provider.js';
+/** dsh-im 宿主服务结构接口（形状以 @xmanrui/dsh-im PROACTIVE_DELIVERY.md 为准，运行时守卫校验）。
+ *  listTargets 证据（2026-09-07）：PROACTIVE_DELIVERY.md:176 `const targets = await ctx.dshIm.listTargets(botId);
+ *  // [{ targetId, name?, kind, route }, ...]`；宿主 lib/index.js 实现为
+ *  `listTargets: async Y => (await H.listTargets(Y)).targets`（同 Host 服务返回裸数组）。
+ *  `{ botId, channel, targets }` 是 Connection RPC `target.list` 的信封形状，与同 Host 服务不同。 */
+export interface DshImLike {
+    send(botId: string, targetId: string, text: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        sent?: boolean;
+    }>;
+    listBots(): Promise<Array<{
+        botId: string;
+        channel: string;
+    }>>;
+    listTargets(botId: string): Promise<Array<{
+        targetId: string;
+        name?: string;
+        kind: string;
+        route: Record<string, string>;
+    }>>;
+}
+export interface ImDeliveryOptions {
+    /** 缺省写 storageDir/dispatcher.log（[im-delivery] 前缀；评审决议落盘位置）。 */
+    log?: (msg: string) => void;
+    /** 重试退避间隔（ms）；测试传 [0,0,0]。 */
+    retryDelaysMs?: number[];
+    /** 手动投递路径（/sms）：失败仅 dispatcher.log 留痕，不写 chain/im-delivery-failed 链事件（用户同步可见错误）。 */
+    manual?: boolean;
+}
+export declare function isDshImLike(svc: unknown): svc is DshImLike;
+/** botId/targetId 解析（评审决议）：配置显式指定优先；留空自动发现唯一 wecom bot + 唯一已保存群目标；
+ *  发现异常返回 error（调用方留痕不投，fail-closed——投错群比不投更糟）。 */
+export declare function resolveTarget(im: DshImLike, cfg: {
+    botId: string;
+    targetId: string;
+}): Promise<{
+    botId: string;
+    targetId: string;
+} | {
+    error: string;
+}>;
+/** 发送 + 退避重试（仅可重试错误码；{sent:true} 即停——dsh-im 无幂等，成功后绝不重发）。 */
+export declare function sendWithRetry(im: DshImLike, botId: string, targetId: string, text: string, delays: number[], log: (m: string) => void): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** 发送器工厂：resolveDshIm → resolveTarget（fail-closed）→ sendWithRetry → 留痕。
+ *  auto 路径（wireImDelivery）失败额外写 chain/im-delivery-failed 链事件；
+ *  manual 路径（/sms，opts.manual）仅 dispatcher.log 留痕，错误同步返回给调用方。 */
+export declare function createSender(ctx: Context, kanban: KanbanService, configProvider: ConfigProvider, opts?: ImDeliveryOptions): (chainId: string, text: string) => Promise<{
+    ok: true;
+    botId: string;
+    targetId: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+export type ReportVariant = 'completion' | 'blocked';
+/** /sms 链解析（纯函数）。空 query：completion=最近满足 W3 完成判据的链（最后完成事件 at 最大）；
+ *  blocked=最近阻塞的链（chain/blocked 事件 at 最大）。显式 query：全量链精确/后缀解析后再验判据。 */
+export declare function resolveReportChainId(state: BoardState, variant: ReportVariant, query: string): {
+    ok: true;
+    chainId: string;
+} | {
+    ok: false;
+    error: string;
+    candidates?: Array<{
+        chainId: string;
+        title: string;
+    }>;
+};
+/** /sms 手动投递：解析链 → 领域函数渲染正文（红线：正文只出自 buildCompletionMessage/buildBlockMessage，
+ *  绝不返回给模型）→ createSender 发送。不受 imDelivery.enabled 门控（显式人工调用即意图），
+ *  但仍要求 dshIm 服务在位且形状合法、目标可解析（同 auto 路径 fail-closed 规则）。 */
+export declare function sendChainReport(ctx: Context, kanban: KanbanService, configProvider: ConfigProvider, opts: ImDeliveryOptions, variant: ReportVariant, query: string): Promise<{
+    ok: true;
+    chainId: string;
+    botId: string;
+    targetId: string;
+} | {
+    ok: false;
+    error: string;
+    guidance?: string;
+}>;
+/** 接线：订阅看板事件多播通道（不动 setOnTaskCompleted 单消费者钩子）。
+ *  listener 同步返回，投递全程 fire-and-forget 自兜异常（publish 在 emit 队列内同步调用，不得拖慢落盘）。 */
+export declare function wireImDelivery(ctx: Context, kanban: KanbanService, configProvider: ConfigProvider, opts?: ImDeliveryOptions): () => void;

package/lib/services/im-delivery.js

@@ -0,0 +1,263 @@
+import { homedir } from 'node:os';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildCompletionMessage, buildBlockMessage } from '../domain/im-message.js';
+const RETRYABLE_CODES = new Set(['bot-not-connected', 'delivery-failed']);
+const DEFAULT_RETRY_DELAYS_MS = [5_000, 10_000, 15_000];
+export function isDshImLike(svc) {
+    const s = svc;
+    return typeof s === 'object' && s !== null
+        && typeof s.send === 'function'
+        && typeof s.listBots === 'function'
+        && typeof s.listTargets === 'function';
+}
+function resolveDshIm(ctx, log) {
+    const svc = ctx.get('dshIm');
+    if (!isDshImLike(svc)) {
+        log('[im-delivery] dshIm 服务缺失或形状不符，显式降级跳过（本次不投递）');
+        return null;
+    }
+    return svc;
+}
+/** botId/targetId 解析（评审决议）：配置显式指定优先；留空自动发现唯一 wecom bot + 唯一已保存群目标；
+ *  发现异常返回 error（调用方留痕不投，fail-closed——投错群比不投更糟）。 */
+export async function resolveTarget(im, cfg) {
+    let botId = cfg.botId.trim();
+    if (!botId) {
+        const bots = await im.listBots();
+        const wecom = bots.filter((b) => b.channel === 'wecom');
+        if (wecom.length !== 1)
+            return { error: `企微机器人数量=${wecom.length}（期望 1），请在插件配置 imDelivery.botId 显式指定` };
+        botId = wecom[0].botId;
+    }
+    let targetId = cfg.targetId.trim();
+    if (!targetId) {
+        const raw = await im.listTargets(botId);
+        // 宿主同 Host 服务返回裸数组（PROACTIVE_DELIVERY.md:176）；防御兼容 Connection RPC `target.list` 信封形状。
+        const targets = Array.isArray(raw) ? raw : Array.isArray(raw?.targets)
+            ? raw.targets
+            : [];
+        const groups = targets.filter((x) => x.kind === 'group');
+        if (groups.length !== 1)
+            return { error: `已保存群目标数量=${groups.length}（期望 1），请到 dsh-im 设置→IM机器人 新建目标或在插件配置 imDelivery.targetId 显式指定` };
+        targetId = groups[0].targetId;
+    }
+    return { botId, targetId };
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** 发送 + 退避重试（仅可重试错误码；{sent:true} 即停——dsh-im 无幂等，成功后绝不重发）。 */
+export async function sendWithRetry(im, botId, targetId, text, delays, log) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            const r = await im.send(botId, targetId, text);
+            if (r?.sent !== true) {
+                const e = new Error('dsh-im send 返回 sent!==true');
+                e.code = 'delivery-failed';
+                throw e;
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            const code = err.code ?? 'delivery-failed';
+            if (attempt >= delays.length || !RETRYABLE_CODES.has(code)) {
+                return { ok: false, error: `${code}: ${String(err)}` };
+            }
+            log(`[im-delivery] send failed (attempt ${attempt + 1}, code=${code})，retry after ${delays[attempt]}ms 后重试`);
+            await sleep(delays[attempt]);
+        }
+    }
+}
+/** storageDir 派生（config 占位符 $DSH_HOME 替换；auto 与 /sms 手动路径同源）。 */
+function deriveStorageDir(configProvider) {
+    return configProvider.getEffective().storageDir.replace('$DSH_HOME', process.env.DSH_HOME ?? homedir());
+}
+function makeDefaultLog(storageDir) {
+    return (msg) => {
+        try {
+            writeFileSync(join(storageDir, 'dispatcher.log'), new Date().toISOString() + ' ' + msg + '\n', { flag: 'a' });
+        }
+        catch { /* 忽略写失败 */ }
+    };
+}
+/** 发送器工厂：resolveDshIm → resolveTarget（fail-closed）→ sendWithRetry → 留痕。
+ *  auto 路径（wireImDelivery）失败额外写 chain/im-delivery-failed 链事件；
+ *  manual 路径（/sms，opts.manual）仅 dispatcher.log 留痕，错误同步返回给调用方。 */
+export function createSender(ctx, kanban, configProvider, opts = {}) {
+    const log = opts.log ?? makeDefaultLog(deriveStorageDir(configProvider));
+    const delays = opts.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+    return async (chainId, text) => {
+        const cfg = configProvider.getEffective().imDelivery;
+        const im = resolveDshIm(ctx, log);
+        if (!im)
+            return { ok: false, error: 'dshIm 服务缺失或形状不符（需 @xmanrui/dsh-im 宿主服务）' };
+        const t = await resolveTarget(im, cfg);
+        if ('error' in t) {
+            log(`[im-delivery] target resolve failed chain=${chainId}: ${t.error}`);
+            return { ok: false, error: t.error };
+        }
+        const r = await sendWithRetry(im, t.botId, t.targetId, text, delays, log);
+        if (r.ok) {
+            log(`[im-delivery] delivered chain=${chainId} bot=${t.botId} target=${t.targetId}`);
+            return { ok: true, botId: t.botId, targetId: t.targetId };
+        }
+        // 超限显形（评审决议）：dispatcher.log 留痕；auto 路径追加 events.jsonl 双留痕；投递失败绝不 block 链。
+        log(`[im-delivery] FAILED chain=${chainId}: ${r.error}`);
+        if (!opts.manual) {
+            try {
+                await kanban.noteImDeliveryFailed(chainId, `企微投递失败（重试 ${delays.length} 次后放弃）：${r.error}`, 'system');
+            }
+            catch (err) {
+                log(`[im-delivery] noteImDeliveryFailed failed chain=${chainId}: ` + String(err));
+            }
+        }
+        return { ok: false, error: r.error };
+    };
+}
+/** 链上最后一个带 taskId 的 task/completed 事件（state.events 按 seq 有序）。 */
+function lastCompleted(state, chainId) {
+    const last = state.events.filter((e) => e.chainId === chainId && e.kind === 'task/completed' && e.taskId).at(-1);
+    return last?.taskId ? { taskId: last.taskId, at: last.at } : null;
+}
+function lastChainBlockedAt(state, chainId) {
+    const last = state.events.filter((e) => e.chainId === chainId && e.kind === 'chain/blocked').at(-1);
+    return last?.at ?? -1;
+}
+/** 全量链内按 精确 id → 唯一 id 后缀 解析（/learning UX：歧义返回候选列表）。 */
+function findByIdOrSuffix(chains, query) {
+    const exact = chains.find((c) => c.id === query);
+    if (exact)
+        return { ok: true, chainId: exact.id };
+    const matches = chains.filter((c) => c.id.endsWith(query));
+    if (matches.length === 1)
+        return { ok: true, chainId: matches[0].id };
+    if (matches.length === 0)
+        return { ok: false, error: 'chain-not-found' };
+    return { ok: false, error: 'chain-ambiguous', candidates: matches.map((c) => ({ chainId: c.id, title: c.title })) };
+}
+/** /sms 链解析（纯函数）。空 query：completion=最近满足 W3 完成判据的链（最后完成事件 at 最大）；
+ *  blocked=最近阻塞的链（chain/blocked 事件 at 最大）。显式 query：全量链精确/后缀解析后再验判据。 */
+export function resolveReportChainId(state, variant, query) {
+    const q = query.trim();
+    const chains = [...state.chains.values()];
+    if (variant === 'blocked') {
+        const blockedChains = chains.filter((c) => c.status === 'blocked');
+        if (!q) {
+            if (blockedChains.length === 0)
+                return { ok: false, error: 'chain-not-found' };
+            let best = blockedChains[0];
+            let bestAt = lastChainBlockedAt(state, best.id);
+            for (const c of blockedChains.slice(1)) {
+                const at = lastChainBlockedAt(state, c.id);
+                if (at > bestAt) {
+                    best = c;
+                    bestAt = at;
+                }
+            }
+            return { ok: true, chainId: best.id };
+        }
+        const resolved = findByIdOrSuffix(chains, q);
+        if (!resolved.ok)
+            return resolved;
+        const chain = state.chains.get(resolved.chainId);
+        if (chain.status !== 'blocked')
+            return { ok: false, error: 'not-blocked' };
+        return { ok: true, chainId: chain.id };
+    }
+    // completion：判据即 buildCompletionMessage !== null（W3 收尾机械判据，防 W2 中间态误报）
+    const candidates = chains.filter((c) => {
+        const lc = lastCompleted(state, c.id);
+        return lc !== null && buildCompletionMessage(state, c.id, lc.taskId, Date.now()) !== null;
+    });
+    if (!q) {
+        if (candidates.length === 0)
+            return { ok: false, error: 'chain-not-found' };
+        let best = candidates[0];
+        let bestAt = lastCompleted(state, best.id)?.at ?? -1;
+        for (const c of candidates.slice(1)) {
+            const at = lastCompleted(state, c.id)?.at ?? -1;
+            if (at > bestAt) {
+                best = c;
+                bestAt = at;
+            }
+        }
+        return { ok: true, chainId: best.id };
+    }
+    const resolved = findByIdOrSuffix(chains, q);
+    if (!resolved.ok)
+        return resolved;
+    if (!candidates.some((c) => c.id === resolved.chainId))
+        return { ok: false, error: 'completion-not-met' };
+    return { ok: true, chainId: resolved.chainId };
+}
+/** /sms 失败 guidance（主会话模型原样转述给用户；绝不生成消息正文）。 */
+function reportGuidance(error, candidates, sendCmd) {
+    if (error === 'chain-ambiguous' && candidates?.length) {
+        const list = candidates.map((c) => `- ${c.chainId} ${c.title}`).join('\n');
+        return `匹配到多条链，请用 ${sendCmd} <chainId> 精确指定：\n${list}`;
+    }
+    if (error === 'chain-not-found')
+        return `未找到可汇报的链。可用 ${sendCmd} <chainId> 指定（完成后自动汇报的链），或 ${sendCmd} blocked [chainId] 重发阻塞通知。`;
+    if (error === 'completion-not-met')
+        return '该链不满足完成汇报判据（W3 未收尾或中间态）。';
+    if (error === 'not-blocked')
+        return '链未处于阻塞态，无阻塞通知可发。';
+    return '投递失败，请将 error 字段原样转告用户，勿自行编造原因、勿复述消息正文。';
+}
+/** /sms 手动投递：解析链 → 领域函数渲染正文（红线：正文只出自 buildCompletionMessage/buildBlockMessage，
+ *  绝不返回给模型）→ createSender 发送。不受 imDelivery.enabled 门控（显式人工调用即意图），
+ *  但仍要求 dshIm 服务在位且形状合法、目标可解析（同 auto 路径 fail-closed 规则）。 */
+export async function sendChainReport(ctx, kanban, configProvider, opts, variant, query) {
+    const state = await kanban.snapshot();
+    const resolved = resolveReportChainId(state, variant, query);
+    if (!resolved.ok) {
+        return { ok: false, error: resolved.error, guidance: reportGuidance(resolved.error, resolved.candidates, configProvider.getEffective().prefixRoutes.send) };
+    }
+    const chainId = resolved.chainId;
+    let text;
+    if (variant === 'completion') {
+        const lc = lastCompleted(state, chainId);
+        const rendered = lc !== null ? buildCompletionMessage(state, chainId, lc.taskId, Date.now()) : null;
+        if (rendered === null)
+            return { ok: false, error: 'completion-not-met' };
+        text = rendered;
+    }
+    else {
+        const reason = state.events.filter((e) => e.chainId === chainId && e.kind === 'chain/blocked').at(-1)?.payload['reason'];
+        text = buildBlockMessage(state, chainId, String(reason ?? ''), deriveStorageDir(configProvider));
+    }
+    const r = await createSender(ctx, kanban, configProvider, { ...opts, manual: true })(chainId, text);
+    if (!r.ok)
+        return { ok: false, error: r.error };
+    return { ok: true, chainId, botId: r.botId, targetId: r.targetId };
+}
+/** 接线：订阅看板事件多播通道（不动 setOnTaskCompleted 单消费者钩子）。
+ *  listener 同步返回，投递全程 fire-and-forget 自兜异常（publish 在 emit 队列内同步调用，不得拖慢落盘）。 */
+export function wireImDelivery(ctx, kanban, configProvider, opts = {}) {
+    const storageDir = deriveStorageDir(configProvider);
+    const log = opts.log ?? makeDefaultLog(storageDir);
+    const deliver = createSender(ctx, kanban, configProvider, opts);
+    const handle = (ev) => {
+        void (async () => {
+            const cfg = configProvider.getEffective().imDelivery;
+            if (!cfg?.enabled)
+                return; // 功能关闭：零开销早退（非异常，不留痕）
+            // 仅 task/completed（带 taskId）与 chain/blocked 关心事件流；其余早退，避免每个无关事件触发 snapshot 全量重放
+            if (!((ev.kind === 'task/completed' && ev.taskId) || ev.kind === 'chain/blocked'))
+                return;
+            const state = await kanban.snapshot();
+            if (ev.kind === 'task/completed' && ev.taskId) {
+                const msg = buildCompletionMessage(state, ev.chainId, ev.taskId, Date.now());
+                if (msg)
+                    await deliver(ev.chainId, msg);
+            }
+            else if (ev.kind === 'chain/blocked') {
+                const chain = state.chains.get(ev.chainId);
+                if (!chain)
+                    return;
+                const msg = buildBlockMessage(state, ev.chainId, String(ev.payload['reason'] ?? ''), storageDir);
+                await deliver(ev.chainId, msg);
+            }
+        })().catch((err) => log('[im-delivery] handler failed ev=' + ev.kind + ': ' + String(err)));
+    };
+    return kanban.subscribe(handle);
+}

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;
@@ -8,9 +9,12 @@ declare module '@deepseek-ai/cordis' {
 }
 export declare class KanbanProvider extends Service {
     readonly service: KanbanService;
-    /** T32 fix：GUI retry 的任务执行器（由 startDispatcher 装配后注入；webServer 先于 agents 就绪时可为 null）。 */
+    /** GUI retry 的任务执行器（由 startDispatcher 装配后注入；webServer 先于 agents 就绪时可为 null）。 */
     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）。 */
+    /** GUI retry 的任务执行器（由 startDispatcher 装配后注入；webServer 先于 agents 就绪时可为 null）。 */
     runner = null;
-    constructor(ctx, config) {
+    /** 整链硬删除后的联动钩子（由 startDispatcher 装配注入）：dispatcher 游标同步 + V 编排 entry 清理。
+     *  purge 物理重排 events seq，若不同步则删链后新建链的可唤醒事件被运行中实例永久跳过。 */
+    onChainDeleted = null;
+    // 经 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;
+            }
+        });
     }
 }