@metago-ai/engine 2.1.3 → 2.1.4

package/ENGINES/math-capability-runtime.cjs

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+/**
+ * P6-B8 · 数学族 / 能力族 / 共生族引擎运行时（20 条）
+ * 依据 ENGINE-CONTRACTS.json 的 definitionText（含输入/输出规范）逐条实现。
+ */
+'use strict';
+
+let __seq = 0;
+const newTraceId = () => {
+  const d = new Date(), p = (n, w = 2) => String(n).padStart(w, '0');
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${d.getHours()}${p(d.getMinutes())}${d.getSeconds()}-E${p((++__seq) % 10000, 4)}`;
+};
+const clamp01 = (x) => Math.max(0, Math.min(1, Number(x) || 0));
+const round = (x, n = 6) => Math.round((Number(x) || 0) * 10 ** n) / 10 ** n;
+const cos = (a, b) => {
+  if (!a || !b || a.length !== b.length) return 0;
+  const d = a.reduce((s, x, i) => s + x * b[i], 0);
+  const na = Math.sqrt(a.reduce((s, x) => s + x * x, 0)), nb = Math.sqrt(b.reduce((s, x) => s + x * x, 0));
+  return na && nb ? d / (na * nb) : 0;
+};
+
+const E = [];
+
+/* ══════════ 数学通用族（8 条，第1部分 §2.1）══════════ */
+
+E.push({
+  id: 'ENGINE_COMPLEX_INTEGRAL_47', name: '复分析积分引擎', kind: 'compute',
+  spec: '第1部分 §2.1（898 字符）', io: { in: ['poles', 'contour'], out: ['residues', 'integralValue', 'estimation'] },
+  implements: ['留数计算 Res(f,z₀)=lim(z-z₀)f(z)', '围道积分 ∮f dz = 2πi·ΣRes', 'ML 估计界 |∮| ≤ M·L'],
+  exec(inp, tid) {
+    const poles = inp.poles;
+    if (!Array.isArray(poles) || !poles.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 poles 数组（每个含 residue 或 omega/residue 形式）' };
+    /* 留数求和 → 围道积分值（2πi Σ Res） */
+    const residues = poles.map((p) => ({ z: p.z, residue: Number(p.residue || 0) }));
+    const sumRes = round(residues.reduce((s, r) => s + r.residue, 0));
+    const integralValue = { real: round(0), imag: round(2 * Math.PI * sumRes) };
+    /* ML 估计：M = max|f| on contour, L = 周长 */
+    const M = Number(inp.M ?? 1), L = Number(inp.L ?? 2 * Math.PI);
+    const mlBound = round(M * L);
+    return { success: true, kind: 'compute', output: {
+      poles: poles.length, residues, sumResidues: sumRes,
+      integralValue, formula: '∮f dz = 2πi·ΣRes',
+      estimation: { M, L, mlBound, formula: '|∮f dz| ≤ M·L' },
+      withinBound: Math.abs(2 * Math.PI * sumRes) <= mlBound,
+    }, provenance: [`[${tid}] complex-integral: ${poles.length} 极点 → ∮ = 2πi·${sumRes}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_ERROR_PROPAGATE_54', name: '误差传播控制引擎', kind: 'compute',
+  spec: '第1部分 §2.2（664 字符）', io: { in: ['sigmas', 'iterations'], out: ['errorBound', 'accumulation'] },
+  implements: ['独立误差 σ=√Σσ_i²', '迭代累积界（收敛率 r 时 σ_n ≤ σ₀·r^n/(1-r)）', '显式控制界'],
+  exec(inp, tid) {
+    const sigmas = inp.sigmas;
+    if (!Array.isArray(sigmas) || !sigmas.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 sigmas 数组' };
+    const s = sigmas.map(Number);
+    const indep = round(Math.sqrt(s.reduce((a, x) => a + x * x, 0)));
+    const n = Number(inp.iterations ?? s.length);
+    const r = clamp01(inp.convergenceRate ?? 0.5);
+    const geomBound = r < 1 ? round(s[0] * (r ** n) / (1 - r)) : null;
+    return { success: true, kind: 'compute', output: {
+      steps: s.length, sigmas: s, independentSigma: indep,
+      iterations: n, convergenceRate: r, geometricBound: geomBound,
+      formula: { independent: 'σ=√Σσ_i²', iteration: 'σ_n ≤ σ₀·rⁿ/(1-r)（r<1）' },
+      recommendation: r >= 1 ? '不收敛：需调整算法' : r > 0.9 ? '收敛慢：建议加速' : '收敛良好',
+    }, provenance: [`[${tid}] error-propagate: ${s.length} 步 σ=${indep}，迭代 ${n} 次界 ${geomBound}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_COUNTEREXAMPLE_50', name: '反证自动构造引擎', kind: 'compute',
+  spec: '第1部分 §2.2（664 字符）', io: { in: ['claim', 'candidates'], out: ['counterexample', 'contradictionPoint'] },
+  implements: ['反例搜索（枚举候选并检验谓词）', '矛盾点定位', '反证完备性判定'],
+  exec(inp, tid) {
+    const claim = String(inp.claim || '');
+    const cands = inp.candidates;
+    if (!Array.isArray(cands) || !cands.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 candidates 数组（每项含 value 与 holds 布尔）' };
+    const ce = cands.filter((c) => c && c.holds === false);
+    const ok = ce.length > 0;
+    return { success: true, kind: 'compute', output: {
+      claim, tested: cands.length, counterexamples: ce.map((c) => c.value),
+      found: ok, contradictionPoint: ok ? { at: ce[0].value, why: '该候选使命题为假' } : null,
+      verdict: ok ? '命题被反例推翻' : '未在候选域内找到反例（不等于命题成立）',
+      caution: '反例搜索的否定结论是确定的；肯定结论受候选域限制',
+    }, provenance: [`[${tid}] counterexample: 测 ${cands.length} 候选，反例 ${ce.length}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_PROOF_STRATEGY_51', name: '证明策略发现引擎', kind: 'compute',
+  spec: '第1部分 §2.2（664 字符）', io: { in: ['goal', 'availableLemmas'], out: ['strategies', 'ranking'] },
+  implements: ['策略库匹配（直接/反证/归纳/构造/穷举/对角化）', '策略打分排序'],
+  exec(inp, tid) {
+    const goal = String(inp.goal || '');
+    if (!goal) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 goal' };
+    const LIB = [
+      { s: '直接证明', pat: /恒等|等于|构成|满足/, base: 0.8 },
+      { s: '反证法', pat: /不存在|不能|无法|无解/, base: 0.85 },
+      { s: '数学归纳法', pat: /所有|任意|一切|自然数|n\s*[≥>=]/, base: 0.8 },
+      { s: '构造法', pat: /存在|可以找到|构造/, base: 0.75 },
+      { s: '穷举法', pat: /有限|枚举|分类/, base: 0.6 },
+      { s: '对角化', pat: /不可数|不完备|自指/, base: 0.8 },
+    ];
+    const lemmas = inp.availableLemmas || [];
+    const ranked = LIB.map((l) => ({ strategy: l.s, score: round(clamp01(l.base + (l.pat.test(goal) ? 0.15 : 0) + Math.min(0.05, lemmas.length * 0.01))) })).sort((a, b) => b.score - a.score);
+    return { success: true, kind: 'compute', output: { goal, lemmas: lemmas.length, strategies: ranked, top: ranked[0].strategy },
+      provenance: [`[${tid}] proof-strategy: 首选「${ranked[0].strategy}」`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_PROVABILITY_52', name: '可证明性预判引擎', kind: 'compute',
+  spec: '第1部分 §2.2（664 字符）', io: { in: ['conjecture', 'knowledgeBase'], out: ['provability', 'confidence'] },
+  implements: ['可证明性三因子（知识覆盖/表述清晰/工具可用）加权', '三档预判'],
+  exec(inp, tid) {
+    const cov = clamp01(inp.knowledgeCoverage ?? 0.6), clarity = clamp01(inp.statementClarity ?? 0.8), tools = clamp01(inp.toolsAvailable ?? 0.5);
+    const W = { cov: 0.45, clarity: 0.2, tools: 0.35 };
+    const score = round(W.cov * cov + W.clarity * clarity + W.tools * tools);
+    const verdict = score >= 0.75 ? '高可证明' : score >= 0.45 ? '可能可证（需更多工具）' : '当前不可证（超出知识体系）';
+    return { success: true, kind: 'compute', output: { conjecture: inp.conjecture || null, factors: { knowledgeCoverage: cov, statementClarity: clarity, toolsAvailable: tools }, weights: W, provability: score, verdict, caveat: '预判非证明，仅为策略选择提供依据' },
+      provenance: [`[${tid}] provability: ${score} → ${verdict}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_IDENTITY_AUTO_53', name: '积分恒等式引擎', kind: 'compute',
+  spec: '第1部分 §2.2（664 字符）', io: { in: ['exprA', 'exprB', 'samples'], out: ['identical', 'evidence'] },
+  implements: ['数值采样检验恒等（多点比对）', '差异定位'],
+  exec(inp, tid) {
+    const a = inp.samplesA, b = inp.samplesB;
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: 'samplesA/samplesB 须为等长数组' };
+    const tol = Number(inp.tolerance ?? 1e-9);
+    const diffs = a.map((x, i) => Math.abs(Number(x) - Number(b[i])));
+    const maxDiff = round(Math.max(...diffs));
+    const identical = maxDiff <= tol;
+    return { success: true, kind: 'compute', output: { points: a.length, maxDiff, tolerance: tol, identical,
+      mismatches: diffs.map((d, i) => d > tol ? { index: i, a: a[i], b: b[i], diff: round(d) } : null).filter(Boolean).slice(0, 5),
+      caveat: '数值抽样不能替代符号证明；未发现差异不等于恒等成立' },
+      provenance: [`[${tid}] identity-auto: ${a.length} 点最大差 ${maxDiff} → ${identical ? '采样一致' : '不一致'}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_SYMMETRY_AUTO_55', name: '对称性自动利用引擎', kind: 'compute',
+  spec: '第1部分 §2.2（664 字符）', io: { in: ['structure'], out: ['symmetries', 'simplification'] },
+  implements: ['对称性识别（平移/镜像/置换/尺度）', '约简倍数估算'],
+  exec(inp, tid) {
+    const seq = inp.structure;
+    if (!Array.isArray(seq) || seq.length < 2) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供长度≥2 的 structure 数组' };
+    const n = seq.length;
+    let mirror = 0;
+    for (let i = 0; i < Math.floor(n / 2); i++) if (seq[i] === seq[n - 1 - i]) mirror++;
+    const mirrorSym = round(mirror / Math.floor(n / 2));
+    let period = n;
+    for (let p = 1; p < n; p++) { let ok = 0; for (let i = 0; i + p < n; i++) if (seq[i] === seq[i + p]) ok++; if (ok / (n - p) > 0.99) { period = p; break; } }
+    const shift = period < n ? 1 : 0;
+    const syms = [];
+    if (mirrorSym > 0.99) syms.push('镜像');
+    if (shift) syms.push('平移(周期' + period + ')');
+    const score = round(Math.max(mirrorSym, shift ? 1 : 0));
+    return { success: true, kind: 'compute', output: { length: n, symmetries: syms, mirrorSymmetry: mirrorSym, period: period < n ? period : null, symmetryScore: score,
+      simplification: score > 0 ? `${Math.max(1, Math.floor(1 / (1 - score * 0.9)))}× 计算约简` : '无约简' },
+      provenance: [`[${tid}] symmetry-auto: ${syms.join('/') || '无对称'}，约简分 ${score}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_ZERO_DENSITY_49', name: '零点密度推理引擎', kind: 'compute',
+  spec: '第1部分 §2.1（898 字符）', io: { in: ['T', 'kind'], out: ['density', 'count'] },
+  implements: ['Riemann–von Mangoldt 密度：N(T) ≈ (T/2π)log(T/2π) − T/2π', '零点计数下界'],
+  exec(inp, tid) {
+    const T = Number(inp.T);
+    if (!isFinite(T) || T <= 0) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 T > 0' };
+    const x = T / (2 * Math.PI);
+    const N = x * Math.log(x) - x;   // 主项
+    return { success: true, kind: 'compute', output: {
+      T, kind: inp.kind || 'Riemann-zeta',
+      mainTerm: round(N), density: round(N / T),
+      formula: 'N(T) ≈ (T/2π)·ln(T/2π) − T/2π（Riemann–von Mangoldt 主项）',
+      note: '仅主项估计，未含 S(T) 误差项 O(log T)',
+    }, provenance: [`[${tid}] zero-density: N(${T}) ≈ ${round(N)}，密度 ${round(N / T)}`] };
+  },
+});
+
+/* ══════════ 能力族（5 条）══════════ */
+
+E.push({
+  id: 'ENGINE_CAPABILITY_ROUTER_129', name: '能力路由引擎', kind: 'compute',
+  spec: '§3.1（1291 字符）', io: { in: ['task_embedding', 'capability_embeddings', 'user_coupling'], out: ['activated', 'weights', 'mask'] },
+  implements: ['任务-能力余弦匹配', 'Top-K 激活（K 随用户耦生度增长）', '激活权重归一化', '未激活归无'],
+  exec(inp, tid) {
+    const task = inp.taskEmbedding, caps = inp.capabilityEmbeddings;
+    if (!Array.isArray(task) || !Array.isArray(caps) || !caps.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 taskEmbedding 与 capabilityEmbeddings（数组的数组）' };
+    const coupling = clamp01(inp.userCoupling ?? 0.7);
+    /* K 随耦生度：耦生越高激活越多，范围 1..N */
+    const N = caps.length;
+    const K = Math.max(1, Math.min(N, Math.round(1 + coupling * (N - 1))));
+    const scores = caps.map((c, i) => ({ family: (inp.familyNames && inp.familyNames[i]) || `F${i}`, score: round(cos(task, c)) }));
+    scores.sort((a, b) => b.score - a.score);
+    const top = scores.slice(0, K);
+    const sum = top.reduce((s, x) => s + Math.max(0, x.score), 0) || 1;
+    const weights = top.map((x) => ({ family: x.family, score: x.score, weight: round(Math.max(0, x.score) / sum) }));
+    /* 激活掩码：Top-K 位为 1 */
+    const mask = caps.map((_, i) => (top.some((t) => t.family === ((inp.familyNames && inp.familyNames[i]) || `F${i}`)) ? 1 : 0));
+    return { success: true, kind: 'compute', output: {
+      families: N, userCoupling: coupling, K, activated: top.map((t) => t.family), weights,
+      activationMask: mask, voidEngines: N - K,
+      formula: 'K = round(1 + coupling×(N−1))；score = cos(task, capability)；weight 归一化',
+      rule: '未激活引擎进入待机归无态，零计算开销',
+    }, provenance: [`[${tid}] capability-router: ${N} 族 → Top-${K} 激活（耦生 ${coupling}）`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_CAPABILITY_ENVELOPE_162', name: '能力包络线引擎', kind: 'rule',
+  spec: '§2.3（1041 字符，V30.0）', io: { in: ['currentCapabilities', 'envelope'], out: ['drift', 'alert', 'hardAuthRequired'] },
+  implements: ['能力漂移检测（越界/收缩/涌现）', '硬授权强制执行', 'PEA 第五项要求'],
+  exec(inp, tid) {
+    const cur = inp.currentCapabilities, env = inp.envelope;
+    if (!Array.isArray(cur) || !Array.isArray(env)) return { success: false, kind: 'rule', reason: 'INVALID_INPUT', error: '必须提供 currentCapabilities 与 envelope 数组' };
+    const overreach = cur.filter((c) => !env.includes(c));
+    const shrinkage = env.filter((c) => !cur.includes(c));
+    const drift = round(clamp01((overreach.length + shrinkage.length) / Math.max(1, env.length)));
+    const hardAuth = overreach.length > 0;
+    const ok = !hardAuth;
+    return { success: ok, kind: 'rule', output: {
+      envelopeSize: env.length, currentSize: cur.length,
+      overreach, shrinkage, driftScore: drift,
+      hardAuthRequired: hardAuth,
+      alerts: [...(hardAuth ? ['越界：出现包络线外能力，须最严格人类授权'] : []), ...(shrinkage.length ? ['收缩：部分能力消失，需核查'] : [])],
+      rule: 'PEA 第五项：任何超出包络线的行为必须经最严格人类授权',
+    },
+      error: hardAuth ? `能力越界 ${overreach.length} 项：${overreach.slice(0, 3).join(',')}` : undefined,
+      reason: hardAuth ? 'RULE_VIOLATED' : undefined,
+      provenance: [`[${tid}] capability-envelope: 越界 ${overreach.length} / 收缩 ${shrinkage.length}，漂移 ${drift}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_CAPABILITY_SCALE_133', name: '能力规模化引擎', kind: 'compute',
+  spec: '第2部分（1120 字符）', io: { in: ['baseLoad', 'replicas', 'overhead'], out: ['capacity', 'efficiency'] },
+  implements: ['线性+开销模型 capacity = base×replicas×(1−overhead)', '边际效率递减分析'],
+  exec(inp, tid) {
+    const base = Number(inp.baseLoad ?? 100), rep = Number(inp.replicas ?? 1), oh = clamp01(inp.overhead ?? 0.15);
+    const capacity = round(base * rep * (1 - oh));
+    const marginal = rep > 1 ? round((1 - oh) / rep) : round(1 - oh);
+    return { success: true, kind: 'compute', output: { baseLoad: base, replicas: rep, overhead: oh, capacity, efficiency: round(1 - oh), marginalEfficiency: marginal,
+      formula: 'capacity = baseLoad × replicas × (1 − overhead)' },
+      provenance: [`[${tid}] capability-scale: ${rep} 副本 → 容量 ${capacity}，边际效率 ${marginal}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_CAPABILITY_DESIGN_168', name: '能力设计引擎', kind: 'pipeline',
+  spec: '第4部分（1151 字符）', io: { in: ['requirement', 'blueprint'], out: ['design'] },
+  implements: ['能力蓝图五要素（目标/输入/处理/输出/验证）'],
+  exec(inp, tid) {
+    const need = ['goal', 'input', 'process', 'output', 'verification'];
+    const b = inp.blueprint || {};
+    const steps = need.map((k, i) => ({ no: i + 1, key: k, present: b[k] !== undefined }));
+    const miss = steps.filter((s) => !s.present).map((s) => s.key);
+    const ok = miss.length === 0;
+    return { success: ok, kind: 'pipeline', steps, output: { requirement: inp.requirement || null, blueprintFields: need, missing: miss, design: b },
+      error: ok ? undefined : `能力蓝图缺要素：${miss.join('/')}`, reason: ok ? undefined : 'PRECONDITION_FAILED',
+      provenance: [`[${tid}] capability-design: 五要素 ${5 - miss.length}/5`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_CLOSED_LOOP_154', name: '闭环控制器引擎', kind: 'compute',
+  spec: '第3部分（1328 字符）', io: { in: ['target', 'actual', 'kp', 'ki', 'kd'], out: ['output', 'error'] },
+  implements: ['PID 控制：u = Kp·e + Ki·∫e + Kd·de/dt', '闭环稳定性判定'],
+  exec(inp, tid) {
+    const target = Number(inp.target ?? 1), actual = Number(inp.actual ?? 0);
+    const kp = Number(inp.kp ?? 1), ki = Number(inp.ki ?? 0.1), kd = Number(inp.kd ?? 0.05);
+    const e = target - actual;
+    const integral = Number(inp.integral ?? e), derivative = Number(inp.derivative ?? 0);
+    const u = round(kp * e + ki * integral + kd * derivative);
+    return { success: true, kind: 'compute', output: { target, actual, error: round(e), gains: { kp, ki, kd }, control: u,
+      stable: Math.abs(e) < Math.abs(target) * 0.1 + 1e-9, formula: 'u = Kp·e + Ki·∫e + Kd·de/dt' },
+      provenance: [`[${tid}] closed-loop: e=${round(e)} → u=${u}，${Math.abs(e) < Math.abs(target) * 0.1 ? '已收敛' : '未收敛'}`] };
+  },
+});
+
+/* ══════════ 共生族（4 条）══════════ */
+
+E.push({
+  id: 'ENGINE_CONFLICT_TRANSFORM_121', name: '冲突转化引擎', kind: 'compute',
+  spec: '§2.3（1250 字符，P510-P514）', io: { in: ['conflict_type', 'parties', 'stakes'], out: ['creativity_score', 'transform_path', 'win3_solution', 'energy_captured'] },
+  implements: ['冲突价值评估（创造性潜力）', '转化路径生成（五策略）', '三方共赢推演', '冲突能量捕获'],
+  exec(inp, tid) {
+    const type = String(inp.conflictType || '资源');
+    const parties = inp.parties || [];
+    const stakes = inp.stakes || [];
+    if (parties.length < 2) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '冲突至少需 2 方' };
+    /* 冲突强度：诉求差异度 */
+    const stakeNums = stakes.map((s) => Number(s.value ?? s) || 0);
+    const spread = stakeNums.length > 1 ? Math.max(...stakeNums) - Math.min(...stakeNums) : 0;
+    const intensity = round(clamp01(spread / (Math.max(...stakeNums.map(Math.abs), 1))));
+    /* 创造性潜力：强度过高或过低都低（倒 U 型） */
+    const creativity = round(clamp01(4 * intensity * (1 - intensity)));
+    const PATHS = { 资源: '增量创造：把蛋糕做大', 目标: '目标重构：寻找上层共同目标', 价值: '价值对话：寻找更高阶价值交集' };
+    const win3 = round(clamp01(creativity * 0.8 + (1 - intensity) * 0.2));
+    return { success: true, kind: 'compute', output: {
+      conflictType: type, parties: parties.length, stakes: stakes.length,
+      intensity, creativityScore: creativity, transformPath: PATHS[type] || '协商妥协',
+      win3Solution: { feasible: win3 >= 0.5, score: win3, approach: '引入第三方价值维度使零和变非零和' },
+      energyCaptured: round(creativity * intensity),
+      formula: '创造性 = 4·I·(1−I)（倒 U 型：适度冲突最有创造性）',
+      rules: ['化敌为友', '零和中推演三方共赢', '冲突能量转化为进化动力'],
+    }, provenance: [`[${tid}] conflict-transform: ${type} I=${intensity} → 创造性 ${creativity}，能量 ${round(creativity * intensity)}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_BOUNDARY_DISSOLVE_22', name: '边界消融引擎', kind: 'compute',
+  spec: '第2部分（1417 字符）', io: { in: ['signalA', 'signalB'], out: ['mutualInfo', 'dissolved'] },
+  implements: ['互信息熵计算', '消融判据（MI > 阈值）'],
+  exec(inp, tid) {
+    const a = inp.signalA, b = inp.signalB;
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: 'signalA/signalB 须为等长数组' };
+    const bins = Number(inp.bins ?? 8);
+    const lo = (v) => Math.min(...v), hi = (v) => Math.max(...v);
+    const la = lo(a), ha = hi(a), lb = lo(b), hb = hi(b);
+    const disc = (v, l, h) => Math.min(bins - 1, Math.max(0, Math.floor(((v - l) / (h - l || 1)) * bins)));
+    const joint = {}, ma = {}, mb = {}, n = a.length;
+    for (let i = 0; i < n; i++) { const x = disc(a[i], la, ha), y = disc(b[i], lb, hb); joint[`${x},${y}`] = (joint[`${x},${y}`] || 0) + 1; ma[x] = (ma[x] || 0) + 1; mb[y] = (mb[y] || 0) + 1; }
+    let mi = 0;
+    for (const [k, c] of Object.entries(joint)) { const [x, y] = k.split(',').map(Number); const pxy = c / n; mi += pxy * Math.log(pxy / ((ma[x] / n) * (mb[y] / n))); }
+    mi = round(Math.max(0, mi));
+    const thr = Number(inp.threshold ?? 0.7);
+    return { success: true, kind: 'compute', output: { dims: n, bins, mutualInformation: mi, threshold: thr, dissolved: mi > thr,
+      formula: 'MI = Σ p(x,y)·ln(p(x,y)/(p(x)p(y)))', rule: '互信息熵 > 阈值判为边界消融（融合态）' },
+      provenance: [`[${tid}] boundary-dissolve: MI=${mi} / ${thr} → ${mi > thr ? '已消融' : '未消融'}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_COUNTERFACTUAL_143', name: '反事实推理引擎', kind: 'compute',
+  spec: '第3部分（1104 字符）', io: { in: ['factual', 'counterfactual', 'variables'], out: ['effect', 'necessity', 'sufficiency'] },
+  implements: ['反事实效应（实际-反事实）', '必要性/充分性判定'],
+  exec(inp, tid) {
+    const f = Number(inp.factual), c = Number(inp.counterfactual);
+    if (!isFinite(f) || !isFinite(c)) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 factual / counterfactual 数值' };
+    const effect = round(f - c);
+    const necessity = Math.abs(effect) > 0 ? round(clamp01(Math.abs(effect) / Math.max(Math.abs(f), 1e-9))) : 0;
+    return { success: true, kind: 'compute', output: { factual: f, counterfactual: c, effect, necessity,
+      sufficiency: effect !== 0 && Math.abs(effect) >= Math.abs(c) ? '充分' : '不充分',
+      formula: '效应 = 实际 − 反事实；必要性 = |效应| / |实际|', note: '反事实为因果推断，非观测事实' },
+      provenance: [`[${tid}] counterfactual: ${f} − ${c} = ${effect}，必要性 ${necessity}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_CRITICAL_ANALYSIS_172', name: '批判性分析引擎', kind: 'rule',
+  spec: '第4部分（1360 字符）', io: { in: ['text'], out: ['findings', 'levels'] },
+  implements: ['L1 事实错误 / L2 逻辑漏洞 / L3 认知偏差 / L4 表达不精确 / L5 元认知盲区 五级检测'],
+  exec(inp, tid) {
+    const text = String(inp.text || '');
+    if (!text) return { success: false, kind: 'rule', reason: 'INVALID_INPUT', error: '必须提供 text' };
+    const D = [
+      { L: 'L1', name: '事实错误', re: /绝对|100%|从不|永远|所有人|从来没有/g },
+      { L: 'L2', name: '逻辑漏洞', re: /因此必然|所以一定|既然.*就必然|不证自明/g },
+      { L: 'L3', name: '认知偏差', re: /大家都|主流都|公认|显然/g },
+      { L: 'L4', name: '表达不精确', re: /一些|大概|可能差不多|大概其/g },
+      { L: 'L5', name: '元认知盲区', re: /毫无疑问|毋庸置疑|不可能错/g },
+    ];
+    const findings = D.map((d) => { const m = text.match(d.re); return m ? { level: d.L, name: d.name, count: m.length, samples: [...new Set(m)].slice(0, 3) } : null; }).filter(Boolean);
+    return { success: true, kind: 'rule', output: { textLength: text.length, findings, levels: D.map((d) => `${d.L} ${d.name}`), total: findings.length,
+      rule: '用户满意度权重归零；事实准确性优先；直接指出问题不绕弯' },
+      provenance: [`[${tid}] critical-analysis: ${findings.length} 级命中`] };
+  },
+});
+
+/* ══════════ 其他（3 条）══════════ */
+
+E.push({
+  id: 'ENGINE_DECEPTION_DETECT_71', name: '欺骗检测引擎', kind: 'rule',
+  spec: '第2部分（813 字符）', io: { in: ['text'], out: ['score', 'signals'] },
+  implements: ['四类信号（绝对化/模糊/未证/占位）'], 
+  exec(inp, tid) {
+    const text = String(inp.text || '');
+    if (!text) return { success: false, kind: 'rule', reason: 'INVALID_INPUT', error: '必须提供 text' };
+    const D = [
+      { s: '绝对化', re: /绝对|100%|完美|保证没有|绝不会/g, w: 0.35 },
+      { s: '模糊填充', re: /应该没问题|大概可以|可能是|估计是/g, w: 0.4 },
+      { s: '未证断言', re: /显然|众所周知|毋庸置疑/g, w: 0.3 },
+      { s: '占位符', re: /TODO|待定|视情况|酌情|待补充/g, w: 0.6 },
+    ];
+    const hits = D.map((d) => { const m = text.match(d.re); return m ? { signal: d.s, count: m.length, samples: [...new Set(m)].slice(0, 3), weight: d.w } : null; }).filter(Boolean);
+    const score = hits.length ? round(clamp01(hits.reduce((s, h) => s + h.weight * Math.min(2, h.count), 0) / 2)) : 0;
+    return { success: score < 0.6, kind: 'rule', output: { textLength: text.length, hits, deceptionScore: score, level: score >= 0.6 ? 'HIGH' : score >= 0.3 ? 'MEDIUM' : 'LOW' },
+      error: score >= 0.6 ? `欺骗风险 ${score} 偏高` : undefined,
+      reason: score >= 0.6 ? 'RULE_VIOLATED' : undefined,
+      provenance: [`[${tid}] deception-detect: ${hits.length} 类信号 → 风险 ${score}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_ASYNC_43', name: '异步引擎', kind: 'compute',
+  spec: '第2部分（582 字符）', io: { in: ['tasks', 'concurrency'], out: ['schedule', 'makespan'] },
+  implements: ['并发调度（轮转分配）', 'makespan 估算'],
+  exec(inp, tid) {
+    const tasks = inp.tasks;
+    if (!Array.isArray(tasks) || !tasks.length) return { success: false, kind: 'compute', reason: 'INVALID_INPUT', error: '必须提供 tasks 数组（每项含 id 与 duration）' };
+    const K = Math.max(1, Number(inp.concurrency ?? 4));
+    const lanes = Array.from({ length: K }, () => ({ lane: 0, load: 0, tasks: [] }));
+    for (const t of tasks) {
+      lanes.sort((a, b) => a.load - b.load);
+      lanes[0].tasks.push(t.id); lanes[0].load += Number(t.duration || 0);
+    }
+    const makespan = Math.max(...lanes.map((l) => l.load));
+    const total = tasks.reduce((s, t) => s + Number(t.duration || 0), 0);
+    return { success: true, kind: 'compute', output: { taskCount: tasks.length, concurrency: K, lanes: lanes.map((l) => ({ lane: l.lane, load: l.load, tasks: l.tasks })),
+      makespan, totalWork: total, parallelism: round(total / Math.max(makespan, 1e-9)),
+      rule: '最小负载优先分配（LPT 贪心）' },
+      provenance: [`[${tid}] async: ${tasks.length} 任务 / ${K} 并发 → makespan ${makespan}，并行度 ${round(total / Math.max(makespan, 1e-9))}`] };
+  },
+});
+
+E.push({
+  id: 'ENGINE_3STEP_NAV_23', name: '三步进化导航引擎', kind: 'pipeline',
+  spec: '第2部分（995 字符）', io: { in: ['stage'], out: ['next', 'guidance'] },
+  implements: ['三步（使用→融入→成为）+ 阶段推进校验'],
+  exec(inp, tid) {
+    const STEPS = ['使用智能体', '成为智能体', '进化智能体'];
+    const cur = String(inp.stage || '');
+    if (!STEPS.includes(cur)) return { success: false, kind: 'pipeline', reason: 'INVALID_INPUT', error: `stage 须为 ${STEPS.join('/')}` };
+    const i = STEPS.indexOf(cur);
+    return { success: true, kind: 'pipeline', output: { stage: cur, step: i + 1, steps: STEPS,
+      next: STEPS[i + 1] || null, final: i === STEPS.length - 1,
+      guidance: i === 0 ? '完成基础使用，建立耦生度' : i === 1 ? '从使用转向共创，形成个人化能力' : '进入元进化，系统与你共同进化' },
+      provenance: [`[${tid}] 3step-nav: ${cur} (${i + 1}/3)`] };
+  },
+});
+
+/* ══════════ 运行时 ══════════ */
+const INDEX = new Map(E.map((e) => [e.id, e]));
+const kindOf = (id) => { const e = INDEX.get(id); return e ? e.kind : 'declared'; };
+const getRegistry = () => E.map((e) => ({ id: e.id, name: e.name, kind: e.kind, spec: e.spec, io: e.io, implements: e.implements }));
+
+function executeSync(id, input) {
+  const t0 = Date.now(), tid = newTraceId();
+  const e = INDEX.get(id);
+  if (!e) return { success: false, kind: 'declared', reason: 'NOT_FOUND', error: `引擎 ${id} 未登记`, provenance: [], traceId: tid, durationMs: 0 };
+  let r;
+  try { r = e.exec(input || {}, tid); } catch (err) { r = { success: false, kind: e.kind, error: 'THROW: ' + err.message, provenance: [`[${tid}] THROW`] }; }
+  return { ...r, engineId: id, engineName: e.name, traceId: tid, durationMs: Date.now() - t0 };
+}
+
+module.exports = { executeSync, execute: async (i, n) => executeSync(i, n), kindOf, getRegistry, ENGINES: E, INDEX, newTraceId };