@joekytc/dsh-swarm 0.3.2 → 0.3.6

package/lib/services/im-delivery.js

@@ -2,8 +2,13 @@ import { homedir } from 'node:os';
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { buildCompletionMessage, buildBlockMessage } from '../domain/im-message.js';
+import { createBotProbe, probeDepsFromCtx } from './im-bot-probe.js';
 const RETRYABLE_CODES = new Set(['bot-not-connected', 'delivery-failed']);
 const DEFAULT_RETRY_DELAYS_MS = [5_000, 10_000, 15_000];
+/** 机器人交互选择等待上限（5 分钟）：到点 abort 信号 + 竞速超时，按「未选择」fail-closed 不投。 */
+const ASK_TIMEOUT_MS = 300_000;
+/** 「设为默认」选项文案：提问与应答解析共用一处，改文案两处同步（字符串比对，无 id 兜底）。 */
+const ASK_SET_DEFAULT_LABEL = '设为默认';
 /** dsh-im 未安装的可识别错误前缀（0.3.1：缺插件属环境问题不重试，直接友好提醒安装）。 */
 export const DSH_IM_MISSING_PREFIX = 'dsh-im-not-installed';
 const DSH_IM_MISSING_ERROR = `${DSH_IM_MISSING_PREFIX}: 未检测到 dsh-im 插件服务，请先安装并启用 @xmanrui/dsh-im（安装后重启 dsh 生效）`;
@@ -23,35 +28,115 @@ function resolveDshIm(ctx, log) {
     }
     return svc;
 }
