deveco_hmigbot 0.21.5

package/skills/migrate-core/templates/mig_slices.js

@@ -0,0 +1,491 @@
+export const meta = {
+  name: 'mig_slices',
+  description: '轻编排实现流水：模型自主实现每片 → 确定性静态门（增量构建 + 算法自测 + 切片级闭合，均可重跑不翻转）→ 落 checked。判断性验收（verify/对抗）不在此，由末端 acceptance 一遍完成——杜绝逐片重验的 churn。依赖分层调度，收口跑集成级闭合。',
+  phases: [
+    { title: 'Implement', detail: '切片实现（填空式：骨架已在，行为接线）' },
+    { title: 'Checkpoint', detail: '确定性静态门：增量构建 + selfTest + 切片级闭合（退出码裁决，失败一次定向修）' },
+    { title: 'Integration', detail: '全切片实现后的集成级闭合' },
+  ],
+};
+
+/*
+ * 轻编排设计（2026-09-05 重构，见 docs/design-2026-09-05-light-orchestration.md）：
+ *  - 只做"确定性验证"：构建/selfTest/闭合，退出码裁决、重跑同答案、不靠真机、不 churn。
+ *  - 不做"判断性验证"：verify agent、对抗否证一律不在此——它们会翻转，逐片连续跑=churn 病根，
+ *    统一挪到末端 acceptance 模板跑一遍。故本模板只把切片推进到 ledger 的 checked，不过账 featureIds。
+ *  - 失败即定向：确定性门红了派一次修（构建错/闭合悬空都是可行动的确定失败），仍红则记 failed 并继续，
+ *    绝不整流水 resume 重验已完成片。
+ *  - 无栅栏：同层切片各自流过 实现→检查点，快的不等慢的；真依赖按拓扑分层，仅层间有序。
+ *
+ * args = {
+ *   goal, dst,
+ *   build:              "$ cd <dst> && hvigorw assembleHap --no-daemon --incremental"
+ *   closureSlice:       "$ node <home>/scripts/closure/closure-suite.mjs --project <dst> --stage slice"
+ *   closureIntegration: "$ node <home>/scripts/closure/closure-suite.mjs --project <dst> --stage integration"
+ *   ledgerCmd?:         "node <home>/scripts/ledger/ledger.mjs --dir <ledgerDir>"
+ *   instructionsFile, conventionsFile, contextFiles?, skills?,
+ *   slices: [{ id, title, targetPath (串或数组), expectation, section?, deps?: [], skills?, route?,
+ *             selfTest?: "$ node spec/run-vectors.mjs" }],   // featureIds 由末端 acceptance 过账，此处可不填
+ *   unownedRoutes?: [{ route, reason }],   // 确不迁移的注册路由（路由归属校验豁免；同时应从 route_map 删注册）
+ *   smoke?: "$ node <home>/scripts/smoke/smoke.mjs --project <dst> --out <spec>/smoke",
+ *   only?: [], models?: { implement?, fix? }
+ * }
+ * 机制内置：路由归属按文件校验（route_map 每个注册页文件须落在某切片 targetPath 内；带 route 的片须拥有其页文件）；
+ * 越权申报 blocked → 台账 debts + summary.blocked；波级冒烟环境阻塞记账不派修；切片过大只给信号不设配额。
+ */
+
+const A = args || {};
+const fail = (m) => { throw new Error(`mig_slices args: ${m}`); };
+for (const k of ['build', 'closureSlice', 'closureIntegration']) {
+  if (!A[k] || !String(A[k]).trim().startsWith('$ ')) fail(`${k} 必须是 "$ <shell 命令>" 形态`);
+}
+if (!Array.isArray(A.slices) || !A.slices.length) fail('slices 为空');
+const ids = A.slices.map(s => s.id);
+if (new Set(ids).size !== ids.length) fail('切片 id 重复');
+const only0 = Array.isArray(A.only) && A.only.length ? A.only : null;
+for (const s of A.slices) {
+  if (!s.id || !s.targetPath) fail(`切片缺 id/targetPath`);
+  if (!/^[A-Za-z0-9_.:-]+$/.test(s.id)) fail(`切片 id "${s.id}" 含非法字符（台账/shell 拼接安全集：字母数字 _ . : -）`);
+  // expectation 长度只校验本次执行集：闭包里"地基波已完成、本轮不执行"的占位片不该拦整流（实测短标注触发整流重跑）
+  const inExec = !only0 || only0.includes(s.id);
+  if (inExec && (!s.expectation || String(s.expectation).trim().length < 20)) fail(`切片 ${s.id} 的 expectation 过短（不足 20 字）：写成可逐条核对的完成标准（原子可断言/穷举/带 文件:行 锚点）`);
+  if (s.selfTest && !String(s.selfTest).trim().startsWith('$ ')) fail(`切片 ${s.id} 的 selfTest 必须是 "$ <shell 命令>" 形态`);
+  // deps 指向不在 slices 的 id：视为外部已满足（与 extSat 同义）并告警，不整流拒跑——依赖顺序只在执行集内有意义
+  //（实测闭包漏列一条已完成地基片 id 就整流重跑）
+  s.deps = (s.deps || []).filter(d => {
+    if (ids.includes(d)) return true;
+    log(`⚠ 切片 ${s.id} 依赖 ${d} 不在 slices（视为外部已满足；若它其实未完成，补进闭包再跑）`);
+    return false;
+  });
+}
+// smoke 会被模板尾接 --routes/--json：bash -c '…' 包裹会把尾接参数变成 bash 位置参数（冒烟退化成仅冷启）且引号错配
+// （实证：/bin/sh unexpected EOF，冒烟从未执行、误派修复一轮）。要切目录写 "cd <dir> && node …"。
+if (A.smoke && /\b(?:bash|sh|zsh)\s+-l?c\b/.test(String(A.smoke))) fail('smoke 直接写命令（模板会尾接 --routes/--json），不要 bash -c 包裹；需切目录写 "$ cd <dir> && node <smoke.mjs> …"');
+// 环检测（对全依赖图，保持校验能力）
+(function detectCycles() {
+  const state = new Map();
+  const walk = (s, path) => {
+    if (state.get(s.id) === 2) return;
+    if (state.get(s.id) === 1) fail(`依赖成环：${[...path, s.id].join('→')}`);
+    state.set(s.id, 1);
+    for (const d of s.deps || []) walk(A.slices.find(x => x.id === d), [...path, s.id]);
+    state.set(s.id, 2);
+  };
+  for (const s of A.slices) walk(s, []);
+})();
+
+// 依赖方向提示：业务核心不该宿主进页面片（tier 前缀数据化，未知前缀不误判）
+const CORE_TIERS = /^(backend|platform|core|fnd|service|domain|data)-/;
+for (const s of A.slices) {
+  if (CORE_TIERS.test(s.id)) {
+    const bad = (s.deps || []).filter(d => /^(page|view|ui)-/.test(d));
+    if (bad.length) log(`⚠ 依赖方向提示：核心片 ${s.id} 依赖页面片 ${bad.join(',')}——建议把共享状态机/服务提为独立核心片`);
+  }
+}
+
+const only = Array.isArray(A.only) && A.only.length ? A.only : null;
+if (only) for (const o of only) if (!ids.includes(o)) fail(`only 中的 ${o} 不在 slices`);
+const slices = only ? A.slices.filter(s => only.includes(s.id)) : A.slices;
+
+// 拓扑分层：只有"本次也要执行"的依赖才推高层级（已完成/外部依赖视为已满足，不制造空转层）。
+const execSet = new Set(slices.map(s => s.id));
+const levelOf = new Map();
+function level(s) {
+  if (levelOf.has(s.id)) return levelOf.get(s.id);
+  const activeDeps = (s.deps || []).filter(d => execSet.has(d));
+  levelOf.set(s.id, 0);
+  const l = activeDeps.length ? Math.max(...activeDeps.map(d => level(A.slices.find(x => x.id === d)))) + 1 : 0;
+  levelOf.set(s.id, l);
+  return l;
+}
+for (const s of slices) level(s);
+const extSat = [...new Set(slices.flatMap(s => (s.deps || []).filter(d => !execSet.has(d))))];
+if (extSat.length) log(`外部依赖视为已满足（不在本次执行集）：${extSat.join(', ')}`);
+const maxLevel = Math.max(...slices.map(s => levelOf.get(s.id)));
+const M = A.models || {};
+const opt = (model, extra) => model ? { model, ...extra } : { ...extra };
+const cmd = (c) => String(c).trim().replace(/^\$\s*/, '');
+
+// ---- 路由归属按文件校验（契约靠机制不靠自觉）----
+// 注册页文件就是交付文件：route_map 每个 pageSourceFile 必须落在某切片 targetPath 内（确不迁移的路由用
+// unownedRoutes:[{route,reason}] 豁免并删注册）；带 route 的片，其注册页文件必须在自己的 targetPath 内。
+// 否则实现落在壳外目录、壳永远挂不上——静态门/冒烟/验收三道都看不见。dst 未给或无 route_map 则跳过。
+if (A.dst) {
+  const norm = (p) => String(p).replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+  const dstN = norm(A.dst);
+  // 扫各模块的 route_map（模块目录不写死），输出 [{module,name,pageSourceFile}]
+  const rr = await check(`node -e "const fs=require('fs'),p=require('path'),d=process.argv[1],o=[];try{for(const m of fs.readdirSync(d)){const f=p.join(d,m,'src','main','resources','base','profile','route_map.json');if(!fs.existsSync(f))continue;try{for(const e of (JSON.parse(fs.readFileSync(f,'utf8')).routerMap||[]))o.push({module:m,name:e.name,pageSourceFile:e.pageSourceFile})}catch{}}}catch{};process.stdout.write(JSON.stringify(o))" "${dstN}"`);
+  let entries = [];
+  try { entries = rr.ok ? JSON.parse(String(rr.output || '[]')) : []; } catch { entries = []; }
+  if (!Array.isArray(entries)) entries = [];
+  if (entries.length) {
+    const owners = (file) => A.slices.filter(s => [].concat(s.targetPath).map(norm).some(tp => file === tp || file.startsWith(tp + '/')));
+    const unowned = new Map((A.unownedRoutes || []).map(u => [u.route || u.name, String(u.reason || '')]));
+    const pageFile = (e) => `${dstN}/${e.module}/${norm(e.pageSourceFile || '')}`;
+    const problems = [];
+    for (const e of entries) {
+      const file = pageFile(e);
+      if (unowned.has(e.name)) { if (unowned.get(e.name).trim().length < 8) problems.push(`unownedRoutes ${e.name} 须给实质理由`); continue; }
+      if (!owners(file).length) problems.push(`路由 ${e.name} 的注册页 ${file} 不在任何切片 targetPath 内`);
+    }
+    for (const s of A.slices) {
+      if (!s.route) continue;
+      const e = entries.find(x => x.name === s.route);
+      if (!e) { problems.push(`切片 ${s.id} 的 route ${s.route} 未在 route_map 注册`); continue; }
+      const file = pageFile(e);
+      if (!owners(file).some(o => o.id === s.id)) problems.push(`切片 ${s.id} 声明 route ${s.route}，但其注册页 ${file} 不在本片 targetPath（${[].concat(s.targetPath).join(', ')}）内——实现会落在别处、壳永远挂不上`);
+    }
+    if (problems.length) fail(`路由归属校验未过（${problems.length} 条）：\n- ${problems.join('\n- ')}\n（怎么改：归属按 slices[] 全集校验、与 only 无关——分波执行时把全部页面片（含后续波的）都列进 slices[]，每片 targetPath 含其注册页文件，再用 only 限定本波执行集；确不迁移的路由才用 unownedRoutes:[{route,reason}] 豁免并从 route_map 删注册）`);
+    log(`路由归属校验通过：${entries.length} 个注册页均有切片拥有${unowned.size ? `（豁免 ${unowned.size}）` : ''}`);
+  }
+}
+
+const IMPL_SCHEMA = {
+  type: 'object', required: ['ok', 'summary', 'files'],
+  properties: { ok: { type: 'boolean' }, summary: { type: 'string' }, files: { type: 'array', items: { type: 'string' } }, deviations: { type: 'array', items: { type: 'object', required: ['kind', 'text'], properties: { kind: { type: 'string', enum: ['no_equiv', 'approx', 'policy', 'source_stub'] }, text: { type: 'string' }, symbols: { type: 'array', items: { type: 'string' } }, probe: { type: 'string' } } } }, unresolved: { type: 'array', items: { type: 'string' } }, blocked: { type: 'string' } },
+};
+
+// 检查点互斥锁（构建/闭合共享资源，串行化）
+let lock = Promise.resolve();
+function withLock(fn) {
+  const run = lock.then(fn, fn);
+  lock = run.then(() => undefined, () => undefined);
+  return run;
+}
+const failReasons = new Map();
+let buildPoisoned = null;
+function failSlice(id, reason) { failReasons.set(id, reason); log(`✗ ${id}：${reason}`); throw new Error(reason); }
+// ---- 构建红归责（无栅栏流水的代价：检查点编译的是整个工程，同层他片可能正写到一半）----
+// 从构建输出抽 .ets/.ts 文件路径（绝对路径按 cwd 转相对），按切片 targetPath 判归属：
+// own=本片文件；others=他片文件（键=片 id）；unknown=无片拥有（壳/共享件）。
+// 全在"同层尚未落定的他片"文件里 → 不是本片之责：不派修、不判毒化，延后到本层收口复检一次。
+const checkedIds = new Set();
+const fixRounds = new Set();   // `${片}:${pass|final}`——每片每阶段最多一轮构建修复
+let levelUnstable = false;     // 本层出现不可归责他片的持续红：后续检查点不各自派修，统一延后收口复检（每层重置）
+const normPath = (p) => String(p).replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+const ownerOf = (file) => A.slices.find(x => [].concat(x.targetPath).map(normPath).some(tp => file === tp || file.startsWith(tp + '/')));
+function blameBuild(output, s) {
+  const own = new Set(), others = new Map(), unknown = new Set();
+  const base = (typeof cwd === 'string' && cwd) ? normPath(cwd) + '/' : '';
+  // Windows 盘符大小写不定（hvigor 打印 c:\… 与 C:\… 都有），前缀比较不区分大小写
+  const stripBase = (f) => { const nf = normPath(f); return base && nf.slice(0, base.length).toLowerCase() === base.toLowerCase() ? nf.slice(base.length) : nf; };
+  for (const m of String(output || '').matchAll(/(?:[A-Za-z]:)?[\/\\]?[\w.\-]+(?:[\/\\][\w.\-]+)*\.(?:ets|ts)(?=[:\s'")\]]|$)/g)) {
+    let f = normPath(m[0]);
+    f = stripBase(f);
+    const o = ownerOf(f);
+    if (!o) { unknown.add(f); continue; }
+    if (o.id === s.id) own.add(f);
+    else { if (!others.has(o.id)) others.set(o.id, new Set()); others.get(o.id).add(f); }
+  }
+  return { own: [...own], others, unknown: [...unknown] };
+}
+const ledgerWarns = [];
+async function ledger(op) {
+  if (!A.ledgerCmd) return;
+  let r = await check(`${A.ledgerCmd} ${op}`);
+  // 宿主重解压内置技能时脚本文件会短暂消失（另一版本 deveco 在同机启动即触发，实证 71 秒窗口）：等 5 s 重试两次，不把丢账当结果
+  for (let i = 0; i < 2 && !r.ok && /Cannot find module/.test(r.output || ''); i++) { await check(`node -e "setTimeout(()=>{},5000)"`); r = await check(`${A.ledgerCmd} ${op}`); }
+  if (!r.ok) { const w = `台账写入失败：${op.slice(0, 140)} → ${(r.output || '').trim().slice(0, 200)}`; ledgerWarns.push(w); log(`⚠ ${w}`); }
+}
+// 批量条目不经 shell 传 JSON（cmd.exe 不认单引号、命令行 8K 上限）：base64 分段由 node 写成临时文件，再 --file 读入。
+// 分段长度取 4 的倍数使每段可独立解码；文件落 .deveco/workflows/tmp/（引擎会把 .deveco 改写为实际点目录）
+let tmpSeq = 0;   // 引擎沙箱禁 Date.now()/Math.random()（脚本须确定性，journal 才能按命令串回放）：临时文件名用自增序号
+// 沙箱是干净 V8 上下文：没有 Buffer/btoa/TextEncoder，只有 JS 内建——base64 用内建函数手写（UTF-8 经 encodeURIComponent+unescape 转字节串）
+const toB64 = (str) => {
+  const bytes = unescape(encodeURIComponent(str)); const T = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes.charCodeAt(i), b = i + 1 < bytes.length ? bytes.charCodeAt(i + 1) : NaN, c = i + 2 < bytes.length ? bytes.charCodeAt(i + 2) : NaN;
+    out += T[a >> 2] + T[((a & 3) << 4) | (isNaN(b) ? 0 : b >> 4)] + (isNaN(b) ? '=' : T[((b & 15) << 2) | (isNaN(c) ? 0 : c >> 6)]) + (isNaN(c) ? '=' : T[c & 63]);
+  }
+  return out;
+};
+async function ledgerAddFile(type, items, tag) {
+  if (!A.ledgerCmd) return;
+  const b64 = toB64(JSON.stringify(items));
+  const file = `.deveco/workflows/tmp/${String(tag).replace(/[^\w.-]/g, '_')}-${String(++tmpSeq)}.json`;
+  const b64file = `${file}.b64`;
+  const chunks = b64.match(/.{1,1600}/g) || [''];
+  for (let i = 0; i < chunks.length; i++) {
+    const w = await check(`node -e "const fs=require('fs');const p=process.argv[1];fs.mkdirSync(require('path').dirname(p),{recursive:true});fs[${i === 0 ? "'writeFileSync'" : "'appendFileSync'"}](p,process.argv[2])" "${b64file}" ${chunks[i]}`);
+    if (!w.ok) { const m = `台账写入失败：临时文件 ${b64file} 写不出（${(w.output || '').trim().slice(0, 120)}）`; ledgerWarns.push(m); log(`⚠ ${m}`); return; }
+  }
+  const d = await check(`node -e "const fs=require('fs');const p=process.argv[1];fs.writeFileSync(p,Buffer.from(fs.readFileSync(p+'.b64','utf8'),'base64'));fs.unlinkSync(p+'.b64')" "${file}"`);
+  if (!d.ok) { const m = `台账写入失败：临时文件 ${file} 解码失败`; ledgerWarns.push(m); log(`⚠ ${m}`); return; }
+  await ledger(`add --type ${type} --file "${file}"`);
+  await check(`node -e "try{require('fs').unlinkSync(process.argv[1])}catch{}" "${file}"`);   // 交接文件用完即删
+}
+
+const results = [];
+// 越权申报（实现者按纪律不动壳/共享件、写进 blocked 的项）：以前只打日志无人消费（实测 120 条含"需壳单元挂载 X"），
+// 现在进台账 debts（blk-<片>）+ 汇总 summary.blocked，收口前必须处置。
+const blockedReports = [];
+const smokeWaves = [];
+
+// ---- 机械切卡（引擎机制，不靠装配纪律）----
+// 模板启动读一次工单与规范，按 `## SECTION: <id>` 机械切分注入各片 prompt。
+// 治的不是那几十 K 文件本身，是"每 agent 开局 read 一轮 = 全上下文重传一轮"的固定税
+// （实测 conventions/instructions 被 31–43 个会话各整读一遍）。
+// 读法：逐片 readSection(工单, 'SECTION: <id>')——引擎按节抽取（前言+该节，50K 上限），不经 check() 的 16K 输出截断
+// （实证一轮 176K/31 节的工单经 check 读入只切出 5 节，26 片静默回退自读文件）。规范全文 readSection 整读，超限即不附。
+let convText = '';
+if (A.conventionsFile) {
+  try {
+    // 标题含"不注入"的节（待验条目层）整节剔除——未经真机验证的规则不进实现 prompt
+    convText = String(await readSection(A.conventionsFile)).replace(/^##[^\n]*不注入[\s\S]*?(?=^## |\s*$(?![\s\S]))/m, '').trim();
+  } catch (e) { log(`⚠ 规范整读失败（${String(e && e.message || e).slice(0, 120)}）——卡片不附规范，改指路必读文件`); convText = ''; }
+}
+const sectionMisses = [];
+async function cardOf(s) {
+  if (s.card) return s.card; // 装配显式给卡则优先
+  if (!A.instructionsFile) return null;
+  let sec = null;
+  const want = s.section || s.id;
+  try { sec = String(await readSection(A.instructionsFile, `SECTION: ${want}`)); }   // 前言 + 本节
+  catch (e) { sectionMisses.push(s.id); log(`⚠ ${s.id} 工单无对应 SECTION（${String(e && e.message || e).slice(0, 100)}）——回退指路，agent 自读工单`); return null; }
+  // 抽到的必须正是本节：引擎按行包含匹配，`page-a` 可能抽到 `page-ab`（本版引擎已优先精确行，这里再守一道）
+  const head = sec.match(/^\W*SECTION:\s*(\S+)\s*$/m);
+  if (!head || head[1] !== want) { sectionMisses.push(s.id); log(`⚠ ${s.id} 抽到的节标题是 "${head ? head[1] : '(无)'}" 不是 "${want}"——回退指路`); return null; }
+  const bodyLen = sec.length - (head.index || 0);   // 本节自身长度（不含前言），过大信号按它算
+  // 24K 上限：先砍规范（工单节永不砍——那是本片的完成标准），规范砍空仍超则如实带超长卡片并告警
+  const conv = convText ? `【写法规范（全文已附，勿再读文件）】\n${convText}` : '';
+  let card = [sec, conv].filter(Boolean).join('\n\n');
+  if (card.length > 24000 && conv) { const room = Math.max(0, 24000 - sec.length - 2); log(`⚠ ${s.id} 卡片超 24K：规范截到 ${room} 字（工单节 ${sec.length} 字保留完整）`); card = room > 400 ? `${sec}\n\n${conv.slice(0, room)}\n…[规范截断，完整规范见 ${A.conventionsFile}]` : sec; }
+  if (card.length > 24000) log(`⚠ ${s.id} 工单节本身 ${bodyLen} 字超 24K——切片过大，按松耦合边界拆`);
+  // 切片过大信号（不是配额）：单节工单 >8K 或断言 >40 条的片单轮难写完（实测 87 条消息均值、最长 205 条报废）
+  const secLen = bodyLen, exLines = String(s.expectation || '').split('\n').filter(l => l.trim()).length;
+  if (secLen > 8000 || exLines > 40) log(`⚠ 切片过大信号 ${s.id}：SECTION ${secLen} 字 · 断言 ${exLines} 行——找松耦合边界拆片，找不到就接受更长单轮`);
+  return card;
+}
+// 技能不是引擎选项：与 implement.js 同法写进 prompt，由子代理用 skill 工具加载（此前作为 agent 选项传入被引擎静默丢弃，实证一轮无一次加载）
+const skillLine = (...vs) => { const sk = []; for (const v of vs) for (const x of [].concat(v || [])) if (typeof x === 'string' && x && !sk.includes(x)) sk.push(x); return sk.length ? `开工前先用 skill 工具加载并遵循这些技能：${sk.join('、')}。\n` : ''; };
+// 结构化结果失败时引擎回退原文字符串：对本流程等同死亡（既无 ok 也无 files），统一按 null 走增量续跑
+const asObj = (r, label) => { if (r !== null && r !== undefined && typeof r !== 'object') { log(`⚠ ${label} 返回非结构化文本（schema 修复失败），按死亡处理`); return null; } return r; };
+
+async function implementSlice(s) {
+  const card = await cardOf(s);
+  const briefing = card
+    ? `【工单（自足，禁再读工单/规范原文件）】\n${card}\n`
+    : `工单：${A.instructionsFile || '（见 expectation）'}${s.section ? ` 的 SECTION: ${s.section}` : ''}\n` +
+      `必读规范：${A.conventionsFile}\n`;
+  const basePrompt =
+    `实现迁移切片 ${s.id}（${s.title || ''}）。骨架与路由已就位，你负责行为接线与语义还原。\n` +
+    skillLine(s.skills, A.skills) +
+    briefing +
+    `参考：${(A.contextFiles || []).join(', ')}\n` +
+    `【只准创建/修改 ${[].concat(s.targetPath).join(' 、 ')} 及其下文件】（注册页文件在列即由你实现，页面内容写进它本身，不另起壳外目录）；需要动共享/壳文件的，不动手，写进返回值 blocked。\n` +
+    `完成标准（后续末端验收将逐条断言，你现在就照它实现到位）：\n${s.expectation}\n` +
+    (s.selfTest ? `【自测前置】实现后立即自跑：\`${String(s.selfTest).replace(/^\$\s*/, '')}\`，修到全过再返回——不许把红着的自测留给检查点。\n` : '') +
+    `完成判定（诚实即效率）：ok:true 仅当"完成标准"逐条落实、或确属平台无等价的项已逐条写入 deviations；` +
+    `deviations 每项写成对象 {kind, text, symbols, probe}：kind=no_equiv（鸿蒙无等价——symbols 列出你在 SDK d.ts 里逐个查过、确认不存在的 API 名，如 ["WaterFlowSections","onDidScroll"]，probe 一句话说查法与结果；脚本会拿 symbols 去 d.ts 核，任一存在即退回）| approx（视觉/动画近似，行为契约不变）| policy（平台策略/权限限制）| source_stub（源码本就是桩）；` +
+    `登记的降级先记"待裁决"，收口时核实后才算数，写不出 probe 的"无等价"不会被豁免。` +
+    `可实现而未写完 = 如实 ok:false 并在 unresolved 列清（会安排续跑；虚报 ok:true 会在末端验收暴露并回炉，代价远高于续跑）。\n` +
+    `纪律：源码是绝对真源；不降级不占位；禁跑全工程构建（检查点统一做）；` +
+    `传入了 skills 的，在 summary 末尾用一句话报告其是否提供了决定性证据。`;
+  // retries:0：超时/stall 死亡不许引擎原 prompt 从零重跑（实测单片报废可达 1–2 小时）。
+  // 死亡回到本层做增量续跑：先扫 targetPath 已落盘文件注入 prompt，只补缺口。
+  let r = asObj(await agent(basePrompt,
+    opt(M.implement, { label: `impl:${s.id}`, phase: 'Implement', schema: IMPL_SCHEMA, retries: 0 })), `impl:${s.id}`);
+  if (r === null) {
+    // node 单行代替 find：Windows 无同义 find（宿主 shell 差异），node 恒在（引擎前置依赖）；targetPath 可为数组/文件
+    const done = await check(`node -e "const fs=require('fs');const w=(d,o=[])=>{try{if(fs.statSync(d).isFile()){o.push(d);return o}for(const e of fs.readdirSync(d,{withFileTypes:true})){const p=d+'/'+e.name;e.isDirectory()?w(p,o):/\\.(ets|ts|json5?)$/.test(e.name)&&o.push(p)}}catch{};return o};console.log(process.argv.slice(1).flatMap(p=>w(p)).slice(0,40).join('\\n'))" ${[].concat(s.targetPath).map(p => `"${p}"`).join(' ')}`);
+    const doneList = (done.output || '').trim();
+    r = asObj(await agent(
+      `切片 ${s.id} 增量续跑：上一轮实现中途死亡（超时/断连），部分文件可能已落盘。\n` +
+      (doneList ? `已存在的交付文件（逐个查看现状，完好的不重写，只补缺口与未完成部分）：\n${doneList}\n` : `目标目录尚无交付文件，从头实现。\n`) +
+      basePrompt,
+      opt(M.implement, { label: `impl:${s.id} 补`, phase: 'Implement', schema: IMPL_SCHEMA, retries: 0, cache: false })), `impl:${s.id} 补`);
+  }
+  // ok:false = 代理诚实报未完成（多为单元过大一轮没写完交付文件）。据此重派续跑，别放它进 checkpoint 蒙混。
+  let att = 0;
+  // 续跑者是隔离的新会话，没有首轮卡片：完整工单+纪律必须重附（此前只给 summary/unresolved 还禁读工单文件，续跑者无完成标准可依）
+  while (r !== null && r.ok === false && att < 2) {
+    att++;
+    r = asObj(await agent(`切片 ${s.id} 续跑 ${att}：上一轮 ok:false 未完成。已做：${String(r.summary || '').slice(0, 500)}\n仍需落地（把交付文件真正写到 ${s.targetPath} 下、写完再返回 ok:true；一轮写不完就先落地能完成的最小部分并如实 ok:false）：\n- ${(r.unresolved || []).slice(0, 10).join('\n- ')}\n\n` + basePrompt,
+      opt(M.implement, { label: `impl:${s.id} 续${att}`, phase: 'Implement', schema: IMPL_SCHEMA, cache: false })), `impl:${s.id} 续${att}`);
+  }
+  if (r && r.blocked) { log(`⚠ ${s.id} 越权申报：${String(r.blocked).slice(0, 200)}`); blockedReports.push({ id: s.id, blocked: String(r.blocked).slice(0, 600) }); }
+  if (r === null) failSlice(s.id, `实现 agent 两轮死亡（含增量续跑）——resumeFrom + only:["${s.id}"] 续跑`);
+  // 诚实未完成 = 失败：此前 ok:false 耗尽续跑仍溜进检查点蒙混——构建/闭合测不出"功能没写"，
+  // 欠账滚到末端验收变成最贵的验→修→复验循环（后台通知片实证）。
+  if (r.ok === false) failSlice(s.id, `切片 ${s.id} 自报未完成（续跑 ${att} 次后仍 ok:false）——未完成项：${(r.unresolved || []).slice(0, 5).join('；') || '(未列)'}。拆片或 resumeFrom + only:["${s.id}"] 续跑`);
+  return r;
+}
+
+// 确定性静态门：构建 + selfTest + 闭合，各失败派一次定向修，仍红记 failed。均为退出码裁决、重跑同答案。
+// finalPass=本层收口复检（他片已落定），不再延后。
+async function checkpoint(s, impl, finalPass = false) {
+  return withLock(async () => {
+    if (buildPoisoned) failSlice(s.id, `构建已被切片 ${buildPoisoned} 毒化，本片快速失败——先修 ${buildPoisoned} 再 only 续跑`);
+    // 实现期登记的平台偏差当场过账（放串行段内写，避免并行写台账竞态）。
+    // 末端验收判据"已登记降级不计失败"依赖这一步——防止同一批偏差被逐轮重复裁决。
+    if (impl && Array.isArray(impl.deviations) && impl.deviations.length && A.ledgerCmd) {
+      // id 按内容散列：同一偏差重跑再报=同 id 同 note（ledger add 幂等跳过），不同偏差不撞车（此前按序号编 id，片重跑整批写失败）
+      const h = (t) => { let x = 5381; for (const c of String(t)) x = ((x * 33) ^ c.charCodeAt(0)) >>> 0; return x.toString(36).slice(0, 6); };
+      if (impl.deviations.length > 24) log(`⚠ ${s.id} 偏差 ${impl.deviations.length} 条只登记前 24 条——偏差这么多说明片划错或在自我豁免，复核工单`);
+      // 结构化：{kind,text,probe}；字符串（旧形态/未分类）记 kind 缺失——同样 pending，收口裁决时补分类
+      const clean = (t, n) => String(t || '').replace(/["'\n\r]/g, ' ').slice(0, n);
+      const items = impl.deviations.slice(0, 24).map((d) => {
+        const o = (d && typeof d === 'object') ? d : { text: String(d) };
+        const note = clean(o.text, 160);
+        if (!note) return null;
+        const symbols = Array.isArray(o.symbols) ? o.symbols.map(x => clean(x, 80)).filter(Boolean).slice(0, 12) : [];
+        return { id: `deg-${s.id}-${h(note)}`, note, ...(o.kind ? { kind: String(o.kind) } : {}), ...(symbols.length ? { symbols } : {}), ...(o.probe ? { probe: clean(o.probe, 200) } : {}), status: 'pending', disposition: `实现期登记（切片 ${s.id}）·待裁决` };
+      }).filter(Boolean);
+      if (items.length) await ledgerAddFile('degradations', items, `deg-${s.id}`);
+    }
+    if (impl && impl.blocked && A.ledgerCmd) {
+      const item = [{ id: `blk-${s.id}`, note: String(impl.blocked).replace(/["'\n\r]/g, ' ').slice(0, 300), disposition: `切片 ${s.id} 越权申报，待壳/共享件 owner 处置（3b 收口清账）` }];
+      await ledgerAddFile('debts', item, `blk-${s.id}`);
+    }
+    let b = await check(cmd(A.build));
+    const othersInFlight = (out) => { const bl = blameBuild(out, s); const inf = [...bl.others.keys()].filter(id => execSet.has(id) && !checkedIds.has(id) && !failReasons.has(id)); return (!bl.own.length && !bl.unknown.length && inf.length) ? inf : null; };
+    const defer = (why) => { log(`检查点[${s.id}]：${why}——本层收口复检`); return { id: s.id, status: 'deferred', s, impl: null }; };
+    if (!b.ok && !finalPass) {
+      const inf = othersInFlight(b.output);
+      if (inf) return defer(`构建红全在他片文件（${inf.join(', ')} 尚未落定），不判本片`);
+      // 本层已有不可归责的持续红：不再各自派修（同一个红会让每片都派一轮），统一延后到收口
+      if (levelUnstable) return defer('本层构建持续红且不可归责他片，不重复派修');
+    }
+    if (!b.ok) {
+      // 每片每阶段最多一轮构建修复：首过一轮、收口复检可再一轮（他片落定后同一处红可能已能修）
+      const key = `${s.id}:${finalPass ? 'final' : 'pass'}`;
+      if (!fixRounds.has(key)) {
+        fixRounds.add(key);
+        log(`检查点[${s.id}]：构建红，派修复`);
+        await agent(skillLine(A.skills || ['arkts-error-fixes', 'arkts-runtime-fix']) + `切片 ${s.id} 后构建失败。只改必要文件恢复绿灯，禁降级止血。构建输出：\n${(b.output || '').slice(-6000)}`,
+          opt(M.fix, { label: `fix-build:${s.id}`, phase: 'Checkpoint', cache: false }));
+        b = await check(cmd(A.build));
+      }
+      if (!b.ok) {
+        if (!finalPass) {
+          // 修后仍红：并行流水里多半是他片半成品（实证：整流续跑后同一份代码全绿）——延后，不在此判毒化连锁
+          const inf = othersInFlight(b.output);
+          if (inf) return defer(`修后剩余红全在他片文件（${inf.join(', ')}）`);
+          levelUnstable = true;
+          return defer('修后仍红且不可归责他片——本层构建不稳，延后统一复检（不连锁判失败）');
+        }
+        // 收口复检（他片已落定）仍红：真毒化，本片失败，其余待复检片快速失败
+        buildPoisoned = s.id;
+        failSlice(s.id, `切片 ${s.id} 后构建无法恢复绿灯（resumeFrom + only:["${s.id}"] 续跑）`);
+      }
+    }
+    if (s.selfTest) {
+      const st = await check(cmd(s.selfTest));
+      if (!st.ok) {
+        log(`检查点[${s.id}]：自测门红，派修复`);
+        await agent(skillLine(A.skills || ['arkts-error-fixes', 'arkts-runtime-fix']) + `切片 ${s.id} 自测未过。按失败清单修复（只改 ${s.targetPath} 下文件）：\n${(st.output || '').slice(-4000)}`,
+          opt(M.fix, { label: `fix-selftest:${s.id}`, phase: 'Checkpoint', cache: false }));
+        const st2 = await check(cmd(s.selfTest));
+        if (!st2.ok) failSlice(s.id, `切片 ${s.id} 自测门未清（resumeFrom + only:["${s.id}"]）`);
+      }
+    }
+    const c = await check(cmd(A.closureSlice));
+    if (!c.ok) {
+      log(`检查点[${s.id}]：切片级闭合有硬违规，派修复`);
+      await agent(`切片 ${s.id} 触发闭合硬违规（跳转未注册名/资源悬空类）。按输出逐条修复：\n${(c.output || '').slice(-4000)}`,
+        opt(M.fix, { label: `fix-closure:${s.id}`, phase: 'Checkpoint', cache: false }));
+      const c2 = await check(cmd(A.closureSlice));
+      if (!c2.ok) failSlice(s.id, `切片 ${s.id} 闭合硬违规未清`);
+    }
+    // 只到 checked（确定性证据）；passed 由末端 acceptance 判断性验收过账
+    checkedIds.add(s.id);
+    await ledger(`status --type slices --id ${s.id} --to checked --evidence "build+selfTest+closure(slice) exit0"`);
+    return { id: s.id, status: 'checked' };
+  });
+}
+
+// ---------- 分层无栅栏流水：实现 → 确定性检查点（无判断性验收） ----------
+for (let l = 0; l <= maxLevel; l++) {
+  const batch = slices.filter(s => levelOf.get(s.id) === l);
+  if (!batch.length) continue;
+  log(`第 ${l} 层：${batch.length} 个切片进入流水（${batch.map(s => s.id).join(', ')}）`);
+  levelUnstable = false;
+  const statusNow = new Map(results.filter(Boolean).map(r => [r.id, r.status]));
+  const out = await pipeline(
+    batch,
+    (s) => {
+      const badDeps = (s.deps || []).filter(d => execSet.has(d) && statusNow.get(d) !== 'checked');
+      if (badDeps.length) failSlice(s.id, `依赖切片 ${badDeps.join(',')} 未过检查点，本片不实现（依赖修好后 only:["${s.id}"] 续跑）`);
+      return implementSlice(s).then(r => ({ s, impl: r }));
+    },
+    (x) => checkpoint(x.s, x.impl),
+  );
+  // 延后复检：检查点时构建红全在他片在飞文件的片，本层其余片落定后再过一次检查点（不再延后；实现期登记已写过账，impl 传空）
+  for (let i = 0; i < out.length; i++) {
+    const r = out[i];
+    if (!r || r.status !== 'deferred') continue;
+    log(`本层收口复检 ${r.id}（此前构建红归他片文件）`);
+    try { out[i] = await checkpoint(r.s, null, true); } catch { out[i] = null; }
+  }
+  out.forEach((r, i) => results.push(r || { id: batch[i].id, status: 'failed', evidence: failReasons.get(batch[i].id) || '流水中途死亡——resumeFrom 续跑' }));
+
+  // ---- 波级装机冒烟（A.smoke 配置且本层有带 route 的页面片才跑）----
+  // 判定阶梯见 smoke.mjs：环境阻塞(3)=记账不派修（装机失败/无设备/hap 过期，fix agent 修不了）；
+  // 崩溃(10)=修复一轮，仍崩即停轮（带病铺片无意义）；立案(2)分两类：接线类（misland/nohook/not-foreground/bounced/scaffold）修一轮、
+  // 仍在则末端裁决；软立案（forwarded/hollow/expect-miss/nodump）只记案不派修。
+  if (A.smoke) {
+    const okIds = new Set(results.filter(r => r && r.status === 'checked').map(r => r.id));
+    const routes = batch.filter(s => s.route && okIds.has(s.id)).map(s => s.route);
+    if (routes.length) {
+      const smokeOut = (cmd(A.smoke).match(/--out\s+["']?([^\s"']+)/) || [, 'spec/smoke'])[1]; // 不吞引号（引号包裹的路径）
+      const smokeCmd = `${cmd(A.smoke)} --routes ${routes.join(',')} --json "${smokeOut}/wave-${l}.json"`;
+      let sm = await check(smokeCmd);
+      const out0 = sm.output || '';
+      if (sm.ok) {
+        log(`✓ 波 ${l} 冒烟绿（${routes.length} 页：装机·前台·着陆·页面子树均核）`);
+        smokeWaves.push({ wave: l, status: 'ok', routes });
+      } else if (/环境阻塞|exit 3|跳过/.test(out0)) {
+        const why = out0.trim().split('\n').filter(Boolean).pop() || '';
+        log(`▲ 波 ${l} 冒烟环境阻塞（不派修，收口报数）：${why.slice(0, 200)}`);
+        smokeWaves.push({ wave: l, status: 'blocked', routes, detail: why.slice(0, 300) });
+      } else {
+        const crashed = /崩溃|jscrash|cppcrash/.test(out0);
+        // 只对崩溃与接线类派修（misland/nohook/not-foreground/bounced/scaffold）；hollow（空态或未实现，回模型裁决）、
+        // forwarded（应用自身转发链，4b 沿链走查）、expect-miss、nodump 只记案不派修——实证 w0 把登录分派转发判成接线问题派修 9 分钟，修复代理只做了豁免。
+        const tally = (out0.match(/页未过（([^）]*)）/) || [])[1] || '';
+        const hard = crashed || /\b(misland|nohook|not-foreground|bounced|scaffold)\b/.test(tally);
+        if (!hard) {
+          log(`▲ 波 ${l} 冒烟软立案（${tally || '见报告'}）——非崩溃/接线类，不派修，末端验收裁决`);
+          smokeWaves.push({ wave: l, status: 'cases', routes, detail: out0.trim().split('\n').filter(Boolean).pop() || '' });
+        } else {
+          log(`▲ 波 ${l} 冒烟未过（${crashed ? '崩溃' : tally}），派修复`);
+          await agent(skillLine(A.skills) + `波 ${l} 装机冒烟${crashed ? '崩溃' : '未过'}。报告语义：misland/nohook=接线问题（EntryAbility smokeRoute 透传、Index 钩子、route_map 注册与页面 Builder 导出）；bounced=推入即弹回（参数判型/pop 防御，参数经序列化后 instanceof 恒 false）；scaffold=注册页仍是骨架占位（片未实现）；not-foreground=应用未起（崩溃/白屏）。forwarded/hollow/expect-miss 不在本次修复范围（末端裁决），不要为它们改代码。按输出定位并只修涉事页面（faultlog 栈/控件树/截图见 ${smokeOut}/）：\n${out0.slice(-5000)}`,
+            opt(M.fix, { label: `fix-smoke-w${l}`, phase: 'Implement', cache: false }));
+          sm = await check(smokeCmd);
+          const out1 = sm.output || '';
+          if (!sm.ok && /崩溃|jscrash|cppcrash/.test(out1)) throw new Error(`波 ${l} 冒烟崩溃修复未收敛——先修崩溃再 resumeFrom 续跑（报告 ${smokeOut}/wave-${l}.json）`);
+          if (!sm.ok) { log(`▲ 波 ${l} 冒烟仍有立案（不阻塞，末端验收裁决）`); smokeWaves.push({ wave: l, status: 'cases', routes, detail: out1.trim().split('\n').filter(Boolean).pop() || '' }); }
+          else { log(`✓ 波 ${l} 修后冒烟绿`); smokeWaves.push({ wave: l, status: 'ok-after-fix', routes }); }
+        }
+      }
+    }
+  }
+}
+
+// ---------- 集成级闭合（确定性全局判定；有失败片先收账不跑闭合） ----------
+phase('Integration');
+const bad = results.filter(r => !r || r.status !== 'checked');
+if (bad.length) {
+  log(`跳过集成级闭合：${bad.length} 个切片未过检查点——先收账（见收口 throw 逐片原因），修好续跑再闭合`);
+} else {
+  const integ = await check(cmd(A.closureIntegration));
+  if (!integ.ok) {
+    log('集成级闭合有硬违规，派一次修复后复检');
+    await agent(`集成级闭合硬违规，逐条修复：\n${(integ.output || '').slice(-6000)}`, opt(M.fix, { label: 'fix-integration', phase: 'Integration', cache: false }));
+    const integ2 = await check(cmd(A.closureIntegration));
+    if (!integ2.ok) throw new Error('mig_slices FAILED: 集成级闭合硬违规未清');
+  }
+  log('集成级闭合完成（确定性全局判定通过；判断性验收由末端 acceptance 一遍完成）');
+}
+
+const checked = results.filter(r => r && r.status === 'checked');
+log(`实现流水收口：${checked.length}/${slices.length} 到 checked（passed 待末端 acceptance 过账）${bad.length ? `；未过 ${bad.map(b => b.id).join(',')}` : ''}`);
+if (blockedReports.length) log(`⚠ 越权申报 ${blockedReports.length} 条（台账 debts blk-*，见 summary.blocked）——壳/共享件改动由主会话处置后再进末端验收：${blockedReports.map(b => b.id).join(', ')}`);
+if (smokeWaves.some(w => w.status === 'blocked')) log(`⚠ 波级冒烟环境阻塞 ${smokeWaves.filter(w => w.status === 'blocked').length} 波（装机/设备/hap 问题，无运行时证据）——见 summary.smoke，报告须如实标"未冒烟"`);
+if (ledgerWarns.length) log(`⚠ 台账写入失败 ${ledgerWarns.length} 次——报告前须核对补账`);
+const summary = { goal: A.goal || '', slicesTotal: slices.length, checked: checked.map(r => r.id), failed: bad.map(r => ({ id: r.id, evidence: String(r.evidence).slice(0, 300) })),
+  ...(blockedReports.length ? { blocked: blockedReports } : {}), ...(smokeWaves.length ? { smoke: smokeWaves } : {}), ...(ledgerWarns.length ? { ledgerWarns } : {}) };
+if (bad.length) {
+  throw new Error(`mig_slices FAILED: ${bad.length} 个切片未到 checked（${bad.map(b => b.id).join(', ')}）。修复后 only:[${bad.map(b => `"${b.id}"`).join(',')}] + resumeFrom 续跑。`);
+}
+return summary;