dsh-punky-swarm 0.3.6

package/lib/api.js

@@ -0,0 +1,266 @@
+/*
+Copyright (C) 2025-2026 Punky
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+// dsh-punky-swarm 只读治理 API：batches / batch / mailbox / locks / stream（全部按 session 隔离）
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import * as mailbox from './comms/mailbox.js';
+import { createStreamHub } from './panel/stream.js';
+// P1 批 R-07 排除项（承接归 panel 批）：事件读端字面量收敛——EVT 常量源 lib/state/event-types.js（P2-07 单点）
+import * as EVT from './state/event-types.js';
+
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.end(body);
+}
+
+function q(url) {
+  return Object.fromEntries(new URL(url, 'http://localhost').searchParams.entries());
+}
+
+export function createApi(ctx, deps) {
+  const { store, root, catalog, agentCatalog, aipFormat, discovery } = deps;
+  const disposers = [];
+  const register = (route) => disposers.push(ctx.webServer.register(route));
+
+  // R3 SSE hub（设计 §3.3.3）：随 webServer 挂载（ADR-4：无独立配置键；降级回轮询即运行时自适配开关）。
+  // 装配点（index.js 层，exec-a 批②）预留时经 deps.panelStream 注入复用（含 topic 触发源 attachTopic 接线）；
+  // 缺省自建（fs.watch 单通道先行交付——契约移交点语义），自建者负责 dispose。
+  const panelStream = deps.panelStream || createStreamHub({ root, logger: ctx.logger });
+  if (!deps.panelStream) disposers.push(() => { try { panelStream.dispose(); } catch {} });
+
+  register({
+    kind: 'prefix',
+    path: '/api/dsh-punky-swarm',
+    handler(req, res) { sendJson(res, 404, { error: 'not-found' }); },
+  });
+
+  register({
+    kind: 'exact',
+    path: '/api/dsh-punky-swarm/batches',
+    handler(req, res) {
+      try {
+        const { session } = q(req.url);
+        if (!session) return sendJson(res, 400, { error: 'session required' });
+        const batches = store.listBatches(session).map((id) => {
+          const b = store.readBatch(session, id);
+          return { batchId: id, session, phase: b.phase, lanes: b.lanes, settled: store.batchSettled(b), eventCount: b.events.length };
+        });
+        sendJson(res, 200, { session, batches });
+      } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+    },
+  });
+
+  register({
+    kind: 'exact',
+    path: '/api/dsh-punky-swarm/sessions',
+    handler(req, res) {
+      try {
+        // 全部有批次的 session 概览（含每 session 批次计数）
+        const sessions = store.listSessions().map((s) => ({ sessionId: s, batchCount: store.listBatches(s).length }));
+        sendJson(res, 200, { sessions });
+      } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+    },
+  });
+
+  register({
+    kind: 'exact',
+    path: '/api/dsh-punky-swarm/batch',
+    handler(req, res) {
+      try {
+        const { batchId, session } = q(req.url);
+        if (!batchId) return sendJson(res, 400, { error: 'batchId required' });
+        if (!session) return sendJson(res, 400, { error: 'session required' });
+        const b = store.readBatch(session, batchId);
+        if (!b) return sendJson(res, 404, { error: 'batch-not-found' });
+        // 每 lane attempt（review->running 返工计数）与升级标记（>=3）由事件推导
+        const laneAttempts = {};
+        const upgrades = {};
+        for (const e of b.events) {
+          if (e.type === EVT.EVT_MEMBER_SETTLED && e.from === 'review' && e.to === 'running') {
+            laneAttempts[e.lane] = (laneAttempts[e.lane] ?? 0) + 1;
+          }
+        }
+        for (const lane of Object.keys(b.lanes)) {
+          upgrades[lane] = (laneAttempts[lane] ?? 0) >= 3 && (b.lanes[lane] === 'review' || b.lanes[lane] === 'failed');
+        }
+        sendJson(res, 200, {
+          batchId: b.batchId, session, phase: b.phase, concurrency: b.concurrency,
+          lanes: b.lanes, wavePlan: b.wavePlan,
+          eventCount: b.events.length, recentEvents: b.events.slice(-20),
+          settled: store.batchSettled(b),
+          autoReleaseable: store.batchAutoReleaseable(b),
+          viewSettled: (b.phase === 'complete' || b.phase === 'aborted') ? true : store.batchSettled(b),
+          laneAttempts,
+          upgrades,
+          lanesGate: Object.fromEntries(Object.keys(b.lanes).map((l) => [l, store.gateStatus(session, batchId, l)])),
+          // P6 接线（exec-format-wire）：装配注入 aipFormat 时附 ACPs Session 投影（纯函数，不改存储；缺省不附 → 既有响应不变）
+          ...(aipFormat ? { aipSession: aipFormat.toAipSession(b) } : {}),
+        });
+      } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+    },
+  });
+
+  register({
+    kind: 'exact',
+    path: '/api/dsh-punky-swarm/mailbox',
+    handler(req, res) {
+      try {
+        const { batchId, box, lane, session } = q(req.url);
+        if (!batchId || !box) return sendJson(res, 400, { error: 'batchId+box required' });
+        if (!session) return sendJson(res, 400, { error: 'session required' });
+        // P2-08：box 枚举校验——非法 box 返回 400（含枚举提示）而非透传进 mailbox.readUnacked 抛错兜成 500
+        const BOXES = ['inbox', 'outbox', 'broadcast'];
+        if (!BOXES.includes(box)) {
+          return sendJson(res, 400, { error: 'invalid box: ' + box + ' (allowed: ' + BOXES.join(' | ') + ')' });
+        }
+        // 可选加固：outbox 分支 lane 必填（readUnacked 按 lane 读 outbox，缺 lane 属调用错误）
+        if (box === 'outbox' && !lane) return sendJson(res, 400, { error: 'lane required for outbox' });
+        const b = box === 'outbox' ? { type: 'outbox', lane } : { type: box };
+        const items = mailbox.readUnacked(join(root, 'sessions', session, 'mailbox', batchId), b);
+        // P6 接线（exec-format-wire）：装配注入 aipFormat 时逐条附 ACPs Message 投影（纯函数投影，不改 mailbox 存储与 ack 语义）
+        sendJson(res, 200, aipFormat ? { items: items.map((it) => ({ ...it, aip: aipFormat.toAipMessage(it) })) } : { items });
+      } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+    },
+  });
+
+  register({
+    kind: 'exact',
+    path: '/api/dsh-punky-swarm/locks',
+    handler(req, res) {
+      try {
+        const { session } = q(req.url);
+        if (!session) return sendJson(res, 400, { error: 'session required' });
+        const locksDir = join(root, 'sessions', session, '.locks');
+        const locks = existsSync(locksDir) ? readdirSync(locksDir).map((f) => {
+          try { return { lock: f, ...JSON.parse(readFileSync(join(locksDir, f), 'utf8')) }; }
+          catch { return { lock: f }; }
+        }) : [];
+        sendJson(res, 200, { session, locks });
+      } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+    },
+  });
+
+  // 国标 AIP 工具列表同步（方案 A：只读 API 端点）：catalog 非空（缺省默认开启）时注册 /tools；
+  // 仅显式 aip.enabled=false 时 catalog 为 null，不注册该路由（保持既有 6 路由契约）。
+  // catalog 由 register.js 经 readCapability 默认合并口径提供——本条件与 enabled 联动，此处零逻辑改动。
+  if (catalog) {
+    register({
+      kind: 'exact',
+      path: '/api/dsh-punky-swarm/tools',
+      handler(req, res) {
+        try {
+          const { name } = q(req.url);
+          const tools = name ? catalog.list().filter((d) => d.name === name) : catalog.list();
+          sendJson(res, 200, { count: tools.length, tools, generatedAt: catalog.generatedAt });
+        } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+      },
+    });
+  }
+
+  // P4 ACS 智能体描述目录：enabled=true 时 agentCatalog 非空，注册 /agents；
+  // 端点输出 ACS 字段集（AgentCapabilitySpec，逐字字段见 lib/aip/agent-descriptor.js）；只读、无参。
+  // enabled=false（默认）时 agentCatalog 为 null，不注册该路由（既有路由契约不变）。
+  if (agentCatalog) {
+    register({
+      kind: 'exact',
+      path: '/api/dsh-punky-swarm/agents',
+      handler(req, res) {
+        try {
+          const agents = agentCatalog.list();
+          sendJson(res, 200, { count: agents.length, agents, generatedAt: agentCatalog.generatedAt });
+        } catch (e) { sendJson(res, 500, { error: String(e.message) }); }
+      },
+    });
+  }
+  // 国标 P5 发现服务（ADP 语义）：discovery 服务实例注入时注册
+  //   POST /api/dsh-punky-swarm/discover — 统一发现查询（DiscoveryRequest → DiscoveryResponse）
+  //   GET  /.well-known/aip          — 发现服务预置信息（地址/协议版本/能力概要）
+  if (discovery) {
+    register({
+      kind: 'exact',
+      path: '/api/dsh-punky-swarm/discover',
+      handler(req, res) {
+        return readJsonBody(req).then((body) => {
+          const resp = discovery.discover(body);
+          // 响应码映射：ADP 错误（result 缺省、error 存在）→ 400（客户端 4xxxx）/ 500（服务端 5xxxx）；成功 → 200
+          const status = resp.error
+            ? (String(resp.error.code).startsWith('5') ? 500 : 400)
+            : 200;
+          sendJson(res, status, resp);
+        }).catch((e) => sendJson(res, 500, { error: { code: 50001, message: 'InternalError', data: String(e.message) } }));
+      },
+    });
+    register({
+      kind: 'exact',
+      path: '/.well-known/aip',
+      handler(req, res) {
+        try {
+          sendJson(res, 200, discovery.wellKnown());
+        } catch (e) { sendJson(res, 500, { error: { code: 50001, message: 'InternalError', data: String(e.message) } }); }
+      },
+    });
+  }
+
+  // R3 SSE 端点（设计 §3.3.3，纯新增路由——既有 /api 路由一字不动）：
+  //   GET /api/dsh-punky-swarm/stream?session=<sid>[&batchId=<bid>]
+  //   SSE 帧协议：event: batch|mailbox|heartbeat + data:<JSON>；注释心跳帧每 10s（hub 内维护）。
+  //   推送只发轻量摘要 {sessionId,batchId,eventCount,updatedAt}，客户端回拉既有只读 API 取全量（ADR-5）。
+  register({
+    kind: 'exact',
+    path: '/api/dsh-punky-swarm/stream',
+    handler(req, res) {
+      try {
+        const { session, batchId } = q(req.url);
+        if (!session) return sendJson(res, 400, { error: 'session required' });
+        const st = panelStream.subscribe(session, batchId || null, res);
+        if (!st.ok) {
+          // 会话级连接数上限（≤8）→ 503；其余（缺 session/handshake 失败）→ 400
+          const status = st.reason === 'limit' ? 503 : 400;
+          try { sendJson(res, status, { error: st.reason === 'limit' ? 'too many stream connections for session' : st.reason }); } catch {}
+          return;
+        }
+      } catch (e) {
+        try { res.end(); } catch {}
+      }
+    },
+  });
+
+  return { dispose() { for (const d of disposers) { try { d?.(); } catch {} } } };
+}
+
+// 读取请求体（POST JSON）：兼容 webServer 注入的 node req（流式）与测试直调形态（req.body 预置）
+function readJsonBody(req) {
+  if (req && typeof req.body === 'string') {
+    return Promise.resolve(req.body ? JSON.parse(req.body) : {});
+  }
+  if (req && req.body && typeof req.body === 'object') {
+    return Promise.resolve(req.body);
+  }
+  if (req && typeof req.on === 'function') {
+    return new Promise((resolve, reject) => {
+      let data = '';
+      req.on('data', (chunk) => { data += chunk; });
+      req.on('end', () => {
+        try { resolve(data ? JSON.parse(data) : {}); } catch (e) { reject(e); }
+      });
+      req.on('error', reject);
+    });
+  }
+  return Promise.resolve({});
+}

package/lib/artifact-types.js

@@ -0,0 +1,48 @@
+/*
+Copyright (C) 2025-2026 Punky
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+// 通用产物类型注册表（2026-08-19，Tier3 增量）
+// 定位：通用任务治理模式——登记产物类型 → 层/目录前缀的约定，供校验与查询；
+// 不绑定任何团队模板（jiufeng 四件套只是使用者，产物内部格式归模板层）。
+// 三层目录约定：plan/（任务层）、exec/（执行层）、audit/（审计层），与 wave-plan 路径契约一致。
+
+export const ARTIFACT_TYPES = [
+  { type: 'plan',       dir: 'plan/',  layer: 'plan', desc: '任务层产物（排期/模块清单/摸底）' },
+  { type: 'spec',       dir: 'plan/',  layer: 'plan', desc: '执行规范（模板层定义内部结构）' },
+  { type: 'taskTree',   dir: 'plan/',  layer: 'plan', desc: '任务树（细拆）' },
+  { type: 'survey',     dir: 'plan/',  layer: 'plan', desc: '代码摸底报告（现状/入口/依赖/风险）' },
+  { type: 'code',       dir: 'exec/',  layer: 'exec', desc: '代码/实现产物' },
+  { type: 'testReport', dir: 'exec/',  layer: 'exec', desc: '测试报告' },
+  { type: 'review',     dir: 'audit/', layer: 'audit', desc: '审查证据' },
+  { type: 'gapList',    dir: 'audit/', layer: 'audit', desc: '差距清单' },
+  { type: 'acceptance', dir: 'audit/', layer: 'audit', desc: '验收报告' },
+  { type: 'retrospective', dir: 'audit/', layer: 'audit', desc: '复盘报告（记忆沉淀输入，记忆工具开放语义）' },
+];
+
+// 相对产物路径 → 类型名（按目录前缀匹配；绝对路径返回 null）
+export function artifactTypeOf(relPath) {
+  if (typeof relPath !== 'string') return null;
+  for (const t of ARTIFACT_TYPES) {
+    if (relPath.startsWith(t.dir)) return t.type;
+  }
+  return null;
+}
+
+// 层 → 该层注册的产物类型
+export function typesOfLayer(layer) {
+  return ARTIFACT_TYPES.filter((t) => t.layer === layer).map((t) => t.type);
+}

package/lib/assembly/audit-blind-review.js

@@ -0,0 +1,170 @@
+/*
+Copyright (C) 2025-2026 Punky
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+// 盲审编排装配数据（review-workflow 借鉴）
+// 纯数据 + 辅助函数，零依赖（被 assembly-schema.js 断言扩展视图引用，独立可加载）：
+//   - BLIND_REVIEW_ROLES / BLIND_REVIEW_SKILLS：audit-panelist/audit-aggregate/audit-critic 三角色映射
+//   - BLIND_REVIEW_TEMPLATES：六任务契约模板（bundle/panelist/aggregate/critic/checklist/config，键名固定供断言）
+//   - applyAssemblyExtensions(assembly, extensions)：装配扩展合并（默认关——blindReview 未启用时原样返回，base 一字不改）
+//   - buildAuditLaneSpec({panelistCount, deps})：Leader/Manager 建批用——生成盲审子 lane 任务包骨架
+//     （consume/produce 契约 + 模板引用；不预写实现，0e 不越权；可直接喂 buildWavePlan 走 wavePlan 固定 DAG）
+// 范围红线：零引擎改动（wave-plan.js / gates.js / store.js 等一律不碰）——盲审 = 装配数据 + 既有工具编排。
+
+// ── 三角色映射（layer=audit，skills 手册前缀；Leader 显式声明或经 applyAssemblyExtensions 合并补全）──
+export const BLIND_REVIEW_ROLES = ['audit-panelist', 'audit-aggregate', 'audit-critic'];
+
+export const BLIND_REVIEW_SKILLS = {
+  'audit-panelist': ['report-blind-audit', 'code-review-guideline'], // 事实核验 + 对抗式打分（rubric/checklist）
+  'audit-aggregate': ['report-blind-audit'],                          // 锚定一致性 + Δ 分级裁决 + 加权聚合
+  'audit-critic': ['report-blind-audit'],                             // 独立复核 + 三态决议（endorse/challenge/block）
+};
+
+// ── 叠加顺序（verify 自动证据 → 盲审可选 → needHuman 人工闸；verify blocked 直接升级人工不进入盲审）──
+// 文档化常量：Leader/Manager 建批参照；三原则 = ① verify 内容证据底座（先跑、自动）② 盲审质量评审编排（后跑、可选）
+// ③ needHuman 人工闸（最后、引擎强制 gates.js checkNeedHumanGate）。任一层的 produce 都进 Tier3 门禁（缺则拒 merged）。
+export const BLIND_REVIEW_ORDER = Object.freeze({
+  steps: ['verify 自动证据裁决（先：advisory 记录 / enforce 拦截；产物 audit/verify-verdict.md）',
+    '盲审编排（可选：blindReview.enabled=true 时 panelist×N → aggregate → critic）',
+    'needHuman 人工闸（后：引擎强制，merged 需 note 含 human:<裁决人>:<时间>:<结论> 证据）'],
+  verifyBlocked: 'verify blocked（EVIDENCE_UNREADABLE/TRUNCATED）→ 直接升级人工（conflict/needHuman），不进入盲审——不可信证据不做评审',
+  needHumanOwner: '盲审 lane 的 needHuman 声明落 aggregate 产物——人工闸裁决对象=聚合结论，非单 panelist',
+});
+
+// ── 六任务契约模板（键名固定，供 assertAssemblyCompleteness 扩展视图与 Leader/Manager 建批取用）──
+const T_BUNDLE = `材料包准备（bundle，防评价污染 M6）：
+- 事实摘录段：仅摘录 exec 产物事实，每条标注出处（file:line）；锚定对照声明前置（对照同 X 分锚定）；
+- 禁评价词（好/差/优雅/低劣等主观词一律禁止——事实层与评价层分离是盲审有效性关键）；
+- 材料完整性按 checklist 模板分级：阻塞缺失→中止；非阻塞→备注 + 对应维度扣分；用户确认降级为可选条款；
+- 叠加顺序：先消费 verify 裁决报告（audit/verify-verdict.md）——verify 自动证据先行，盲审在其上做质量评审；
+  verify blocked（EVIDENCE_UNREADABLE/TRUNCATED）→ 直接升级人工，不进入盲审（不可信证据不做评审）。`;
+
+const T_PANELIST = `独立盲审打分（panelist）：
+- 独立 subagent 互不可见（隔离盲审，各评各的）；按 rubric 逐维度评分 + 理由 + 低分修改建议；
+- 锚定对照声明必填（对照同 X 分锚定——aggregate 阶段 1 依赖）；
+- 失败重试 ≤3 次，仍失败标 DEGRADED（映射 skipped/低权重，不单评顶替）；
+- 产物落盘 audit/panelist-<i>.md（Tier3 门禁：缺 produce 拒 merged，替代文本 checkpoint）。`;
+
+const T_AGGREGATE = `聚合裁决（aggregate，锚定 + Δ 两阶段，M2）：
+- 阶段 1 锚定一致性：各 panelist 锚定对照匹配同 X 分 → 进阶段 2；锚定分歧 → Chair 裁决（引用事实依据）；
+- 阶段 2 Δ 分级：Δ=0 直接取；Δ=1 默认取低（可依理据采纳高）；Δ=2 Chair 裁决；Δ≥3 补理据重评，仍 ≥3 升级人工；
+- 加权总分手算验证（Checkpoint 4）；聚合报告落盘 audit/aggregate.md；
+- needHuman 声明落本产物（独立行 needHuman: true）——人工闸裁决对象=聚合结论，非单 panelist。`;
+
+const T_CRITIC = `独立复核（critic，三态决议 M3）：
+- 独立 session（不复用聚合上下文，避免偏见）；输入 bundle + 全部 panelist 评分 + 聚合报告 + rubric；
+- 流程合规检查 + 逐维度理据挑战 + 跨维度一致性检查；
+- 三态决议：endorse（通过→merged）/ challenge（Chair 逐条响应→conflict/重审）/ block（退回聚合，不允许跳过）；
+- 产物落盘 audit/critic.md（audit produce，Tier3 缺则拒 merged）；顺序约束：critic 必须等 aggregate 完成后启动。`;
+
+const T_CHECKLIST = `材料完整性分级（checklist，M4）：
+- 阻塞项缺失 → 中止（Tier3 硬门禁为默认，引擎强制不后退到自觉）；
+- 非阻塞项缺失 → 备注 + 对应维度扣分；
+- 用户确认降级为可选条款（audit 层检查通过但标注降级）。`;
+
+const T_CONFIG = {
+  panelistCount: 2,     // 评委数默认 2（关键 lane 才启用、默认单审，防流程膨胀）
+  threshold: 3.5,       // 评分阈值（如 rubric 均分 ≥3.5 为通过线，Leader/Manager 可按项目覆写）
+  criticRequired: true, // critic 默认必跑（三态决议兜底；显式 false 可跳过，不建议）
+  note: 'config 为建批默认值；Leader/Manager 经 buildAuditLaneSpec 覆写（panelistCount/threshold/criticRequired）',
+};
+
+export const BLIND_REVIEW_TEMPLATES = Object.freeze({
+  bundle: T_BUNDLE,
+  panelist: T_PANELIST,
+  aggregate: T_AGGREGATE,
+  critic: T_CRITIC,
+  checklist: T_CHECKLIST,
+  config: T_CONFIG,
+});
+
+// ── 装配扩展合并（extensions.blindReview 默认关）──
+// blindReview.enabled !== true → 原样返回（base DEFAULT_ASSEMBLY 一字不改 → buildAgentDescriptors 输出不变，兼容）；
+// enabled === true → 返回合并副本（三角色入 layers.audit.roles + skills，其他层/角色共享引用，base 不被 mutate）。
+export function applyAssemblyExtensions(assembly, extensions) {
+  const br = (extensions && extensions.blindReview) || (assembly && assembly.extensions && assembly.extensions.blindReview);
+  if (!br || br.enabled !== true) return assembly; // 默认关：零变化
+  if (!assembly || typeof assembly !== 'object' || !assembly.layers || !assembly.layers.audit) return assembly;
+  const out = {
+    ...assembly,
+    layers: {
+      ...assembly.layers,
+      audit: {
+        ...assembly.layers.audit,
+        roles: [...(assembly.layers.audit.roles ?? [])],
+        skills: { ...(assembly.layers.audit.skills ?? {}) },
+      },
+    },
+  };
+  for (const role of BLIND_REVIEW_ROLES) {
+    if (!out.layers.audit.roles.includes(role)) out.layers.audit.roles.push(role);
+    out.layers.audit.skills[role] = BLIND_REVIEW_SKILLS[role];
+  }
+  return out;
+}
+
+// ── 盲审子 lane 任务包骨架（Leader/Manager 建批用）──
+// 返回 { config, templates, tasks }：tasks 可直接喂 buildWavePlan（固定 DAG：panelist×N → aggregate → critic；
+// aggregate deps=全部 panelist、critic deps=aggregate）；consume/produce 契约 + 模板引用齐备，不预写实现（0e）。
+// deps = 外部依赖路径数组（如 exec 产物 + audit/verify-verdict.md），作为 panelist/aggregate/critic 的共享 consume。
+export function buildAuditLaneSpec({ panelistCount, deps = [], threshold, criticRequired } = {}) {
+  const n = Number.isInteger(panelistCount) && panelistCount >= 1 ? panelistCount : T_CONFIG.panelistCount;
+  const depList = Array.isArray(deps) ? deps : [];
+  const panelists = [];
+  for (let i = 1; i <= n; i++) {
+    panelists.push({
+      id: 'audit-panelist-' + i,
+      layer: 'audit',
+      role: 'audit-panelist',
+      deps: [],
+      consume: [...depList],
+      produce: ['audit/panelist-' + i + '.md'],
+      template: 'panelist',
+      cmd: '盲审打分（模板 panelist）：rubric 逐维度评分 + 理由 + 低分建议 + 锚定对照声明；产物 audit/panelist-' + i + '.md',
+    });
+  }
+  const panelistIds = panelists.map((p) => p.id);
+  const panelistProduces = panelists.map((p) => p.produce[0]);
+  const aggregate = {
+    id: 'audit-aggregate',
+    layer: 'audit',
+    role: 'audit-aggregate',
+    deps: [...panelistIds],
+    consume: [...depList, ...panelistProduces],
+    produce: ['audit/aggregate.md'],
+    template: 'aggregate',
+    cmd: '聚合裁决（模板 aggregate）：锚定一致性 + Δ 分级裁决 + 加权聚合 + needHuman 声明；产物 audit/aggregate.md',
+  };
+  const critic = {
+    id: 'audit-critic',
+    layer: 'audit',
+    role: 'audit-critic',
+    deps: ['audit-aggregate'],
+    consume: [...depList, ...panelistProduces, 'audit/aggregate.md'],
+    produce: ['audit/critic.md'],
+    template: 'critic',
+    cmd: '独立复核（模板 critic）：流程合规 + 逐维度理据挑战 + 三态决议 endorse/challenge/block；产物 audit/critic.md',
+  };
+  return {
+    config: {
+      panelistCount: n,
+      threshold: threshold ?? T_CONFIG.threshold,
+      criticRequired: criticRequired ?? T_CONFIG.criticRequired,
+    },
+    templates: BLIND_REVIEW_TEMPLATES,
+    tasks: [...panelists, aggregate, critic],
+  };
+}