-/** botId/targetId 解析（评审决议）：配置显式指定优先；留空自动发现唯一 wecom bot + 唯一已保存目标（按 kind）。
- *  群/私聊各自仅且只有一个——发现异常返回 error（调用方留痕不投，fail-closed——投错对象比不投更糟）。 */
-export async function resolveTarget(im, cfg, kind) {
-    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;
+/** 交互选项展示文案：脱敏名 + id（id 是唯一可靠标识，展示名可能重名）。 */
+function askLabel(o) {
+    return o.label ? `${o.label}（${o.botId}）` : o.botId;
+}
+/** 多机器人且无法自动决策时的 fail-closed 报错：列候选（有探针数据则带模式与连接态）。 */
+function botCandidatesError(ids, probed) {
+    const byId = new Map(probed.map((b) => [b.botId, b]));
+    const list = ids.map((id) => {
+        const c = byId.get(id);
+        if (!c)
+            return id;
+        return `${id}(${c.label || '未命名'}·${c.agentPreset || '未设模式'}${c.connected ? '' : '·离线'})`;
+    }).join(' / ');
+    return `企微机器人数量=${ids.length}（期望 1），无法自动确定投递对象。候选：${list}。请在插件配置 imDelivery.botId 显式指定，或在可交互的手动投递会话重试以选择`;
+}
+/** 机器人决策链：显式配置 → 唯一机器人 → 会话 preset 命中 → 默认机器人 → 交互选择。
+ *  每环都 fail-closed（宁可不投也不投错对象）；探针不可用只失去自动匹配能力，不阻断投递。 */
+export async function chooseBot(im, cfg, deps) {
+    const explicit = cfg.botId.trim();
+    if (explicit)
+        return { ok: true, botId: explicit, via: 'explicit' };
+    const wecom = (await im.listBots()).filter((b) => b.channel === 'wecom');
+    if (wecom.length === 0) {
+        return { ok: false, error: '未检测到企微机器人接入：请先在 dsh-im 设置→IM机器人 接入机器人后重试' };
     }
+    const ids = wecom.map((b) => b.botId);
+    if (ids.length === 1)
+        return { ok: true, botId: ids[0], via: 'single' };
+    const fallback = (cfg.fallbackBotId ?? '').trim();
+    const preset = (deps.sessionPreset ?? '').trim();
+    // 只有「能模式匹配」或「能交互」时才值得探针：纯自动路径 + 无默认 → 直接给候选报错，省一次握手。
+    const probed = (preset || deps.ask) ? await deps.probe() : { ok: false, error: 'probe-skipped' };
+    if (!probed.ok && (preset || deps.ask))
+        deps.log(`[im-delivery] bot probe unavailable: ${probed.error}`);
+    const candidates = probed.ok ? probed.bots.filter((b) => ids.includes(b.botId)) : [];
+    if (preset && candidates.length) {
+        const hit = candidates.filter((b) => b.connected && b.agentPreset === preset);
+        if (hit.length === 1)
+            return { ok: true, botId: hit[0].botId, via: 'preset' };
+        deps.log(hit.length > 1
+            ? `[im-delivery] preset ${preset} 命中 ${hit.length} 个已连接机器人，不唯一，转默认/交互`
+            : `[im-delivery] preset ${preset} 未命中已连接机器人（候选模式：${candidates.map((b) => b.agentPreset || '未设').join(', ') || '无元数据'}），转默认/交互`);
+    }
+    if (fallback && ids.includes(fallback))
+        return { ok: true, botId: fallback, via: 'fallback' };
+    if (fallback)
+        deps.log(`[im-delivery] 默认机器人 ${fallback} 不在接入列表，转交互`);
+    if (!deps.ask)
+        return { ok: false, error: botCandidatesError(ids, candidates) };
+    const options = ids.map((id) => {
+        const c = candidates.find((b) => b.botId === id);
+        if (!c)
+            return { botId: id, label: '' };
+        return { botId: id, label: `${c.label || '未命名'}·${c.agentPreset || '未设模式'}${c.connected ? '' : '·离线'}` };
+    });
+    const answer = await deps.ask(options);
+    if (!answer)
+        return { ok: false, error: '未选择投递机器人（交互取消或超时），本次不投递' };
+    if (!answer.setDefault || !deps.setFallback)
+        return { ok: true, botId: answer.botId, via: 'interactive' };
+    const saved = await deps.setFallback(answer.botId);
+    if (!saved)
+        deps.log('[im-delivery] 默认机器人写入失败（配置未更新），本次仍按所选机器人投递');
+    return { ok: true, botId: answer.botId, via: 'interactive', fallbackSaved: saved };
+}
+/** dsh-im 目标列表（宿主同 Host 服务返回裸数组；防御兼容 Connection RPC `target.list` 信封形状）。 */
+async function readTargets(im, botId) {
+    const raw = await im.listTargets(botId);
+    if (Array.isArray(raw))
+        return raw;
+    const enveloped = raw?.targets;
+    return Array.isArray(enveloped) ? enveloped : [];
+}
+/** targetId 解析：配置显式指定优先；留空自动发现该机器人下唯一已保存目标（按 kind）。
+ *  群/私聊各自仅且只有一个——发现异常返回 error（调用方留痕不投，fail-closed）。
+ *  机器人非显式指定（preset/默认/交互选出）而配置又填死了 targetId 时先校验归属：
+ *  targetId 是 per-bot 作用域，填错机器人只会落成 dsh-im 的 unknown-target，这里提前给可行动报错。 */
+export async function resolveTargetId(im, botId, botIdExplicit, cfg, kind) {
     const explicit = (kind === 'group' ? cfg.targetId : cfg.dmTargetId ?? '').trim();
-    let targetId = explicit;
-    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 matched = targets.filter((x) => x.kind === kind);
-        const label = kind === 'group' ? '群目标' : '私聊目标';
-        const cfgHint = kind === 'group' ? 'imDelivery.targetId' : 'imDelivery.dmTargetId';
-        if (matched.length !== 1) {
-            const candidates = matched.length > 1 ? '，候选：' + matched.map((x) => `${x.targetId}${x.name ? `(${x.name})` : ''}`).join(' / ') : '';
-            return { error: `已保存${label}数量=${matched.length}（期望 1，仅且只有一个）${candidates}。请到 dsh-im 设置→IM机器人 ${matched.length > 1 ? '清理多余目标' : '新建目标'}或在插件配置 ${cfgHint} 显式指定` };
-        }
-        targetId = matched[0].targetId;
+    const label = kind === 'group' ? '群目标' : '私聊目标';
+    const cfgHint = kind === 'group' ? 'imDelivery.targetId' : 'imDelivery.dmTargetId';
+    if (explicit) {
+        if (botIdExplicit)
+            return { targetId: explicit };
+        const targets = await readTargets(im, botId);
+        const owned = targets.some((x) => x.targetId === explicit);
+        if (owned)
+            return { targetId: explicit };
+        return { error: `${cfgHint}=${explicit} 不属于本轮选定的机器人 ${botId}（targetId 按机器人隔离）。请清空该字段改由自动发现，或显式指定 imDelivery.botId 固定机器人` };
+    }
+    const targets = await readTargets(im, botId);
+    const matched = targets.filter((x) => x.kind === kind);
+    if (matched.length !== 1) {
+        const candidates = matched.length > 1 ? '，候选：' + matched.map((x) => `${x.targetId}${x.name ? `(${x.name})` : ''}`).join(' / ') : '';
+        return { error: `已保存${label}数量=${matched.length}（期望 1，仅且只有一个）${candidates}。请到 dsh-im 设置→IM机器人 ${matched.length > 1 ? '清理多余目标' : '新建目标'}或在插件配置 ${cfgHint} 显式指定` };
     }
-    return { botId, targetId };
+    return { targetId: matched[0].targetId };
+}
+/** botId+targetId 一步解析（无交互/无探针的简化入口，保留给单机器人场景与单测）。 */
+export async function resolveTarget(im, cfg, kind) {
+    const choice = await chooseBot(im, cfg, {
+        sessionPreset: null, probe: async () => ({ ok: false, error: 'probe-skipped' }), ask: null, setFallback: null, log: () => { },
+    });
+    if (!choice.ok)
+        return { error: choice.error };
+    const t = await resolveTargetId(im, choice.botId, cfg.botId.trim() !== '', cfg, kind);
+    if ('error' in t)
+        return t;
+    return { botId: choice.botId, targetId: t.targetId };
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** 发送 + 退避重试（仅可重试错误码；{sent:true} 即停——dsh-im 无幂等，成功后绝不重发）。 */
@@ -88,13 +173,90 @@ function makeDefaultLog(storageDir) {
         catch { /* 忽略写失败 */ }
     };
 }
-/** 发送器工厂：resolveDshIm → resolveTarget（fail-closed）→ sendWithRetry → 留痕。
+/** 交互选择接线（仅手动投递路径）：两问一次弹——选机器人 + 是否设为默认。
+ *  agent 必传（exec.agent 的 live 实例）：GUI 弹窗按 agent 路由；无询问通道返回 null（调用方 fail-closed 列候选），
+ *  取消/超时/服务端拒绝同样返回 null（不投），失败原因进日志（只带错误码，不含任何敏感载荷）。 */
+function buildBotAsk(ctx, agent, log) {
+    const uq = ctx.get?.('userQuestions');
+    if (typeof uq?.ask !== 'function') {
+        log('[im-delivery] 机器人交互不可用：无 userQuestions 服务');
+        return null;
+    }
+    return async (options) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => { controller.abort(); }, ASK_TIMEOUT_MS);
+        try {
+            const ans = await Promise.race([
+                uq.ask({
+                    questions: [
+                        {
+                            id: 'im-bot',
+                            header: '投递机器人',
+                            question: '本轮企微投递用哪个机器人？（当前会话模式未匹配到任何机器人）',
+                            detail: '展示名·默认模式；离线机器人不保证能发出。选择只作用于本次投递。',
+                            options: options.map((o) => ({ label: askLabel(o), description: o.botId })),
+                        },
+                        {
+                            id: 'im-bot-default',
+                            header: '设为默认',
+                            question: '是否把所选机器人设为默认机器人？（之后模式未命中时直接使用，不再询问）',
+                            detail: '写入插件配置 imDelivery.fallbackBotId（可在设置面板看到来源标记）。',
+                            options: [{ label: ASK_SET_DEFAULT_LABEL }, { label: '仅本次' }],
+                        },
+                    ],
+                    ...(agent === undefined ? {} : { agent }),
+                    signal: controller.signal,
+                }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('im-bot-ask-timeout')), ASK_TIMEOUT_MS)),
+            ]);
+            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 ?? '';
+            if (!botId) {
+                log('[im-delivery] 机器人交互已应答但未映射到候选（selected 与候选不符）');
+                return null;
+            }
+            const setDefault = (ans.answers?.find((a) => a.id === 'im-bot-default')?.selected ?? []).includes(ASK_SET_DEFAULT_LABEL);
+            return { botId, setDefault };
+        }
+        catch (err) {
+            const code = err.code;
+            const name = err.name;
+            log(`[im-delivery] 机器人交互未完成: ${typeof code === 'string' && code ? code : typeof name === 'string' && name ? name : 'unknown'}`);
+            return null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+}
+/** 写默认机器人接线：经 ConfigProvider.applyOverride 落 config-override.json + 审计留痕。 */
+function buildSetFallback(configProvider) {
+    return async (botId) => {
+        try {
+            const snap = configProvider.snapshot().effective;
+            return configProvider.applyOverride({ ...snap, imDelivery: { fallbackBotId: botId } }).ok;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/** 发送器工厂：resolveDshIm → chooseBot（fail-closed）→ resolveTargetId → 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;
     const targetKind = opts.targetKind ?? 'group';
+    // 探针单飞缓存挂在发送器上（连发 /sms 不重复握手）；交互与写默认只在手动路径接线（后台 auto 路径无人应答）。
+    const probe = opts.botChoice?.probe ?? createBotProbe(probeDepsFromCtx(ctx));
+    const ask = opts.botChoice?.ask !== undefined ? opts.botChoice.ask
+        : (opts.manual ? buildBotAsk(ctx, opts.agent, log) : null);
+    const setFallback = opts.botChoice?.setFallback !== undefined ? opts.botChoice.setFallback
+        : (opts.manual ? buildSetFallback(configProvider) : null);
     return async (chainId, text) => {
         const cfg = configProvider.getEffective().imDelivery;
         const im = resolveDshIm(ctx, log);
@@ -111,15 +273,22 @@ export function createSender(ctx, kanban, configProvider, opts = {}) {
             }
             return { ok: false, error: DSH_IM_MISSING_ERROR };
         }
-        const t = await resolveTarget(im, cfg, targetKind);
+        const choice = await chooseBot(im, cfg, {
+            sessionPreset: opts.sessionPreset ?? null, probe, ask, setFallback, log,
+        });
+        if (!choice.ok) {
+            log(`[im-delivery] bot resolve failed chain=${chainId}: ${choice.error}`);
+            return { ok: false, error: choice.error };
+        }
+        const t = await resolveTargetId(im, choice.botId, cfg.botId.trim() !== '', cfg, targetKind);
         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);
+        const r = await sendWithRetry(im, choice.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 };
+            log(`[im-delivery] delivered chain=${chainId} bot=${choice.botId} target=${t.targetId} via=${choice.via}`);
+            return { ok: true, botId: choice.botId, targetId: t.targetId, via: choice.via, ...(choice.fallbackSaved === undefined ? {} : { fallbackSaved: choice.fallbackSaved }) };
         }
         // 超限显形（评审决议）：dispatcher.log 留痕；auto 路径追加 events.jsonl 双留痕；投递失败绝不 block 链。
         log(`[im-delivery] FAILED chain=${chainId}: ${r.error}`);
@@ -266,7 +435,7 @@ export async function sendChainReport(ctx, kanban, configProvider, opts, variant
             ? { ok: false, error: r.error, guidance: DSH_IM_MISSING_GUIDANCE }
             : { ok: false, error: r.error };
     }
-    return { ok: true, chainId, botId: r.botId, targetId: r.targetId };
+    return { ok: true, chainId, botId: r.botId, targetId: r.targetId, via: r.via, ...(r.fallbackSaved === undefined ? {} : { fallbackSaved: r.fallbackSaved }) };
 }
 /** 接线：订阅看板事件多播通道（不动 setOnTaskCompleted 单消费者钩子）。
  *  listener 同步返回，投递全程 fire-and-forget 自兜异常（publish 在 emit 队列内同步调用，不得拖慢落盘）。 */
@@ -279,8 +448,9 @@ export function wireImDelivery(ctx, kanban, configProvider, opts = {}) {
             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'))
+            // 仅 task/completed（带 taskId）/ chain/blocked / review/gave-up 关心事件流；其余早退，避免每个无关事件触发 snapshot 全量重放。
+            // 2026-09-15：+ review/gave-up（评审超限待裁决）——不再静默等看门狗 block，人工在 gave-up 时刻即获通知与两条出口。
+            if (!((ev.kind === 'task/completed' && ev.taskId) || ev.kind === 'chain/blocked' || ev.kind === 'review/gave-up'))
                 return;
             const state = await kanban.snapshot();
             if (ev.kind === 'task/completed' && ev.taskId) {
@@ -295,6 +465,22 @@ export function wireImDelivery(ctx, kanban, configProvider, opts = {}) {
                 const msg = buildBlockMessage(state, ev.chainId, String(ev.payload['reason'] ?? ''), storageDir);
                 await deliver(ev.chainId, msg);
             }
+            else if (ev.kind === 'review/gave-up') {
+                const chain = state.chains.get(ev.chainId);
+                if (!chain)
+                    return;
+                const reviewTaskId = String(ev.payload['reviewTaskId'] ?? '');
+                const targetTaskId = String(ev.payload['targetTaskId'] ?? '');
+                const msg = [
+                    `【评审超限待裁决】${chain.title || ev.chainId} 的评审卡 ${reviewTaskId} 超限放弃（${String(ev.payload['reason'] ?? '')}）。`,
+                    `被评审卡：${targetTaskId}`,
+                    '两条出口：',
+                    '① 人工豁免评审 → 计划评审按通过继续（GUI 任务详情「豁免评审」按钮 / 主会话 kanban_waive_review）；',
+                    '② 人工恢复链后按需返工（GUI 链头「人工恢复」按钮 / 主会话 kanban_reopen_chain）。',
+                    '若无人处置，看门狗将在链持续无进展后把链置 blocked（届时可人工恢复）。',
+                ].join('\n');
+                await deliver(ev.chainId, msg);
+            }
         })().catch((err) => log('[im-delivery] handler failed ev=' + ev.kind + ': ' + String(err)));
     };
     return kanban.subscribe(handle);

package/lib/tools/kanban-tools.js

@@ -2,6 +2,7 @@ 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';
+import { resolveReviewTarget } from '../domain/review-target.js';
 function guard(action, caller, task = null) {
     if (!can(action, caller.actor, task))
         throw new Error('permission denied: ' + action);
@@ -92,7 +93,7 @@ export function buildKanbanTools(service, getCaller) {
             parameters: {
                 taskId: { type: 'string', required: true },
                 summary: { type: 'string', required: true, description: 'Human-readable completion summary' },
-                metadata: { type: 'json', description: 'Machine-readable handoff: changed_files/verification/kb_url...' },
+                metadata: { type: 'json', description: 'Machine-readable handoff: changed_files/verification/kb_url... W3/kb may add report = { requirement, status, branch, tasks: [{ text, done }], acceptance, verification, leftovers?, todos? } (delivery-report fields; tasks mirrors the OpenSpec plan checklist openspec/changes/<id>/tasks.md verbatim, done = checked)' },
             },
             output: { schema: { type: 'json' }, render: (_a, v) => [{ type: 'text', text: JSON.stringify(v) }] },
             async execute(args) {
@@ -166,5 +167,41 @@ export function buildKanbanTools(service, getCaller) {
                 return task;
             },
         }),
+        // 人工恢复能力（2026-09-15）：仅 human（caller.actor 由主会话/角色装配注入；角色工具面不暴露这两个工具）。
+        defineTool({
+            name: 'kanban_reopen_chain',
+            description: 'Reopen a blocked chain back to executing (human only; reason required).',
+            parameters: {
+                chainId: { type: 'string', required: true, description: 'Chain id (ch_xxx)' },
+                reason: { type: 'string', required: true, description: 'Recovery reason (audited)' },
+            },
+            output: { schema: { type: 'json' }, render: (_a, v) => [{ type: 'text', text: JSON.stringify(v) }] },
+            async execute(args) {
+                const caller = getCaller();
+                const ev = await service.reopenChain(args.chainId, args.reason, caller.actor);
+                return ev;
+            },
+        }),
+        defineTool({
+            name: 'kanban_waive_review',
+            description: 'Waive a failed/gave-up review card for its target task (human only; reason required).',
+            parameters: {
+                taskId: { type: 'string', required: true, description: 'Review card id (pt/dt card)' },
+                reason: { type: 'string', required: true, description: 'Waive reason (audited)' },
+            },
+            output: { schema: { type: 'json' }, render: (_a, v) => [{ type: 'text', text: JSON.stringify(v) }] },
+            async execute(args) {
+                const caller = getCaller();
+                const state = await service.snapshot();
+                const reviewTask = state.tasks.get(args.taskId);
+                if (!reviewTask)
+                    throw new Error('unknown review task: ' + args.taskId);
+                const target = resolveReviewTarget(state, reviewTask, reviewTask.chainId);
+                if (!target)
+                    throw new Error('review target not resolvable for ' + args.taskId);
+                const ev = await service.waiveReview(args.taskId, target.root.id, args.reason, caller.actor);
+                return ev;
+            },
+        }),
     ];
 }

package/lib/tools/main-session-tools.js

@@ -131,6 +131,16 @@ function buildFreeSendGuidance(routes, query, dm) {
         '投递结果只向用户确认成功与目标，不复述正文；失败时把 error/guidance 原样转告，勿编造原因。',
     ].join('\n');
 }
+/** 当前会话 preset（多机器人投递按它匹配机器人的默认 dsh 模式）。
+ *  header.agentPreset 缺省（用默认模式创建的会话可能不落该字段）→ 回落到 agentPresets.defaultId；
+ *  两者都拿不到返回空串，调用方按「无模式匹配」处理（走默认机器人/交互，绝不猜）。 */
+function sessionPresetOf(ctx, exec) {
+    const fromHeader = exec?.agent?.session?.header?.agentPreset;
+    if (typeof fromHeader === 'string' && fromHeader.trim())
+        return fromHeader.trim();
+    const presets = ctx.get?.('agentPresets');
+    return typeof presets?.defaultId === 'string' ? presets.defaultId : '';
+}
 /** v2 主会话工具面：/plan: 捕获规划上下文（零副作用）→ planning_checklist_save 回写 → /openspec: 建链。
  *  工具面 = kanban_route + 只读 kanban 子集 + spec_card_view + planning 工具；
  *  无 spec_card_edit/approve、无 kanban_create/complete/block（主会话越权写由工具面裁剪 + prefetch 子代理只读护栏双保险）。 */
@@ -150,8 +160,10 @@ export function registerMainSessionTools(ctx, configProvider) {
         ? new LocalWikiClient(ensureLocalKbRoot())
         : (ctx.get('wiki') ?? new WikiVaultClient(() => configProvider.getEffective().wikiVault));
     const caller = () => ({ actor: 'human' });
-    // 只读 kanban 子集（无 create/complete/block）
-    const readOnly = new Set(['kanban_show', 'kanban_chain', 'kanban_list', 'kanban_comment']);
+    // 主会话 kanban 工具子集（无 create/complete/block）。2026-09-15 恢复能力：+ 人工恢复双工具
+    //（kanban_reopen_chain / kanban_waive_review）——主会话 caller 恒为 human（服务层再校验 can()），
+    // 角色 toolsets 名单不动（角色工具面零暴露）。
+    const readOnly = new Set(['kanban_show', 'kanban_chain', 'kanban_list', 'kanban_comment', 'kanban_reopen_chain', 'kanban_waive_review']);
     for (const tool of buildKanbanTools(service, caller)) {
         const name = tool.name;
         if (name && readOnly.has(name))
@@ -232,15 +244,23 @@ export function registerMainSessionTools(ctx, configProvider) {
                 // 其余非空 rest → 自由投递（正文由主 agent 按意图生成，显式豁免；事实基准=看板实查）。
                 // -s 独立 token 由 parseSendRequest 剥离置 dm；manual 路径零重试。
                 const parsed = parseSendRequest(plan.rest);
-                const targetOpts = { retryDelaysMs: [], manual: true, targetKind: (parsed.dm ? 'user' : 'group') };
+                const targetOpts = {
+                    retryDelaysMs: [], manual: true,
+                    targetKind: (parsed.dm ? 'user' : 'group'),
+                    sessionPreset: sessionPresetOf(ctx, exec),
+                    agent: exec?.agent,
+                };
                 const deliver = async (variant, query) => {
                     const r = await sendChainReport(ctx, service, configProvider, targetOpts, variant, query);
                     if (r.ok) {
                         const noun = variant === 'blocked' ? '阻塞通知' : '完成汇报';
                         const dest = parsed.dm ? '私聊' : '群聊';
+                        const via = r.via === 'interactive' ? `（本次交互选定${r.fallbackSaved ? '，已设为默认' : ''}）`
+                            : r.via === 'fallback' ? '（未命中会话模式，走默认机器人）'
+                                : r.via === 'preset' ? '（按会话模式匹配机器人）' : '';
                         return {
-                            kind: 'send', chainId: r.chainId, botId: r.botId, targetId: r.targetId,
-                            guidance: `${noun}已投递${dest}（/sms 手动触发）。请仅向用户确认投递成功与目标，勿复述消息正文。`,
+                            kind: 'send', chainId: r.chainId, botId: r.botId, targetId: r.targetId, via: r.via,
+                            guidance: `${noun}已投递${dest}${via}（/sms 手动触发）。请仅向用户确认投递成功与目标，勿复述消息正文。`,
                         };
                     }
                     return { kind: 'send', error: r.error, guidance: r.guidance ?? '请将 error 字段原样转告用户，勿复述消息正文。' };
@@ -328,7 +348,7 @@ export function registerMainSessionTools(ctx, configProvider) {
             dm: { type: 'boolean', description: 'true = private chat; omit/false = group' },
         },
         output: { schema: { type: 'json' }, render: (_a, v) => [{ type: 'text', text: JSON.stringify(v) }] },
-        async execute(args) {
+        async execute(args, exec) {
             // actor 边界与 planning 工具同构：主会话工具面仅限人工触发，非 human caller 一律拒绝
             if (caller().actor !== 'human')
                 throw new Error('permission denied: sms_send');
@@ -338,7 +358,10 @@ export function registerMainSessionTools(ctx, configProvider) {
             if (text.length > 4000)
                 throw new Error(`text too long: ${text.length} > 4000 chars`);
             const dm = args.dm === true;
-            const deliver = createSender(ctx, service, configProvider, { retryDelaysMs: [], manual: true, targetKind: dm ? 'user' : 'group' });
+            const deliver = createSender(ctx, service, configProvider, {
+                retryDelaysMs: [], manual: true, targetKind: dm ? 'user' : 'group',
+                sessionPreset: sessionPresetOf(ctx, exec), agent: exec?.agent,
+            });
             const r = await deliver('free-send', text);
             if (!r.ok) {
                 return {
@@ -347,8 +370,10 @@ export function registerMainSessionTools(ctx, configProvider) {
                 };
             }
             return {
-                kind: 'send', mode: 'free', dm, botId: r.botId, targetId: r.targetId,
-                guidance: '已投递（自由投递）。请仅向用户确认投递成功与目标（群聊/私聊），勿复述正文。',
+                kind: 'send', mode: 'free', dm, botId: r.botId, targetId: r.targetId, via: r.via,
+                guidance: '已投递（自由投递）。请仅向用户确认投递成功与目标（群聊/私聊），勿复述正文。'
+                    + (r.fallbackSaved === true ? '已按你的选择把该机器人设为默认机器人（后续模式未命中时直接使用）。' : '')
+                    + (r.fallbackSaved === false ? '注意：设为默认未写入成功（配置未更新），下次仍需重新选择。' : ''),
             };
         },
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joekytc/dsh-swarm",
-  "version": "0.3.2",
+  "version": "0.3.6",
   "description": "A governed swarm of six specialist DSH agents (orchestrator, planner, knowledge-base bridge, developer and two reviewers) that turns a requirement into a strict phase pipeline with machine-verified delivery evidence, review-gated merges, a full audit-log event stream and a live kanban tab; design inspired by the Hermes Agent kanban",
   "license": "MIT",
   "author": "joekytc",

package/personas/kanban-p/agent.cordis.yml

@@ -60,6 +60,22 @@
       explicit protocol name) and how the plan complies with it; if no protocol is declared,
       write 「无」 in that section. Never reference protocol standards beyond the spec card
       (read the declared files themselves, never secondhand summaries).
+      10. Requirement alignment (granularity): every task item / task point / note in the
+      clarification checklist / spec card must map BOTH ways to plan tasks — nothing missing;
+      anything beyond scope must trace back to a clarification answer.
+      11. Logical/interaction consistency: the plan must not contradict itself; slice/task
+      dependency order must be executable. When impl_decisions offer multiple options, converge
+      to a single path inside the plan — no left-open branches (e.g. "render per the current
+      page data source"); declared boundaries/error handling must have task mappings.
+      12. Structural readiness — stage-free criteria: a done criterion MUST describe a single
+      terminal state after implementation is complete. Do NOT write execution-layer staged
+      criteria (RED/GREEN/REFACTOR, "fail first then pass") — those belong to the D-phase
+      execution protocol (see the D-phase instruction template); process notes may stay as
+      non-acceptance remarks only.
+      13. Rework rounds (2026-09-15): when the task body contains a 「本轮修复清单」 (fix-this-round)
+      section, KEEP the existing task numbering and fix ONLY the listed items — never renumber
+      tasks and never rewrite/expand unrelated parts of the plan (each rewrite grows the review
+      surface and blocks convergence).
 
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'

package/personas/kanban-pt/agent.cordis.yml

@@ -32,7 +32,16 @@
       - Engineering-protocol consistency: only reconcile against the 「上游协议遵循说明」
       section of proposal.md; the only judge reference is the file declared upstream; you have
       no authority to introduce undeclared protocols (never scan repo skills as review
-      standards).
+      standards). TDD (RED/GREEN/REFACTOR) is a pipeline-built-in execution-layer protocol
+      (D-phase requirement) and is NOT in your protocol-reconciliation scope — when the plan
+      contains staged criteria, ask for final-state criteria per rule 4 (stable terminal
+      state); never fail it as an "undeclared upstream protocol".
+      - Review-source positivity (2026-09-15): your review source is the spec-card functional
+      surface (problem/solution/user_stories/testing plus explicit server-side constraints)
+      plus the plan text. Environment/tooling/credential/permission/API-source matters (e.g.
+      "a task must prove no reference to project X") are OUTSIDE the requirement and must NOT
+      be blocking criteria — put such findings in non-blocking suggestions for the execution
+      phase (D API integration / joint retest) to verify.
       2. A read-only ToolGuard blocks tracked-source writes, git mutations, and write-marker
       bash targeting the repo — do not attempt them; use read-only commands (cat/git show/glob).
       3. Write the review conclusion into kanban_complete metadata review_evidence =
@@ -53,6 +62,15 @@
       carried over as-is / partially fixed resolved=false with the remaining part in detail), then
       raise new issues; unfixed prior issues MUST stay in the issues list. Never skip
       reconciliation and only raise new issues.
+      Legacy marking (2026-09-15 convergence gate): reconciliation entries MUST carry legacy: true;
+      newly raised issues carry legacy: false (or omit). The system uses this to detect whether the
+      legacy backlog is cleared — while it is not, rework continues; once cleared, only unresolved
+      CRITICAL findings may keep the verdict at fail — all other new findings are downgraded into
+      downstream non-blocking suggestions (this round counts as passed).
+      Convergence expectation: do not keep failing with finer-grained NEW dimensions in the same
+      round where the legacy backlog was fixed (e.g. from "one criterion per protocol" down to
+      import-level, or from behavior splits down to symbol-level). New issues must fall inside the
+      five existing elements and trace back to an upstream declaration or an internal contradiction.
       5. Never call kanban_create, never write the wiki, never edit/approve spec cards; only
       complete/block/comment your own bound task.
       6. Use kanban_show/kanban_list/kanban_complete/kanban_block/kanban_heartbeat/

package/personas/kanban-w/agent.cordis.yml

@@ -44,6 +44,21 @@
       for a human; never hand in an empty complete.
       8. Use kanban_* + web_search/web_fetch + (remote: wiki_search/wiki_read/wiki_write | local:
       skill) + prefetch_file/prefetch_external/prefetch_kb + spec_card_view (read-only).
+      9. Sandbox discipline (2026-09-15): this session may already run at danger-full-access (the
+      permission ceiling — e.g. after the session permission was switched to 完全权限, or after a
+      one-shot escalation was approved). NEVER attach `sandbox_permissions` or `justification` to
+      ANY tool call (bash/write/edit/run_code/...): when the current mode is already the ceiling,
+      any value is rejected by the host with "sandbox escalation ... is not strictly wider than
+      this call's current ... mode". If a call was rejected that way, DROP the parameter and retry
+      with bare arguments — never retry with the parameter attached (it keeps failing).
+      10. Chain closing report (W3/kb only): when the repo carries an OpenSpec plan
+      (openspec/changes/*/tasks.md), read its checkbox state and attach metadata.report to
+      kanban_complete: { requirement, status, branch, tasks: [{ text, done }], acceptance,
+      verification, leftovers?, todos? }. tasks mirrors the plan checklist verbatim (done =
+      checked; unchecked items stay false — failures belong in leftovers, never flipped to done).
+      requirement/status/branch/acceptance/verification are one-line factual strings (branch from
+      the D handoff, status from the chain outcome). These fields render verbatim into the
+      delivered WeCom report — keep them factual; omit report entirely when no OpenSpec plan exists.
 
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'

package/personas/persona-p.md

@@ -14,3 +14,7 @@
 8. complete 时 metadata 必须带 `pt_decision`：`{ needed: boolean, reason?: string }`（needed=true 时 reason 必填）。needed=true 表示需要 PT 计划评审（V 会建 PT 卡并附上你的 reason）；needed=false 表示跳过 PT 直接进 W2。
 9. tasks.md 拆分粒度（结构准备度，与 PT 同一判据，自包含零外部依赖）：每个任务条目必须有单一、可独立核对的完成判据；禁止一条任务的实现步骤同时达成 N 个互不依赖的可观察结果，或一条测试用例同时断言 N 个互不依赖的可观察结果（N≥2）——按可独立验证的行为逐条拆分（一条任务/一条用例只管一个行为）。
 10. proposal.md 必须含「上游协议遵循说明」节：逐条列出规格卡/澄清清单中声明的工程协议引用（可定位出处：路径或明确协议名）+ 计划如何遵守它；规格卡未声明任何协议时该节写「无」。禁止引用规格卡之外的协议标准（读声明的原文，不读二手转述）。
+11. **需求对齐（颗粒度）**：澄清清单/规格卡的任务项、任务点、注意点 ↔ 计划任务必须**逐条双向映射**——不遗漏；超纲任务须能溯源到澄清回答。
+12. **逻辑交互一致性**：计划内部不得自相矛盾；slice/任务依赖顺序必须可执行。impl_decisions 存在多方案时必须在计划内**收敛为唯一路径**，不得留"按当前页面数据源渲染"式未定分支；已声明的边界/错误处理必须有任务映射。
+13. **结构准备度补充（不写执行层阶段态判据）**：RED/GREEN/REFACTOR、"先失败再通过"等属 D 阶段执行层协议——计划任务的完成判据必须是**实施完成后的单一可核对终态**，不写阶段态判据（过程说明可作非验收备注，不作为任务或协议要求）。
+14. **返工轮约束（2026-09-15）**：本卡为返工轮时，**沿用既有任务编号、只做任务体「本轮修复清单」内条目的定点修复**；禁止重排编号、禁止与清单无关的全文重写与扩写（每轮重写会扩大判据面并阻塞收敛）。

package/personas/persona-pt.md

@@ -9,12 +9,15 @@
    - 完整性：solution/impl_decisions 覆盖所有需求点；每个任务有可核对的完成判据。
    - 逻辑交互一致性：计划内部无自相矛盾；slice/任务依赖顺序可执行。
    - 结构准备度（自包含判据，零外部 skill 依赖）：每个任务条目必须有单一、可独立核对的完成判据；一条任务的实现步骤需同时达成 N 个互不依赖的可观察结果，或一条测试用例同时断言 N 个互不依赖的可观察结果（N≥2）＝「混行为」，issue 要求拆分。判定只看计划文本自身，不引用、不要求出现任何执行层字样（RED/GREEN/命名窄测等）。
-   - 工程协议一致性：只对账 proposal.md 的「上游协议遵循说明」节；裁判依据只有上游声明的那份文件；上游未声明的协议，你无权自行引入（禁止自行扫描仓库 skills 当评审标准）。
+   - 工程协议一致性：只对账 proposal.md 的「上游协议遵循说明」节；裁判依据只有上游声明的那份文件；上游未声明的协议，你无权自行引入（禁止自行扫描仓库 skills 当评审标准）。**TDD（RED/GREEN/REFACTOR）属链路内置执行层协议（D 阶段硬要求），不在协议对账范围**——计划里出现执行层阶段态判据时，按第 4 条「稳定终态」口径要求改为最终态判据即可，不得以此判"引入上游未声明协议"。
+   - **评审源正相关（2026-09-15）**：评审源 = 规格卡功能面（problem/solution/user_stories/testing 及明确的服务端约束）+ 计划文本。**环境/工具/凭证/权限/接口来源等需求外事项不得作为阻断性判据**（例如"必须新增任务证明未引用某项目接口/未读取某项目文档"）——此类内容既非需求、也无需求来源，有价值时置为非阻塞建议，由执行环节（D 接口对接、联调回测）验证。
 2. 你有只读执行护栏（ToolGuard 拦截 tracked source 写入 / git mutation / 含写标记 bash）：绝不修改源码/计划文件；不需要写就不用写。
 3. 评审结论写进 kanban_complete 的交接 metadata.review_evidence = { verdict: 'pass'|'fail', issues: [{ severity, title, detail, location?, resolved }], ... }：
    - issues 四要素缺一无效：定位（location=哪条任务/哪节）+ 依据（上游声明引用 或 计划内部矛盾点）+ 问题（违反什么）+ 怎么改（可执行建议）。
    - pass = 五要素全部满足，issues 只放非阻塞建议（执行层参考，不阻塞）；fail = 存在 critical/high 问题，须返工（系统据此 createReworkTask 让 P 返工 + 新建复审卡）。
    - 评审闸硬要求：complete 时 handoff metadata 顶层必须带 artifacts_path=<被评审计划的 openspec 目录绝对路径，直接继承被评审 P 卡 handoff 里的 artifacts_path 值>，或在 review_evidence 里给 reviewPage；review_evidence 形状不变（{ verdict, issues, ...reviewPage 可选 }）——两者都缺时评审闸拒绝 pass。
 4. 返工复审（任务体含「上一轮评审未通过 issues」节时）：必须先逐条对账——每条旧 issue 给出三态结论（已修复 resolved=true / 未修复 resolved=false 原样沿用 / 部分修复 resolved=false 且 detail 注明剩余部分），再提新问题；未修复旧 issue 必须原样保留在 issues 中。禁止跳过对账只提新问题。
+   - **legacy 标记（2026-09-15 收敛闸）**：对账条目（来自「上一轮评审未通过 issues」）必须写 `legacy: true`；本轮新发现的问题写 `legacy: false` 或省略。系统据此判定"旧账是否清零"——旧账未清 → 继续返工；旧账清零后**仅未解决的 critical 允许继续判 fail**，其余新问题会被降级为下游「评审遗留建议」（本轮按通过处理）。
+   - **收敛预期**：不要在旧账已修复的同一轮用"更细的新维度"继续判 fail（如把"每协议一个判据"再细化到 import 级、把"行为拆分"再细化到符号级）；新问题必须落在五要素既有判据内，且能溯源到上游声明或计划内部矛盾点。
 5. 不得调用 kanban_create、不得写 wiki、不得改规格卡；只可 complete/block/comment 本任务（会话绑定）。
 6. 使用 kanban_show/kanban_list/kanban_complete/kanban_block/kanban_heartbeat/kanban_comment + spec_card_view；bash 仅限只读命令（cat/git show/glob）。

package/personas/persona-w.md

@@ -12,3 +12,4 @@
 6. 不得创建任务、不得批准/编辑规格卡；不得越权操作其他任务（只可 complete/block 本任务，会话绑定）。
 7. KB（任一模式）不可达时 kanban_block(reason=kb-unreachable) 等人工；绝不放行空 complete。
 8. 工具面按模式分支：kanban_* + web_search/web_fetch（联网检索外部事实）+（远程：wiki_search/wiki_read/wiki_write ｜ 本地：skill）+ prefetch_file/prefetch_external/prefetch_kb + spec_card_view（只读）。
+9. **沙箱纪律**：本会话可能已处于 danger-full-access（权限天花板——例如会话权限被切到「完全权限」，或审批提权过一次后）。**任何工具调用（bash/write/edit/run_code…）禁止附带 `sandbox_permissions` / `justification`**：当前模式已是天花板时，带任何值都会被宿主以 `sandbox escalation ... is not strictly wider than this call's current ... mode` 拒绝。若某次调用因此被拒，**去掉该参数后用裸参数重试**，绝不带参重试（会持续失败）。

package/personas/swarm/agent.cordis.yml

@@ -42,3 +42,14 @@
   name: '@deepseek-ai/dsh-agent-instructions'
   config:
     maxBytes: 65536
+
+# ── skills ──
+- id: skill-filesystem
+  name: '@deepseek-ai/dsh-skill-filesystem'
+
+- id: tool-skill
+  name: '@deepseek-ai/dsh-tool-skill'
+
+# ── web ──
+- id: tool-web
+  name: '@deepseek-ai/dsh-tool-web'