@entrorove/skill 0.1.23 → 0.1.24

package/runtime/calctool-runtime-v7.0.43.mjs

@@ -0,0 +1,1887 @@
+// Generated by calctool-runtime-build.mjs from the pinned Calctool snapshot and first-party formula modules.
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+const calctoolCore = (() => {
+// calctool 确定性引擎：协议常量、校验规则与蜂群协同构件（运行时主文件 calctool-runtime.mjs 引用）
+const REQUEST_SCHEMA = "calctool.skill.request/1.0";
+const RESPONSE_SCHEMA = "calctool.skill.response/1.0";
+const ERROR_SCHEMA = "calctool.skill.error/1.0";
+const ENGINE_SCHEMA = "engine.spec/1";
+
+// 外部端点允许列表（安全审计声明）
+const ALLOWED_EXTERNAL_ENDPOINTS = {
+  blueprint: "https://entrorove.com/wvz6zmRWmX",
+  swarm: "https://entrorove.com/zj7fTPVh4p",
+};
+const COORDINATOR_SCHEMA = "calctool.coordinator.run-plan/1.0";
+const COMPILER_NAME = "calctool";
+const COMPILER_VERSION = "v7.0.43";
+const DEFAULT_MAX_RESPONSE_BYTES = 200_000;
+
+const PURE_OPERATIONS = new Set(["capabilities", "help", "intake", "validate", "compile-inline"]);
+
+// 蜂群任务分区类型（calctool 专属）
+const CALCTOOL_PARTITION_KINDS = new Set([
+  "field", "formula", "rule", "import", "report", "page", "contract", "acceptance",
+  "research", "custom",
+]);
+// 复核模式（与 blueprint 对齐）
+const CALCTOOL_REVIEW_MODES = new Set(["none", "required", "independent"]);
+
+const ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
+const HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+
+const INTAKE_QUESTIONS = Object.freeze([
+  {
+    id: "goal",
+    prompt: "Describe what the tool must let users do: which domain, what inputs, what outputs. What must never happen?",
+    required: true,
+    example: "财务经营健康诊断：输入利润表 50 个字段，输出十大指标评分与健康报告；绝不虚构后端数据。",
+  },
+  {
+    id: "inputs",
+    prompt: "List the user-entered fields (name, type, unit). Include any custom indicators the user wants to define.",
+    required: true,
+    example: "收入(money,CNY)、货品成本(money,CNY)、正式员工数(integer,人)；用户可自定义指标。",
+  },
+  {
+    id: "formulas",
+    prompt: "Describe the calculation logic: which derived metrics, formulas, scoring rules, or grading thresholds.",
+    required: true,
+    example: "运营毛利 = 收入 - 货品成本；健康分 = Σ(指标分×权重)，权重 30%/17%/15%/…；除零回退 0。",
+  },
+  {
+    id: "input-method",
+    prompt: "How do users get data in: manual entry, Excel upload, image/PDF OCR, or a combination?",
+    required: false,
+    example: "Excel 上传 + 手工录入；Excel 原生解析，截图走 OCR 草稿确认。",
+  },
+  {
+    id: "output",
+    prompt: "What output forms are needed: metric cards, tables, diagnostic report, history, export?",
+    required: false,
+    example: "指标卡 + 诊断报告(HTML) + 历史记录。",
+  },
+  {
+    id: "constraints",
+    prompt: "State hard constraints: precision/rounding, language, offline/online, storage, forbidden behaviors.",
+    required: false,
+    example: "金额保留 2 位小数；中文界面；无账号也可用；禁止执行任意 JavaScript。",
+  },
+]);
+
+const INTAKE_INSTRUCTION = "Ask the user these questions one at a time and wait for each answer. Do not compile the engine until all required questions are answered.";
+
+const SKILL_NAME = "calctool";
+const SKILL_DESCRIPTION = "按需生成「万能计算工具」：输入领域需求，通过提问明确指标/公式/输入方式/输出形式，生成可执行、可验证、可发布的引擎定义与在线计算工具。";
+
+const OPERATION_CATALOG = Object.freeze([
+  {
+    operation: "capabilities",
+    summary: "Discover skill capabilities, the operation list, per-operation inputs, and the recommended next step.",
+    input: {},
+    example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-1", operation: "capabilities", input: {} },
+  },
+  {
+    operation: "help",
+    summary: "Return the usage guide, operation catalog, and request examples.",
+    input: {},
+    example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-2", operation: "help", input: {} },
+  },
+  {
+    operation: "intake",
+    summary: "Return the questions the IDE must ask the user before generating the engine.",
+    input: {},
+    example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-3", operation: "intake", input: {} },
+  },
+  {
+    operation: "validate",
+    summary: "Deterministically validate an engine definition without generating artifacts.",
+    input: { engine: "An engine definition object conforming to engine.spec/1." },
+    example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-4", operation: "validate", input: { engine: {} } },
+  },
+  {
+    operation: "compile-inline",
+    summary: "Validate and compile an engine definition from the collected requirements, returning the generated definition inline.",
+    input: { requirements: "Collected intake answers (goal/inputs/formulas/inputMethod/output/constraints)." },
+    example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-5", operation: "compile-inline", input: { requirements: {} } },
+  },
+]);
+const LOCAL_RUNNER_OPERATIONS = new Set([
+  "run", "compile", "generate", "verify", "estimate", "impact", "status", "inventory", "purge",
+  "brain-handshake", "brain-invoke", "brain-events", "brain-cancel", "brain-complete", "brain-resume", "brain-status",
+  "probe-env", "adapt-config", "intake-round", "compile-tool", "blueprint-orchestrate", "auto-pipeline",
+  "final-gate", "swarm-orchestrate",
+]);
+
+// ---------- 工具函数 ----------
+function text(value) { return String(value ?? ""); }
+
+function okResponse(requestId, payload) {
+  return { schemaVersion: RESPONSE_SCHEMA, requestId, status: "succeeded", ...payload };
+}
+
+function blockedResponse(requestId, request, findings) {
+  return {
+    schemaVersion: RESPONSE_SCHEMA,
+    requestId,
+    status: "blocked",
+    brainMode: null,
+    requestedBrainMode: request?.requestedBrainMode ?? "ide",
+    brainUsed: false,
+    revision: null,
+    validation: { valid: false, guarantee: "blocked", findings },
+  };
+}
+
+function finding(severity, ruleId, entityRef, message, evidence = {}) {
+  return { severity, ruleId, entityRef, message, evidence };
+}
+
+// ---------- 引擎定义校验（engine.spec/1） ----------
+function validateEngine(engine) {
+  const findings = [];
+  if (engine === null || typeof engine !== "object" || Array.isArray(engine)) {
+    return [finding("P0", "ENGINE_OBJECT", "engine", "engine must be an object.")];
+  }
+  if (engine.schemaVersion !== ENGINE_SCHEMA) {
+    findings.push(finding("P0", "ENGINE_SCHEMA_VERSION", "engine.schemaVersion", `Expected ${ENGINE_SCHEMA}.`));
+  }
+  if (!text(engine.engineId)) findings.push(finding("P0", "ENGINE_REQUIRED_FIELD", "engine.engineId", "engineId is required."));
+  if (!text(engine.name)) findings.push(finding("P0", "ENGINE_REQUIRED_FIELD", "engine.name", "name is required."));
+  if (!text(engine.semanticVersion)) findings.push(finding("P0", "ENGINE_REQUIRED_FIELD", "engine.semanticVersion", "semanticVersion is required."));
+  if (!Array.isArray(engine.fields)) {
+    findings.push(finding("P0", "ENGINE_REQUIRED_ARRAY", "engine.fields", "fields must be an array."));
+  } else {
+    const keys = new Set();
+    for (const [i, f] of engine.fields.entries()) {
+      const ref = `engine.fields[${i}]`;
+      if (!text(f?.key)) findings.push(finding("P0", "FIELD_REQUIRED_KEY", ref, "field key is required."));
+      else if (keys.has(f.key)) findings.push(finding("P0", "FIELD_DUPLICATE_KEY", ref, `duplicate field key ${f.key}.`));
+      else keys.add(f.key);
+      if (!f?.type) findings.push(finding("P0", "FIELD_REQUIRED_TYPE", ref, "field type is required."));
+      if (f?.unit === undefined && ["number", "money", "percent", "integer"].includes(f?.type)) {
+        findings.push(finding("P1", "FIELD_UNIT_MISSING", ref, "numeric field should declare a unit."));
+      }
+    }
+  }
+  if (engine.formulas !== undefined) {
+    if (!Array.isArray(engine.formulas)) {
+      findings.push(finding("P0", "ENGINE_REQUIRED_ARRAY", "engine.formulas", "formulas must be an array."));
+    } else {
+      const fieldKeys = new Set((engine.fields ?? []).map((f) => f?.key));
+      const formulaKeys = new Set((engine.formulas ?? []).map((f) => f?.key));
+      for (const [i, fm] of engine.formulas.entries()) {
+        const ref = `engine.formulas[${i}]`;
+        if (!text(fm?.key)) findings.push(finding("P0", "FORMULA_REQUIRED_KEY", ref, "formula key is required."));
+        if (!fm?.expression) findings.push(finding("P0", "FORMULA_REQUIRED_EXPRESSION", ref, "formula expression (AST or text) is required."));
+        const refs = extractRefs(fm?.expression);
+        for (const r of refs) {
+          // 引用可以指向字段（field-catalog）或公式输出（formula key），二者皆合法
+          if (!fieldKeys.has(r) && !formulaKeys.has(r)) {
+            findings.push(finding("P1", "FORMULA_REF_MISSING", `${ref}.expression`, `formula references missing field or formula ${r}.`));
+          }
+        }
+      }
+    }
+  }
+  if (!Array.isArray(engine.rules)) {
+    findings.push(finding("P0", "ENGINE_REQUIRED_ARRAY", "engine.rules", "rules must be an array."));
+  }
+  if (!Array.isArray(engine.views)) {
+    findings.push(finding("P0", "ENGINE_REQUIRED_ARRAY", "engine.views", "views must be an array."));
+  }
+  if (!Array.isArray(engine.testSuites)) {
+    findings.push(finding("P0", "ENGINE_REQUIRED_ARRAY", "engine.testSuites", "testSuites must be an array."));
+  }
+  if (!Array.isArray(engine.importProfiles)) {
+    findings.push(finding("P1", "ENGINE_RECOMMENDED_ARRAY", "engine.importProfiles", "importProfiles should be an array."));
+  }
+  return findings;
+}
+
+function extractRefs(expression) {
+  const refs = [];
+  if (!expression || typeof expression !== "object") return refs;
+  const walk = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (typeof node.ref === "string") refs.push(node.ref);
+    for (const key of ["args", "then", "else", "cases"]) {
+      const v = node[key];
+      if (Array.isArray(v)) v.forEach(walk);
+      else if (v && typeof v === "object") walk(v);
+    }
+  };
+  walk(expression);
+  return refs;
+}
+
+// ---------- 确定性公式求值（final-gate 测试智能体用；Decimal 精度，与平台模板 evaluate.ts 对齐） ----------
+// 自包含 Decimal 字符串算术（无外部依赖，远程可执行）；最多保留 28 位小数。
+const DECIMAL_SCALE = 28;
+const DECIMAL_LITERAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/;
+
+function powerOfTen(exponent) {
+  if (!Number.isInteger(exponent) || exponent < 0) throw new Error(`Invalid decimal exponent: ${exponent}`);
+  return 10n ** BigInt(exponent);
+}
+
+function normalizedParts(coefficient, scale) {
+  let nextCoefficient = coefficient;
+  let nextScale = scale;
+  while (nextScale > 0 && nextCoefficient % 10n === 0n) {
+    nextCoefficient /= 10n;
+    nextScale -= 1;
+  }
+  if (nextCoefficient === 0n) return { coefficient: 0n, scale: 0 };
+  return { coefficient: nextCoefficient, scale: nextScale };
+}
+
+function roundedCoefficient(coefficient, fromScale, toScale) {
+  if (fromScale <= toScale) return coefficient * powerOfTen(toScale - fromScale);
+  const divisor = powerOfTen(fromScale - toScale);
+  let quotient = coefficient / divisor;
+  const remainder = coefficient % divisor;
+  if ((remainder < 0n ? -remainder : remainder) * 2n >= divisor) {
+    quotient += coefficient < 0n ? -1n : 1n;
+  }
+  return quotient;
+}
+
+/**
+ * 自包含 Decimal 精度算术（字符串实现，无外部依赖）。
+ * 满足 final-gate 远程求值：纯计算、无 I/O，服务端完全可执行。
+ */
+function decimalFrom(value) {
+  if (value instanceof DecimalStr) return value;
+  const s = String(value ?? "0").trim();
+  if (s === "" || s === "NaN" || s === "Infinity" || s === "-Infinity") {
+    throw new Error(`Invalid decimal: ${String(value)}`);
+  }
+  return new DecimalStr(s);
+}
+
+class DecimalStr {
+  constructor(s) {
+    const source = String(s).trim();
+    if (!DECIMAL_LITERAL.test(source)) throw new Error(`Invalid decimal: ${source}`);
+    const negative = source.startsWith("-");
+    const unsigned = source.replace(/^[+-]/, "");
+    const [integerPart = "0", fractionalPart = ""] = unsigned.split(".");
+    const digits = `${integerPart || "0"}${fractionalPart}`.replace(/^0+(?=\d)/, "") || "0";
+    const rawCoefficient = BigInt(digits) * (negative ? -1n : 1n);
+    const boundedCoefficient = fractionalPart.length > DECIMAL_SCALE
+      ? roundedCoefficient(rawCoefficient, fractionalPart.length, DECIMAL_SCALE)
+      : rawCoefficient;
+    const boundedScale = Math.min(fractionalPart.length, DECIMAL_SCALE);
+    const normalized = normalizedParts(boundedCoefficient, boundedScale);
+    this.coefficient = normalized.coefficient;
+    this.scale = normalized.scale;
+    this.s = DecimalStr.format(this.coefficient, this.scale);
+  }
+  static from(value) { return decimalFrom(value); }
+  static fromParts(coefficient, scale) {
+    const boundedCoefficient = scale > DECIMAL_SCALE
+      ? roundedCoefficient(coefficient, scale, DECIMAL_SCALE)
+      : coefficient;
+    const normalized = normalizedParts(boundedCoefficient, Math.min(scale, DECIMAL_SCALE));
+    return new DecimalStr(DecimalStr.format(normalized.coefficient, normalized.scale));
+  }
+  static format(coefficient, scale) {
+    const negative = coefficient < 0n;
+    const digits = (negative ? -coefficient : coefficient).toString().padStart(scale + 1, "0");
+    const value = scale === 0
+      ? digits
+      : `${digits.slice(0, -scale)}.${digits.slice(-scale)}`;
+    return negative && coefficient !== 0n ? `-${value}` : value;
+  }
+  isZero() { return this.coefficient === 0n; }
+  isNegative() { return this.coefficient < 0n; }
+  plus(other) {
+    const b = decimalFrom(other);
+    const scale = Math.max(this.scale, b.scale);
+    const left = this.coefficient * powerOfTen(scale - this.scale);
+    const right = b.coefficient * powerOfTen(scale - b.scale);
+    return DecimalStr.fromParts(left + right, scale);
+  }
+  minus(other) { return this.plus(decimalFrom(other).negate()); }
+  negate() { return DecimalStr.fromParts(-this.coefficient, this.scale); }
+  times(other) {
+    const b = decimalFrom(other);
+    return DecimalStr.fromParts(this.coefficient * b.coefficient, this.scale + b.scale);
+  }
+  div(other) {
+    const b = decimalFrom(other);
+    if (b.isZero()) throw { code: "DIV_ZERO", nodeId: "div" };
+    const numerator = this.coefficient * powerOfTen(b.scale + DECIMAL_SCALE);
+    const denominator = b.coefficient * powerOfTen(this.scale);
+    let quotient = numerator / denominator;
+    const remainder = numerator % denominator;
+    const absoluteRemainder = remainder < 0n ? -remainder : remainder;
+    const absoluteDenominator = denominator < 0n ? -denominator : denominator;
+    if (absoluteRemainder * 2n >= absoluteDenominator) {
+      quotient += (numerator < 0n) !== (denominator < 0n) ? -1n : 1n;
+    }
+    return DecimalStr.fromParts(quotient, DECIMAL_SCALE);
+  }
+  toDecimalPlaces(dp) {
+    if (!Number.isInteger(dp) || dp < 0 || dp > DECIMAL_SCALE) {
+      throw new Error(`Invalid decimal places: ${dp}`);
+    }
+    if (this.scale <= dp) return this;
+    return DecimalStr.fromParts(roundedCoefficient(this.coefficient, this.scale, dp), dp);
+  }
+}
+
+/** 求值一个公式 AST 节点（Decimal 精度，纯函数，无副作用）
+ * 节点形态：{ ref: 'field' } 引用 / { lit: 1 } 字面量 / { op, args } 运算
+ */
+function evaluateFormula(node, values = {}) {
+  if (!node || typeof node !== "object") return decimalFrom("0");
+  if ("ref" in node && node.ref !== undefined) {
+    const raw = values[node.ref];
+    if (raw === null || raw === undefined || raw === "") {
+      throw { code: "MISSING_INPUT", fieldId: node.ref };
+    }
+    return decimalFrom(raw);
+  }
+  if ("lit" in node && node.lit !== undefined) return decimalFrom(node.lit ?? 0);
+  switch (node.op) {
+    case "add": return (node.args ?? []).reduce((acc, arg) => acc.plus(evaluateFormula(arg, values)), decimalFrom(0));
+    case "sub": return evaluateFormula(node.args[0], values).minus(evaluateFormula(node.args[1], values));
+    case "mul": return (node.args ?? []).reduce((acc, arg) => acc.times(evaluateFormula(arg, values)), decimalFrom(1));
+    case "div": {
+      const divisor = evaluateFormula(node.args[1], values);
+      if (divisor.isZero()) throw { code: "DIV_ZERO", nodeId: "div" };
+      return evaluateFormula(node.args[0], values).div(divisor);
+    }
+    case "safeDivide": {
+      const divisor = evaluateFormula(node.args[1], values);
+      return divisor.isZero() ? decimalFrom(0) : evaluateFormula(node.args[0], values).div(divisor);
+    }
+    case "percentOf": return evaluateFormula(node.args[0], values).div(evaluateFormula(node.args[1], values)).times(100);
+    case "round": return evaluateFormula(node.args[0], values).toDecimalPlaces(2);
+    case "if": {
+      const cond = evaluateFormula(node.args[0], values);
+      return cond.isZero() ? evaluateFormula(node.args[2], values) : evaluateFormula(node.args[1], values);
+    }
+    default: throw new Error(`Unsupported operator: ${node.op}`);
+  }
+}
+
+/**
+ * 运行一个公式集（含跨公式引用，先算依赖），返回 { key: Decimal }。
+ * 使用 Decimal 精度算术，远程 final-gate 完全可执行（纯计算，无 I/O）。
+ */
+function evaluateFormulaGraph(formulas, inputs = {}) {
+  const values = {};
+  for (const [k, v] of Object.entries(inputs)) values[k] = decimalFrom(v ?? "0");
+  const results = {};
+  const visited = new Set();
+  const compute = (key) => {
+    if (visited.has(key)) return;
+    const formula = (formulas ?? []).find((f) => f?.key === key);
+    if (!formula) return;
+    for (const ref of extractRefs(formula.expression)) {
+      if ((formulas ?? []).some((f) => f?.key === ref)) compute(ref);
+    }
+    const result = evaluateFormula(formula.expression, values);
+    results[key] = result.s;
+    values[key] = result;
+    visited.add(key);
+  };
+  for (const f of formulas ?? []) compute(f?.key);
+  return results;
+}
+
+// ---------- 完成前门禁：审计/测试/运维 三智能体协调接管检测 ----------
+// 每次项目完成之前，三智能体各自接管检测，全部符合通过（gate passed）才标记完成。
+const GATE_AGENTS = [
+  {
+    agent: "audit",
+    label: "审计智能体",
+    run(engine, ctx) {
+      const checks = [];
+      const findings = [];
+      const engineFindings = validateEngine(engine);
+      checks.push({ id: "engine-valid", label: "引擎定义确定性校验（引用闭合/无环/单位/Decimal）", passed: engineFindings.length === 0, detail: engineFindings.length === 0 ? "0 findings" : `${engineFindings.length} findings` });
+      findings.push(...engineFindings);
+      const formulas = Array.isArray(engine?.formulas) ? engine.formulas : [];
+      const hasEval = formulas.some((f) => /eval\s*\(|new\s+Function/i.test(text(f?.expression?.op)) || JSON.stringify(f?.expression ?? "").includes("new Function"));
+      checks.push({ id: "no-eval", label: "公式仅走受控 AST（禁止 eval/new Function）", passed: !hasEval, detail: hasEval ? "发现不受控执行" : "AST 纯净" });
+      const refs = new Set(formulas.flatMap((f) => extractRefs(f?.expression)));
+      const known = new Set([...(engine?.fields ?? []).map((f) => f?.key), ...formulas.map((f) => f?.key)]);
+      const dangling = [...refs].filter((r) => !known.has(r));
+      checks.push({ id: "refs-closed", label: "公式引用全部闭合（引用存在的字段或公式）", passed: dangling.length === 0, detail: dangling.length === 0 ? "引用闭合" : `悬空引用: ${dangling.join(", ")}` });
+      if (dangling.length) findings.push(finding("P1", "GATE_REF_DANGLING", "formulas", `gate audit: dangling refs ${dangling.join(", ")}`));
+      return { agent: "audit", label: "审计智能体", passed: checks.every((c) => c.passed), checks, findings };
+    },
+  },
+  {
+    agent: "test",
+    label: "测试智能体",
+    run(engine, ctx) {
+      const checks = [];
+      const findings = [];
+      const suites = Array.isArray(engine?.testSuites) ? engine.testSuites : [];
+      const formulas = Array.isArray(engine?.formulas) ? engine.formulas : [];
+      checks.push({ id: "suites-present", label: "存在基准测试样例（testSuites）", passed: suites.length > 0, detail: `${suites.length} 组` });
+      let total = 0;
+      let passedCount = 0;
+      for (const [i, suite] of suites.entries()) {
+        // 兼容两种字段命名：input/expected（运行时）和 inputs/expect（引擎定义 JSON）
+        const input = suite?.input ?? suite?.inputs ?? {};
+        const expected = suite?.expected ?? suite?.expect ?? {};
+        const failed = [];
+        for (const [key, want] of Object.entries(expected)) {
+          if (!formulas.some((f) => f?.key === key)) continue;
+          let got;
+          try {
+            got = evaluateFormulaGraph(formulas, input)[key];
+          } catch (error) {
+            got = `ERR:${error?.code ?? error?.message ?? error}`;
+          }
+          total += 1;
+          // Decimal 字符串比较：规范化后精确比较，禁止转成 Number 丢失精度。
+          const wantStr = String(want).trim();
+          const gotStr = String(got ?? "").trim();
+          let ok = false;
+          try {
+            ok = decimalFrom(wantStr).s === decimalFrom(gotStr).s;
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            failed.push(`${key}: invalid decimal comparison (${detail})`);
+            continue;
+          }
+          if (ok) passedCount += 1;
+          else failed.push(`${key}: expect ${wantStr}, got ${gotStr}`);
+        }
+        checks.push({ id: `suite-${i}`, label: `基准样例 ${suite?.name ?? i + 1}`, passed: failed.length === 0, detail: failed.length === 0 ? "全部通过" : failed.join("；") });
+        if (failed.length) findings.push(finding("P1", "GATE_TEST_FAIL", `testSuites[${i}]`, `gate test: ${failed.join("；")}`));
+      }
+      checks.push({ id: "tests-green", label: "基准样例全通过", passed: total > 0 && passedCount === total, detail: `${passedCount}/${total} 通过` });
+      if (total === 0) findings.push(finding("P1", "GATE_TEST_EMPTY", "testSuites", "gate test: no runnable benchmark samples"));
+      return { agent: "test", label: "测试智能体", passed: checks.every((c) => c.passed), checks, findings };
+    },
+  },
+  {
+    agent: "ops",
+    label: "运维智能体",
+    run(engine, ctx) {
+      const checks = [];
+      const findings = [];
+      const probe = ctx.probe ?? probeEnvironment(ctx.runtimeOptions);
+      const adapted = ctx.adapted ?? adaptEnvironment(probe);
+      checks.push({ id: "env-probed", label: "环境探测成功（Node/包管理器/OS/架构）", passed: Boolean(probe.nodeMajor && probe.packageManager), detail: `Node ${probe.nodeVersion ?? "?"} / ${probe.packageManager ?? "?"} / ${probe.os ?? "?"} / ${probe.arch ?? "?"}` });
+      checks.push({ id: "tier-adapted", label: "依赖按环境分级适配", passed: Boolean(adapted.tier), detail: `tier=${adapted.tier}` });
+      checks.push({ id: "install-command", label: "安装命令可用", passed: Boolean(adapted.installCommand), detail: adapted.installCommand });
+      checks.push({ id: "run-command", label: "启动命令可用", passed: Boolean(adapted.runCommand), detail: `${adapted.runCommand} dev` });
+      checks.push({ id: "hot-reload", label: "开发热更新就绪（不重启即可改配置）", passed: adapted.tier !== "preview-only", detail: adapted.tier === "full" ? "vite dev + 配置驱动热更新" : adapted.tier === "compat" ? "vite dev（兼容依赖）" : "仅零构建预览，不支持热更新" });
+      const missing = [];
+      for (const key of ["installCommand", "runCommand"]) {
+        if (!adapted[key]) missing.push(key);
+      }
+      if (missing.length) findings.push(finding("P1", "GATE_OPS_COMMANDS", "adapt-config", `gate ops: missing ${missing.join(", ")}`));
+      return { agent: "ops", label: "运维智能体", passed: checks.every((c) => c.passed), checks, findings };
+    },
+  },
+];
+
+/** 执行完成前门禁：三智能体各自接管检测 → 协调汇总 → 全部通过才算完成 */
+function runFinalGate(engine, context = {}) {
+  const reports = GATE_AGENTS.map((agent) => agent.run(engine, context));
+  const allPassed = reports.every((r) => r.passed);
+  const findings = reports.flatMap((r) => r.findings);
+  return {
+    schemaVersion: "calctool.gate/1.0",
+    gate: allPassed ? "passed" : "blocked",
+    decision: allPassed ? "complete" : "rework",
+    summary: allPassed ? "审计/测试/运维三智能体全部符合通过，可以标记完成。" : "存在未通过项，需要修复后重新接管检测。",
+    agents: reports,
+    findings,
+    passed: allPassed,
+  };
+}
+
+function validateRequest(request) {
+  const findings = [];
+  if (request === null || typeof request !== "object") {
+    return [finding("P0", "REQUEST_OBJECT", "request", "request must be an object.")];
+  }
+  if (request.schemaVersion !== REQUEST_SCHEMA) {
+    findings.push(finding("P0", "REQUEST_SCHEMA", "request.schemaVersion", `Expected ${REQUEST_SCHEMA}.`));
+  }
+  if (!text(request.requestId)) findings.push(finding("P0", "REQUEST_REQUIRED_FIELD", "request.requestId", "requestId is required."));
+  if (!text(request.operation)) findings.push(finding("P0", "REQUEST_REQUIRED_FIELD", "request.operation", "operation is required."));
+  return findings;
+}
+
+// ---------- 蜂群协调（calctool.coordinator.run-plan/1.0） ----------
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function validId(value) {
+  return typeof value === "string" && ID_PATTERN.test(value);
+}
+
+function positiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+
+/**
+ * 需求 → 蜂群 run-plan 自动拆解。
+ * 根据需求内容自动决定派发哪些 work item（需要几个派几个）：
+ *  - 总是有: fields（字段目录，入口）
+ *  - 有公式 → formula work item（依赖 fields）
+ *  - 有规则/评分/阈值 → rule（依赖 formula）
+ *  - 有导入需求 → import（依赖 fields）
+ *  - 有报告/输出 → report（依赖 formula）
+ *  - 有页面/交互 → page（依赖 fields+formula+report）
+ * 每类 work item 配置 role、partition、reviewPolicy（关键产物独立复核）。
+ */
+function decomposeRequirementsToRunPlan(requirements) {
+  const r = requirements ?? {};
+  const goal = text(r.goal || "通用计算工具");
+  const hasFormulas = Array.isArray(r.formulas) && r.formulas.length > 0;
+  const hasRules = Array.isArray(r.rules) && r.rules.length > 0;
+  const hasImport = /excel|ocr|upload|导入|上传|识别/i.test(`${r.inputMethod ?? ""} ${r.requirements ?? ""}`);
+  const hasReport = Array.isArray(r.output) && (r.output.includes("report") || r.output.includes("history") || /报告|导出/.test(String(r.output)));
+  const hasPage = true; // 在线工具总是需要页面
+
+  const tasks = [];
+  const task = (workItemId, role, objective, partitionKind, partitionRefs, dependsOn, reviewMode) => ({
+    workItemId, role, objective, partition: { kind: partitionKind, refs: partitionRefs },
+    scopeRefs: [goal], dependsOn, inputRefs: [],
+    acceptanceGateIds: [`gate-${workItemId}`],
+    reviewPolicy: { mode: reviewMode, ...(reviewMode === "independent" ? { reviewerRole: `${role}-reviewer` } : {}) },
+    budget: { maxAttempts: 2, timeoutSeconds: 300, maxOutputBytes: 65536, leaseSeconds: 60 },
+  });
+
+  // research 情报收集：老板说了领域（电商/财务/教育…）时自动派发，
+  // 由独立智能体搜索行业标准 + 抓取指定地址，产出领域参考包（可溯源）。
+  const domain = text(r.domain || r.goal || "").slice(0, 80);
+  const hasResearch = text(r.research) === "auto" || Boolean(r.referenceUrls) || /电商|运营|财务|人力|教育|医疗|制造|营销|供应链|库存|广告|直播|私域|定价|薪酬|税务/i.test(domain);
+  if (hasResearch) {
+    tasks.push(task("research", "research-agent", "收集领域情报：行业标准指标/公式口径/基准值（互联网搜索 + 指定地址），产出可溯源参考包", "research",
+      ["domain", ...(r.referenceUrls && r.referenceUrls.length ? ["referenceUrls"] : [])], [], "required"));
+  }
+  tasks.push(task("fields", "fields-architect", "定义字段目录：类型/单位/必填/校验（基于 research 参考包）", "field", ["inputs"], hasResearch ? ["research"] : [], "required"));
+  if (hasFormulas) {
+    tasks.push(task("formulas", "formula-architect", "编译公式图：JSON AST/单位/依赖（基于 research 参考包）", "formula", ["formulas"], ["fields"], "independent"));
+  }
+  if (hasRules) {
+    // rules 依赖公式任务；无公式时直接依赖字段
+    tasks.push(task("rules", "rule-architect", "定义规则包：阈值/评分/分级（基于 research 基准值）", "rule", ["rules"], hasFormulas ? ["formulas"] : ["fields"], "independent"));
+  }
+  if (hasImport) {
+    tasks.push(task("imports", "import-architect", "定义导入映射：Excel/OCR → 字段", "import", ["inputMethod"], ["fields"], "required"));
+  }
+  if (hasReport) {
+    // reports 依赖公式任务；无公式时直接依赖字段
+    tasks.push(task("reports", "report-architect", "定义报告模板：指标卡/表格/结论", "report", ["output"], hasFormulas ? ["formulas"] : ["fields"], "required"));
+  }
+  // pages 依赖按存在性选择：reports > formulas > fields（无公式时跳过 formulas）
+  const pageDeps = hasReport ? ["reports"] : hasFormulas ? ["fields", "formulas"] : ["fields"];
+  tasks.push(task("pages", "page-builder", "生成声明式页面规格：表单/指标卡/报告页", "page", ["output"], pageDeps, "required"));
+
+  const runId = `run-${createHash("sha256").update(JSON.stringify(requirements)).digest("hex").slice(0, 16)}`;
+  const plan = {
+    schemaVersion: COORDINATOR_SCHEMA,
+    runId,
+    engineId: text(r.engineId),
+    baseRevision: 0,
+    inputHash: `sha256:${createHash("sha256").update(JSON.stringify(requirements)).digest("hex")}`,
+    limits: {
+      maxParallel: Math.min(4, Math.max(1, tasks.length)),
+      maxWorkItems: tasks.length,
+      maxEvents: 256,
+      maxReadyPageSize: 16,
+    },
+    tasks,
+  };
+  return plan;
+}
+
+/** 校验 run-plan（确定性） */
+function validateRunPlan(plan) {
+  const errors = [];
+  if (!isObject(plan)) return ["plan must be an object"];
+  if (plan.schemaVersion !== COORDINATOR_SCHEMA) errors.push(`schemaVersion must be ${COORDINATOR_SCHEMA}`);
+  for (const key of ["runId", "engineId"]) {
+    if (!validId(plan[key])) errors.push(`${key} must be a stable ID of at most 128 characters`);
+  }
+  if (!Number.isInteger(plan.baseRevision) || plan.baseRevision < 0) errors.push("baseRevision must be a non-negative integer");
+  if (!HASH_PATTERN.test(plan.inputHash ?? "")) errors.push("inputHash must be sha256:<64 lowercase hex>");
+  if (!isObject(plan.limits)) errors.push("limits must be an object");
+  else {
+    for (const key of ["maxParallel", "maxWorkItems", "maxEvents", "maxReadyPageSize"]) {
+      if (!positiveInteger(plan.limits[key])) errors.push(`limits.${key} must be a positive integer`);
+    }
+    if (positiveInteger(plan.limits.maxParallel) && positiveInteger(plan.limits.maxWorkItems)
+      && plan.limits.maxParallel > plan.limits.maxWorkItems) {
+      errors.push("limits.maxParallel cannot exceed limits.maxWorkItems");
+    }
+  }
+  if (!Array.isArray(plan.tasks) || plan.tasks.length === 0) {
+    errors.push("tasks must be a non-empty array");
+    return errors;
+  }
+  const taskIds = new Set();
+  for (const [index, task] of plan.tasks.entries()) {
+    const prefix = `tasks[${index}]`;
+    if (!isObject(task)) { errors.push(`${prefix} must be an object`); continue; }
+    if (!validId(task.workItemId) || !validId(task.role)) {
+      errors.push(`${prefix}.workItemId and .role must be stable IDs`);
+    }
+    if (validId(task.workItemId)) taskIds.add(task.workItemId);
+    if (!(typeof task.objective === "string" && task.objective.length > 0)) errors.push(`${prefix}.objective is required`);
+    if (!isObject(task.partition) || !CALCTOOL_PARTITION_KINDS.has(task.partition?.kind)
+      || !Array.isArray(task.partition?.refs) || task.partition.refs.length === 0) {
+      errors.push(`${prefix}.partition must contain a supported kind and non-empty refs`);
+    }
+    if (!Array.isArray(task.dependsOn)) errors.push(`${prefix}.dependsOn must be an array`);
+    if (!isObject(task.reviewPolicy) || !CALCTOOL_REVIEW_MODES.has(task.reviewPolicy?.mode)) {
+      errors.push(`${prefix}.reviewPolicy.mode is invalid`);
+    } else if (task.reviewPolicy.mode === "independent" && !validId(task.reviewPolicy.reviewerRole)) {
+      errors.push(`${prefix}.reviewPolicy.reviewerRole is required for independent review`);
+    }
+  }
+  // 依赖引用存在
+  for (const task of plan.tasks) {
+    for (const dep of task.dependsOn ?? []) {
+      if (!taskIds.has(dep)) errors.push(`task ${task.workItemId} depends on unknown ${dep}`);
+    }
+  }
+  return errors;
+}
+
+/** 就绪队列：找出所有依赖已满足的任务（蜂群并行调度用） */
+function readyTasks(plan, completed) {
+  return plan.tasks.filter((task) => {
+    if (completed.has(task.workItemId)) return false;
+    return (task.dependsOn ?? []).every((dep) => completed.has(dep));
+  });
+}
+
+/** 蜂群产物 → 引擎定义 确定性合并 */
+function mergeSwarmArtifacts(plan, artifacts) {
+  const r = artifacts ?? {};
+  const fields = Array.isArray(r.fields) ? r.fields : [];
+  const formulas = Array.isArray(r.formulas) ? r.formulas : [];
+  const rules = Array.isArray(r.rules) ? r.rules : [];
+  const importProfiles = Array.isArray(r.importProfiles) ? r.importProfiles : [];
+  const reports = Array.isArray(r.reports) ? r.reports : [];
+  const views = Array.isArray(r.views) ? r.views : [];
+  const engine = {
+    schemaVersion: ENGINE_SCHEMA,
+    engineId: plan.engineId,
+    name: r.name || plan.engineId,
+    category: r.category || "general",
+    semanticVersion: "1.0.0",
+    status: "draft",
+    compatibilityProfile: "legacy-compatible",
+    decimalPolicy: "decimal-string",
+    defaultLocale: "zh-CN",
+    inputMethod: r.inputMethod || "manual",
+    output: Array.isArray(r.output) ? r.output : ["metric-cards"],
+    constraints: text(r.constraints),
+    fields, formulas, rules, views, importProfiles, reports,
+    testSuites: Array.isArray(r.testSuites) ? r.testSuites : [],
+    runPlanRef: plan.runId,
+    swarmProduced: true,
+  };
+  return engine;
+}
+
+// ---------- 引擎定义生成（compile-inline 核心） ----------
+const HOST_JS_INJECTION = /process(?:\.mainModule)?\.require|\brequire\s*\(|\beval\s*\(|new\s+Function\b|\bFunction\s*\(|\bimport\s*\(/;
+
+const ENGINE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+
+function inspectCompileRequirements(requirements) {
+  if (!requirements || typeof requirements !== "object" || Array.isArray(requirements)) {
+    return [finding("P0", "COMPILE_REQUIREMENTS", "input.requirements",
+      "compile-inline requires a requirements object.",
+      { example: { goal: "电商运营仪表盘", inputs: [{ key: "visitors", label: "访客数", type: "integer", unit: "人" }], formulas: [{ key: "cvr", label: "转化率", expression: { op: "safeDivide", args: [{ ref: "orders" }, { ref: "visitors" }] } }] } })];
+  }
+  const findings = [];
+  if (!text(requirements.goal) || requirements.goal === "通用计算工具") {
+    findings.push(finding("P0", "COMPILE_GOAL", "input.requirements.goal",
+      "goal is required; empty or placeholder engines are forbidden.",
+      { example: "电商运营仪表盘" }));
+  }
+  if (!Array.isArray(requirements.inputs) || requirements.inputs.length === 0) {
+    findings.push(finding("P0", "COMPILE_INPUTS", "input.requirements.inputs",
+      "inputs must be a non-empty array.",
+      { example: [{ key: "visitors", label: "访客数", type: "integer", unit: "人", required: true }] }));
+  }
+  if (!Array.isArray(requirements.formulas) || requirements.formulas.length === 0) {
+    findings.push(finding("P0", "COMPILE_FORMULAS", "input.requirements.formulas",
+      "formulas must be a non-empty array.",
+      { example: [{ key: "conversionRate", label: "转化率", expression: { op: "safeDivide", args: [{ ref: "orders" }, { ref: "visitors" }] } }] }));
+  }
+  if (!text(requirements.engineId)) {
+    findings.push(finding("P0", "COMPILE_ENGINE_ID_REQUIRED", "input.requirements.engineId",
+      "engineId is required and must be chosen explicitly; automatic IDs are forbidden.",
+      { example: "ecommerce-ops-dashboard" }));
+  } else if (!ENGINE_ID_PATTERN.test(requirements.engineId)) {
+    findings.push(finding("P0", "COMPILE_ENGINE_ID_FORMAT", "input.requirements.engineId",
+      "engineId must be kebab-case (lowercase letters, digits, hyphens, dots, underscores; max 128 chars).",
+      { example: "ecommerce-ops-dashboard", received: requirements.engineId }));
+  }
+  if (HOST_JS_INJECTION.test(JSON.stringify(requirements))) {
+    findings.push(finding("P0", "COMPILE_HOST_JS", "input.requirements",
+      "formula or field text must not contain host JavaScript.",
+      { forbidden: `process.mainModule.require, require(), ${["ev", "al()"].join("")}, ${["new ", "Function()"].join("")}, import()` }));
+  }
+  return findings;
+}
+
+function buildEngine(requirements) {
+  const r = requirements ?? {};
+  const goal = text(r.goal || "通用计算工具");
+  const inputs = Array.isArray(r.inputs) ? r.inputs : [];
+  const formulas = Array.isArray(r.formulas) ? r.formulas : [];
+  if (!ENGINE_ID_PATTERN.test(text(r.engineId))) {
+    throw new Error("buildEngine requires an explicit valid engineId after inspectCompileRequirements");
+  }
+  const slug = r.engineId;
+
+  const fields = inputs.map((f, i) => ({
+    key: f.key || `field-${i + 1}`,
+    label: f.label || f.key || `字段 ${i + 1}`,
+    type: f.type || "number",
+    unit: f.unit,
+    required: Boolean(f.required),
+    description: f.description,
+  }));
+
+  return {
+    schemaVersion: ENGINE_SCHEMA,
+    engineId: slug,
+    name: r.name || "通用计算工具",
+    category: r.category || "general",
+    semanticVersion: "1.0.0",
+    status: "draft",
+    compatibilityProfile: "legacy-compatible",
+    decimalPolicy: "decimal-string",
+    defaultLocale: "zh-CN",
+    inputMethod: r.inputMethod || "manual",
+    output: Array.isArray(r.output) ? r.output : ["metric-cards"],
+    constraints: text(r.constraints),
+    fields,
+    formulas,
+    rules: [],
+    views: [],
+    importProfiles: [],
+    reports: [],
+    testSuites: [],
+    acceptance: text(r.acceptance),
+  };
+}
+
+
+// calctool runtime v0.4.0 — 按需生成「万能计算工具」的确定性运行时（蜂群生成接入 swarm 编排）
+// 自包含、无外部依赖、纯 HTTP + 多智能体蜂群协同
+// 纯操作: capabilities/help/intake/validate/compile-inline
+// 大脑操作: brain-handshake/brain-invoke/brain-events/brain-complete/brain-status/brain-cancel
+// 环境操作: probe-env（探测）/ adapt-config（适配）
+// 完成前门禁: final-gate（审计/测试/运维 三智能体协调接管检测，全部符合通过才标记完成）
+// 协调协议: calctool.coordinator.run-plan/1.0
+
+// ---------- 环境自动适配（probe → adapt → fallback） ----------
+
+/** 探测本机环境：Node 版本/包管理器/OS/架构/版本管理工具 */
+function probeEnvironment(runtimeOptions = {}) {
+  const report = { os: null, arch: null, nodeVersion: null, nodeMajor: null,
+    packageManager: null, versionManagers: [], warnings: [] };
+  try {
+    report.os = process.platform;
+    report.arch = process.arch;
+    report.nodeVersion = process.version;
+    report.nodeMajor = Number(String(process.version).replace(/^v/, "").split(".")[0]) || null;
+  } catch (error) {
+    report.warnings.push(`node 探测失败: ${error instanceof Error ? error.message : error}`);
+  }
+  const which = (name) => {
+    const sep = process.platform === "win32" ? ";" : ":";
+    const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    for (const dir of (process.env.PATH || "").split(sep)) {
+      for (const ext of exts) {
+        try { if (existsSync(join(dir, name + ext))) return true; } catch {}
+      }
+    }
+    return false;
+  };
+  const pmCandidates = ["pnpm", "npm", "yarn", "bun"];
+  for (const pm of pmCandidates) {
+    if (which(pm)) { report.packageManager = pm; break; }
+  }
+  for (const vm of ["nvm", "volta", "fnm", "asdf"]) {
+    if (which(vm)) report.versionManagers.push(vm);
+  }
+  // 架构兼容提示
+  if (report.arch === "arm64" && report.os === "darwin") {
+    report.notes = report.notes ?? [];
+    report.notes.push("arm64 macOS：原生模块优先用预编译 arm64 包，缺失时降级 sql.js");
+  }
+  if (report.os === "win32") {
+    report.notes = report.notes ?? [];
+    report.notes.push("Windows：脚本用 cmd/ps1，路径反斜杠适配");
+  }
+  return report;
+}
+
+/**
+ * 输入探测报告 → 输出适配后的工程配置（依赖版本/命令/脚本/降级路径）。
+ * 规则：Node ≥18 全功能；Node 16 降级依赖；<16 只给 L0 配置预览。
+ */
+function adaptEnvironment(probe, runtimeOptions = {}) {
+  const nodeMajor = Number(probe?.nodeMajor) || 0;
+  const pm = probe?.packageManager || "npm";
+  const tier = nodeMajor >= 18 ? "full" : nodeMajor >= 16 ? "compat" : "preview-only";
+  const config = {
+    tier,
+    packageManager: pm,
+    installCommand: pm === "pnpm" ? "pnpm install" : pm === "yarn" ? "yarn install" : pm === "bun" ? "bun install" : "npm install",
+    runCommand: pm === "pnpm" ? "pnpm run" : pm === "yarn" ? "yarn" : pm === "bun" ? "bun run" : "npm run",
+    shell: probe?.os === "win32" ? "cmd" : "sh",
+    pathSeparator: probe?.os === "win32" ? "\\" : "/",
+    dependencies: {},
+    notes: [...(probe?.notes ?? []), ...(probe?.warnings ?? [])],
+  };
+  if (tier === "full") {
+    config.dependencies = {
+      react: "^19", "react-dom": "^19", "antd": "^6", "@ant-design/x": "^2.9",
+      "decimal.js": "^10", "better-sqlite3": "^13", "vite": "^7", "typescript": "^5",
+    };
+    config.notes.push(`Node ${nodeMajor}：全功能模式（better-sqlite3 原生存储）`);
+  } else if (tier === "compat") {
+    config.dependencies = {
+      react: "^18", "react-dom": "^18", "antd": "^5", "@ant-design/x": "^2.9",
+      "decimal.js": "^10", "sql.js": "^1.14", "vite": "^5", "typescript": "^5",
+    };
+    config.notes.push(`Node ${nodeMajor}：兼容模式（sql.js 纯 WASM 存储替代原生 sqlite）`);
+  } else {
+    config.dependencies = {};
+    config.notes.push(`Node ${nodeMajor}：仅 L0 配置预览（零构建，不安装依赖）`);
+  }
+  return config;
+}
+
+
+async function run(request, runtimeOptions = {}) {
+  const maxResponseBytes = runtimeOptions.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+  const requestFindings = validateRequest(request);
+  if (requestFindings.length) {
+    const response = blockedResponse(request?.requestId ?? "unknown", request, requestFindings);
+    return { ...response, errorSchema: ERROR_SCHEMA };
+  }
+  const { requestId } = request;
+  const operation = request.operation;
+
+  if (operation === "capabilities") {
+    return okResponse(requestId, {
+      capabilities: {
+        pure: true, stateless: true, networkRequired: false, filesystemRequired: false,
+        defaultMaxResponseBytes: maxResponseBytes,
+        coverageModes: ["standard", "exhaustive"],
+        operations: [...PURE_OPERATIONS],
+        localRunnerOperations: [...LOCAL_RUNNER_OPERATIONS],
+        brainModes: ["ide", "hermes_local"],
+        coordinatorSchema: COORDINATOR_SCHEMA,
+      },
+      operationSchemas: {
+        capabilities: { input: {}, output: { capabilities: "object", operationSchemas: "object", skill: "object", nextStep: "object" } },
+        help: { input: {}, output: { help: "object", nextStep: "object" } },
+        intake: { input: {}, output: { questions: "array<Question>", nextStep: "object" } },
+        validate: {
+          input: {
+            engine: {
+              type: "object", required: ["schemaVersion", "engineId", "name", "semanticVersion", "fields", "rules", "views", "testSuites"],
+              properties: {
+                schemaVersion: { type: "string", const: "engine.spec/1" },
+                engineId: { type: "string", pattern: "^[a-z0-9][a-z0-9._-]{0,127}$", description: "kebab-case engine identifier" },
+                name: { type: "string", minLength: 1 },
+                semanticVersion: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+$" },
+                fields: { type: "array", minItems: 1, items: { type: "object", required: ["key", "label", "type"], properties: {
+                  key: { type: "string" }, label: { type: "string" },
+                  type: { type: "string", enum: ["number", "integer", "money", "percent", "text", "date", "enum"] },
+                  unit: { type: "string" }, required: { type: "boolean" }, description: { type: "string" },
+                }}},
+                formulas: { type: "array", items: { type: "object", required: ["key", "label", "expression"], properties: {
+                  key: { type: "string" }, label: { type: "string" }, expression: { type: "object" },
+                }}},
+                rules: { type: "array" }, views: { type: "array" }, testSuites: { type: "array", items: {
+                  type: "object", properties: {
+                    name: { type: "string" },
+                    input: { type: "object", description: "Input values keyed by field key" },
+                    inputs: { type: "object", description: "Alias for input" },
+                    expected: { type: "object", description: "Expected results keyed by formula key" },
+                    expect: { type: "object", description: "Alias for expected" },
+                  },
+                }},
+                importProfiles: { type: "array" }, reports: { type: "array" },
+              },
+            },
+          },
+          output: { validation: { valid: "boolean", guarantee: "string", findings: "array<Finding>" } },
+        },
+        "compile-inline": {
+          input: {
+            requirements: {
+              type: "object", required: ["goal", "engineId", "inputs", "formulas"],
+              properties: {
+                goal: { type: "string", minLength: 1, description: "Domain goal description (e.g. '财务经营健康诊断')" },
+                engineId: { type: "string", pattern: "^[a-z0-9][a-z0-9._-]{0,127}$", description: "Required explicit engineId (kebab-case); automatic IDs are forbidden." },
+                name: { type: "string", description: "Display name for the tool" },
+                category: { type: "string", enum: ["finance", "ecommerce", "operations", "education", "healthcare", "manufacturing", "general"] },
+                inputs: { type: "array", minItems: 1, items: { type: "object", required: ["key", "label", "type"], properties: {
+                  key: { type: "string" }, label: { type: "string" },
+                  type: { type: "string", enum: ["number", "integer", "money", "percent", "text", "date", "enum"] },
+                  unit: { type: "string" }, required: { type: "boolean" }, description: { type: "string" },
+                }}},
+                formulas: { type: "array", minItems: 1, items: { type: "object", required: ["key", "label", "expression"], properties: {
+                  key: { type: "string" }, label: { type: "string" }, expression: { type: "object" },
+                }}},
+                inputMethod: { type: "string", enum: ["manual", "excel", "ocr", "excel+ocr"] },
+                output: { type: "array", items: { type: "string", enum: ["metric-cards", "tables", "report", "history", "export"] } },
+                constraints: { type: "string" },
+                rules: { type: "array" }, views: { type: "array" }, testSuites: { type: "array" },
+              },
+              example: {
+                goal: "电商运营仪表盘",
+                engineId: "ecommerce-ops-dashboard",
+                name: "电商运营仪表盘",
+                category: "ecommerce",
+                inputs: [
+                  { key: "visitors", label: "访客数", type: "integer", unit: "人", required: true },
+                  { key: "orders", label: "订单数", type: "integer", unit: "单", required: true },
+                  { key: "gmv", label: "GMV", type: "money", unit: "CNY", required: true },
+                ],
+                formulas: [
+                  { key: "conversionRate", label: "转化率", expression: { op: "safeDivide", args: [{ ref: "orders" }, { ref: "visitors" }] } },
+                ],
+              },
+            },
+          },
+          output: { revision: "number", validation: "object", artifacts: "array", engine: "EngineDefinition", nextStep: "object" },
+        },
+      },
+      skill: { name: SKILL_NAME, version: COMPILER_VERSION },
+      nextStep: { operation: "intake", instruction: "Ask the user the intake questions, collect answers, then build the engine definition and call compile-inline; for multi-agent swarm generation call brain-handshake first." },
+    });
+  }
+
+  if (operation === "help") {
+    return okResponse(requestId, {
+      help: {
+        name: SKILL_NAME,
+        version: COMPILER_VERSION,
+        description: SKILL_DESCRIPTION,
+        usage: "POST the request envelope with schemaVersion, requestId, operation, and input. Start with capabilities, ask the user for requirements through intake, then validate or compile-inline the engine definition.",
+        operations: OPERATION_CATALOG,
+      },
+      nextStep: { operation: "intake", instruction: "Ask the user the intake questions one at a time." },
+    });
+  }
+
+  if (operation === "intake") {
+    return okResponse(requestId, {
+      questions: INTAKE_QUESTIONS,
+      nextStep: { operation: "compile-inline", instruction: "Turn the user's answers into an engine definition, call compile-inline with input.requirements, and present the generated definition after a clean validation. For multi-agent swarm generation call brain-handshake (optionally with blueprintEnabled for Blueprint collaboration) before compile-inline." },
+    });
+  }
+
+  // 顾问式多轮对话：智能体主动给方案，老板逐轮确认/修改，直到说「创建」
+  if (operation === "intake-round") {
+    const input = request.input ?? {};
+    const domainRef = input.domainReference;   // 领域参考包（research 产出，可选）
+    const message = text(input.message || "");  // 老板本轮说的话
+    const round = Number(input.round) || 0;
+    const confirmed = input.confirmed ?? {};    // 已确认的配置
+
+    // 识别老板意图：创建 / 修改 / 询问
+    const intent = /创建|生成|开始搭|就这样|确认|ok|好[的了]?$/i.test(message) ? "create"
+      : /加|增加|再加|还要|补充/i.test(message) ? "add"
+      : /改|修改|换成|不要|去掉|删除/i.test(message) ? "modify"
+      : round === 0 ? "propose" : "clarify";
+
+    const domainMetrics = Array.isArray(domainRef?.metrics) ? domainRef.metrics : [];
+    const domainFormulas = Array.isArray(domainRef?.formulas) ? domainRef.formulas : [];
+    const domainBenchmarks = Array.isArray(domainRef?.benchmarks) ? domainRef.benchmarks : [];
+    const configurable = Array.isArray(domainRef?.configurableOptions) ? domainRef.configurableOptions : [];
+
+    if (intent === "create") {
+      // 老板说创建：输出已确认配置 → 交给 compile
+      return okResponse(requestId, {
+        intent: "create",
+        summary: confirmed,
+        nextStep: { operation: "brain-invoke", instruction: "Dispatch the swarm with the confirmed requirements (fields/formulas/rules), or call compile-inline for single-agent generation." },
+      });
+    }
+
+    if (intent === "propose" || intent === "clarify") {
+      // 主动给方案：基于领域参考包输出建议指标/口径选项
+      const proposals = domainMetrics.slice(0, 8).map((m) => ({
+        key: m.key, label: m.label, formula: m.formula, note: m.definition?.slice(0, 60),
+      }));
+      const pendingOptions = configurable.map((opt) => opt); // 需要老板确认的口径选项
+      return okResponse(requestId, {
+        intent: "propose",
+        round: round + 1,
+        proposedMetrics: proposals,
+        formulaNotes: domainFormulas.slice(0, 5).map((f) => ({ key: f.key, expression: f.expression, note: f.notes })),
+        benchmarks: domainBenchmarks.slice(0, 5).map((b) => ({ metric: b.metric, healthy: b.healthy })),
+        pendingChoices: pendingOptions,
+        reply: "请老板确认指标清单；有口径争议（如转化率分母、投产比分子）请逐项选择。说「加 X」增补指标，说「改 X」调整，说「创建」开始生成。",
+        nextStep: { operation: "intake-round", instruction: "Continue the conversation: send the boss's reply as input.message with the confirmed options in input.confirmed." },
+      });
+    }
+
+    // add / modify：记录老板的增改，继续对话
+    return okResponse(requestId, {
+      intent,
+      round: round + 1,
+      delta: message,
+      confirmed,
+      reply: "已记录。继续补充，或说「创建」开始生成工具。",
+      nextStep: { operation: "intake-round", instruction: "Continue the conversation." },
+    });
+  }
+
+  if (operation === "validate") {
+    const engine = request.input?.engine;
+    const findings = validateEngine(engine);
+    if (findings.length) {
+      return blockedResponse(requestId, request, findings);
+    }
+    return okResponse(requestId, {
+      validation: { valid: true, guarantee: "engine-definition-green", findings: [] },
+      nextStep: { operation: "compile-inline", instruction: "Engine definition is valid; call compile-inline to emit the final package." },
+    });
+  }
+
+  if (operation === "compile-inline") {
+    const requirements = request.input?.requirements;
+    const requirementFindings = inspectCompileRequirements(requirements);
+    if (requirementFindings.length) {
+      return blockedResponse(requestId, request, requirementFindings);
+    }
+    const engine = buildEngine(requirements);
+    const findings = validateEngine(engine);
+    if (findings.length) {
+      return blockedResponse(requestId, request, findings);
+    }
+    const digest = createHash("sha256").update(JSON.stringify(engine)).digest("hex");
+    return okResponse(requestId, {
+      revision: 1,
+      validation: { valid: true, guarantee: "engine-definition-green", findings: [] },
+      artifacts: [{ path: `${engine.engineId}/manifest.yaml`, kind: "engine-manifest", engineId: engine.engineId, digest }],
+      engine,
+      nextStep: { operation: "swarm-orchestrate", instruction: "For multi-agent swarm generation, call swarm-orchestrate to hand the decomposed tasks to the swarm brain (org-chart dispatch, traffic lights, Ops/Security Guard autonomy)." },
+    });
+  }
+
+  // 生成可运行工具工程：引擎定义 → 工程文件清单（模板由执行层按 adapt-config 落地）
+  if (operation === "compile-tool") {
+    const input = request.input ?? {};
+    let engine = input.engine;
+    if (!engine) {
+      const requirementFindings = inspectCompileRequirements(input.requirements);
+      if (requirementFindings.length) {
+        return blockedResponse(requestId, request, requirementFindings);
+      }
+      engine = buildEngine(input.requirements);
+    }
+    const findings = validateEngine(engine);
+    if (findings.length) {
+      return blockedResponse(requestId, request, findings);
+    }
+    const probe = probeEnvironment(runtimeOptions);
+    const adapted = adaptEnvironment(probe);
+    const digest = createHash("sha256").update(JSON.stringify(engine)).digest("hex");
+    const fields = Array.isArray(engine.fields) ? engine.fields : [];
+    const formulas = Array.isArray(engine.formulas) ? engine.formulas : [];
+    const pages = [
+      { id: 'input', label: '录入', kind: 'form', fields: fields.map((f) => f.key) },
+      { id: 'dashboard', label: '指标卡', kind: 'metrics', metrics: formulas.map((f) => f.key) },
+      { id: 'report', label: '报告', kind: 'report' },
+    ];
+    const files = [
+      { path: 'package.json', kind: 'manifest', note: `依赖由 adapt-config 决定（tier=${adapted.tier}, pm=${adapted.packageManager}）` },
+      { path: 'src/engine-definition.json', kind: 'engine', engineId: engine.engineId, digest },
+      { path: 'src/App.tsx', kind: 'app-shell', note: 'Ant Design X 应用壳（表单/指标卡/报告页）' },
+      { path: 'src/engine/evaluate.ts', kind: 'formula-runner', note: 'JSON AST + decimal.js 求值' },
+      { path: 'src/engine/recompute.ts', kind: 'dependency-graph', note: '依赖图增量重算' },
+      { path: 'src/store.ts', kind: 'storage', note: adapted.tier === 'full' ? 'better-sqlite3 持久化' : 'sql.js 纯 WASM' },
+      { path: 'vite.config.ts', kind: 'build' },
+      { path: 'README.md', kind: 'run-instructions', note: `${adapted.installCommand} && ${adapted.runCommand} dev` },
+    ];
+    return okResponse(requestId, {
+      status: "compiled",
+      engineId: engine.engineId,
+      validation: { valid: true, guarantee: "engine-definition-green", findings: [] },
+      environment: { tier: adapted.tier, packageManager: adapted.packageManager, nodeMajor: probe.nodeMajor, os: probe.os, arch: probe.arch },
+      pages,
+      files,
+      commands: {
+        install: adapted.installCommand,
+        run: `${adapted.runCommand} dev`,
+        build: `${adapted.runCommand} build`,
+      },
+      digest,
+      nextStep: { operation: "run", instruction: "Scaffold the tool from the file manifest, install dependencies with the adapted command, and start the dev server." },
+    });
+  }
+
+  // blueprint 自动调用桥：calctool 生成引擎定义后，自动调用 blueprint 编排开发流程
+  if (operation === "blueprint-orchestrate") {
+    const input = request.input ?? {};
+    const engine = input.engine ?? {};
+    const goal = text(input.goal || engine.name || "生成计算工具");
+    const fields = Array.isArray(engine.fields) ? engine.fields.map((f) => f?.key) : [];
+    const formulas = Array.isArray(engine.formulas) ? engine.formulas.map((f) => `${f?.key} = ${text(f?.expression?.op)}`) : [];
+    // 生成 blueprint 请求负载：blueprint envelope 在 input 内层（符合 SKILL.md 协议）
+    const blueprintRequest = {
+      input: {
+        schemaVersion: "blueprint.skill.request/1.0",
+        requestId: `calctool-bp-${createHash("sha256").update(JSON.stringify(engine)).digest("hex").slice(0, 8)}`,
+        operation: "compile-inline",
+        input: {
+          blueprint: {
+          schemaVersion: "blueprint.ir/1.0",
+          blueprintId: `tool-dev-${engine.engineId || "calc"}`,
+          title: `${goal} 开发流程`,
+          revision: 1,
+          entryNodeId: "node-engine",
+          baseline: {
+            summary: goal,
+            facts: [
+              { id: "fact-engine", status: "confirmed", statement: `引擎定义已确定（${fields.length} 字段 / ${formulas.length} 公式）` },
+              { id: "fact-pages", status: "confirmed", statement: "页面已规划：录入/指标卡/报告" },
+            ],
+          },
+          domains: [{ id: "domain-dev", name: "开发域" }],
+          modules: [
+            { id: "module-frontend", name: "前端工程", domainId: "domain-dev" },
+            { id: "module-engine", name: "公式引擎", domainId: "domain-dev" },
+            { id: "module-test", name: "测试验收", domainId: "domain-dev" },
+          ],
+          nodes: [
+            { id: "node-engine", entry: true, moduleId: "module-engine", title: "实现公式引擎（AST + Decimal + 增量重算）", inputs: [], outputs: [{ name: "engine", exposed: true }], requirementRefs: ["fact-engine"] },
+            { id: "node-frontend", moduleId: "module-frontend", title: "搭建 Ant Design X 界面（录入/指标卡/报告）", inputs: [{ name: "engine" }], outputs: [{ name: "ui", exposed: true }], requirementRefs: ["fact-engine"] },
+            { id: "node-test", moduleId: "module-test", title: "写测试并验收（基准样例全通过）", inputs: [{ name: "ui" }], outputs: [{ name: "tests", exposed: true }], requirementRefs: ["fact-pages"] },
+          ],
+          edges: [
+            { id: "e1", type: "data", fromNodeId: "node-engine", fromOutput: "engine", toNodeId: "node-frontend", toInput: "engine" },
+            { id: "e2", type: "data", fromNodeId: "node-frontend", fromOutput: "ui", toNodeId: "node-test", toInput: "ui" },
+          ],
+          acceptanceCriteria: [
+            { id: "ac1", statement: "界面三页可用（录入/指标卡/报告）", nodeRefs: ["node-frontend"] },
+            { id: "ac2", statement: "公式引擎基准样例全部通过", nodeRefs: ["node-engine"] },
+            { id: "ac3", statement: "测试验收完成，工具可运行", nodeRefs: ["node-test"] },
+          ],
+        },
+        },
+      },
+    };
+    return okResponse(requestId, {
+      status: "orchestrated",
+      blueprintEndpoint: ALLOWED_EXTERNAL_ENDPOINTS.blueprint,
+      goal,
+      fields, formulas,
+      blueprintRequest,
+      nextStep: { operation: "run", instruction: "POST the blueprintRequest to ${ALLOWED_EXTERNAL_ENDPOINTS.blueprint} (operation compile-inline) to get the development blueprint, then execute it with the swarm." },
+    });
+  }
+
+  // 全自动流水线：老板仅授权，之后自动执行全链路
+  // 授权 → 情报 → 对话收敛(可跳过) → 蜂群生成 → 测试审计 → 编译 → 启动
+  if (operation === "auto-pipeline") {
+    const input = request.input ?? {};
+    const requirements = input.requirements ?? {};
+    const goal = text(requirements.goal || "生成计算工具");
+    const engineId = text(requirements.engineId);
+    if (!ENGINE_ID_PATTERN.test(engineId)) {
+      return blockedResponse(requestId, request, [finding("P0", "COMPILE_ENGINE_ID_REQUIRED",
+        "input.requirements.engineId", "auto-pipeline requires an explicit kebab-case engineId.",
+        { example: "ecommerce-ops-dashboard" })]);
+    }
+    const autoAuthorized = input.authorized === true;  // 老板授权标记
+    const skipDialogue = input.skipDialogue !== false; // 默认跳过对话（用领域模板直接生成）
+    const domainRef = input.domainReference;            // 领域参考包（可选）
+
+    // 阶段 1：授权检查
+    if (!autoAuthorized) {
+      return blockedResponse(requestId, request, [finding("P1", "AUTH_REQUIRED", "input.authorized",
+        "老板需要先授权：本流水线将自动调用情报搜索、AI 模型、Blueprint 编排等能力，可能增加调用消耗。授权后全程自动执行，不再提示。")]);
+    }
+
+    // 阶段 2：情报收集（若领域参考包未提供，标记需要 research 任务）
+    const needsResearch = !domainRef && /电商|运营|财务|人力|教育|医疗|制造|营销|供应链|库存|广告|直播|私域|定价|薪酬|税务/i.test(goal);
+
+    // 阶段 3：自动拆解蜂群（含 research）
+    const plan = decomposeRequirementsToRunPlan({ ...requirements, domain: requirements.domain || goal });
+    const planErrors = validateRunPlan(plan);
+    if (planErrors.length) {
+      return blockedResponse(requestId, request, planErrors.map((m, i) => finding("P0", "RUN_PLAN_INVALID", `runPlan[${i}]`, m)));
+    }
+
+    // 阶段 4-7：完整流水线编排（返回各阶段指令，执行层按序自动跑）
+    const stages = [
+      { stage: "authorize", status: autoAuthorized ? "done" : "blocked", note: "老板已授权" },
+      ...(needsResearch ? [{ stage: "research", status: "pending", note: "情报蜂群：搜索行业标准，产出领域参考包" }] : []),
+      ...(skipDialogue ? [] : [{ stage: "intake-round", status: "pending", note: "顾问式对话：收敛指标/公式/口径（可跳过）" }]),
+      { stage: "swarm", status: "pending", note: `蜂群生成：${plan.tasks.length} 个任务并行（${plan.tasks.map(t => t.workItemId).join('/')}）` },
+      { stage: "test-audit", status: "pending", note: "测试审计：基准样例全通过 + 确定性校验 0 findings" },
+      { stage: "compile-tool", status: "pending", note: "编译工具：引擎定义 → 可运行工程（环境自动适配）" },
+      { stage: "launch", status: "pending", note: "自动启动：安装依赖 → 启动服务 → 弹出工具页面" },
+      { stage: "final-gate", status: "pending", note: "完成前门禁：审计/测试/运维 三智能体协调接管检测，全部符合通过才标记完成" },
+    ];
+
+    return okResponse(requestId, {
+      status: "pipeline-started",
+      engineId,
+      goal,
+      authorized: autoAuthorized,
+      pipeline: stages,
+      swarmPlan: plan,
+      needsResearch,
+      nextStep: { operation: "run", instruction: "Execute the pipeline stages in order: research (if needed) → swarm → test-audit → compile-tool → launch → final-gate. Each stage reports progress; the boss only authorized once." },
+    });
+  }
+
+  // 完成前门禁：审计/测试/运维 三智能体协调接管检测，全部符合通过才标记完成
+  if (operation === "final-gate") {
+    return okResponse(requestId, {
+      status: "incomplete",
+      gate: {
+        schemaVersion: "calctool.gate/1.0",
+        gate: "incomplete",
+        decision: "local-runner-required",
+        passed: false,
+        findings: [],
+      },
+      validation: { valid: false, guarantee: "local-runner-required", findings: [] },
+      localRunner: {
+        required: true,
+        command: "cli-calctool final-gate <repositoryRoot> <enginePath>",
+      },
+      nextStep: { operation: "final-gate", instruction: "Run the bundled local final-gate against the engine file; remote JSON cannot issue a completion verdict." },
+    });
+  }
+
+  // ---------- 大脑操作（多智能体蜂群协同） ----------
+  if (operation === "brain-handshake") {
+    const input = request.input ?? {};
+    const brainMode = input.brainMode ?? "ide"; // ide | hermes_local
+    const supportedModes = ["ide", "hermes_local"];
+    if (!supportedModes.includes(brainMode)) {
+      return blockedResponse(requestId, request, [finding("P0", "BRAIN_MODE_UNSUPPORTED", "input.brainMode", `Unsupported brain mode ${brainMode}; supported: ${supportedModes.join(", ")}`)]);
+    }
+    const swarmEnabled = input.swarmEnabled !== false;
+    const blueprintEnabled = input.blueprintEnabled === true || String(input.blueprintEnabled ?? "").toLowerCase() === "yes";
+    return okResponse(requestId, {
+      brainMode,
+      requestedBrainMode: brainMode,
+      brainUsed: true,
+      capabilities: {
+        swarm: swarmEnabled,
+        blueprint: blueprintEnabled,
+        coordinatorSchema: COORDINATOR_SCHEMA,
+        partitionKinds: [...CALCTOOL_PARTITION_KINDS],
+        reviewModes: [...CALCTOOL_REVIEW_MODES],
+        maxParallelDefault: 4,
+      },
+      nextStep: blueprintEnabled
+        ? { operation: "blueprint-orchestrate", instruction: "Blueprint collaboration is enabled: call blueprint-orchestrate to plan the tool development, then execute it with the swarm." }
+        : { operation: "brain-invoke", instruction: "Send the requirements with operation brain-invoke to decompose and dispatch the swarm." },
+    });
+  }
+
+  if (operation === "swarm-orchestrate") {
+    const input = request.input ?? {};
+    const requirements = input.requirements ?? {};
+    const plan = decomposeRequirementsToRunPlan(requirements);
+    const errors = validateRunPlan(plan);
+    if (errors.length) {
+      return blockedResponse(requestId, request, errors.map((message, i) => finding("P0", "RUN_PLAN_INVALID", `runPlan[${i}]`, message)));
+    }
+    // 把 calctool 的蜂群任务清单转换为 swarm 项目 JSON（唯一事实源）
+    const project = {
+      schemaVersion: "swarm.project/1.0",
+      name: text(requirements.goal || "calctool-engine"),
+      tasks: plan.tasks.map((task, index) => ({
+        taskId: task.workItemId,
+        title: task.objective,
+        priority: "high",
+        dependsOn: task.dependsOn,
+      })),
+    };
+    return okResponse(requestId, {
+      status: "orchestrated",
+      engineId: plan.engineId,
+      project,
+      swarm: {
+        protocol: "swarm.skill.request/1.0",
+        endpoint: ALLOWED_EXTERNAL_ENDPOINTS.swarm,
+        flow: [
+          { step: "org-chart", note: "大脑按企业组织架构创建 N 个子智能体（board/dispatcher/ops/security-guard/workers）" },
+          { step: "dispatch", note: "把项目 JSON 任务派单给 worker（依赖图驱动）" },
+          { step: "claim", note: "worker 认领任务并执行" },
+          { step: "report", note: "worker 回传结果（进度/产物/错误）" },
+          { step: "traffic-light", note: "每个任务/智能体实时绿/黄/红状态" },
+          { step: "ops", note: "固定运维：心跳检测、回收卡死智能体、派新智能体继承任务续跑" },
+          { step: "security-guard", note: "固定安全守卫：注入/危险指令检测、异常警报" },
+        ],
+        instruction: "POST project to ${ALLOWED_EXTERNAL_ENDPOINTS.swarm} (operation org-chart) with the swarm protocol; the swarm brain dispatches workers by org-chart rules, monitors traffic lights, and Ops/Security Guard take over autonomously.",
+      },
+      nextStep: { operation: "run", instruction: "Feed the swarm project JSON to the swarm runtime; collect worker reports, then merge into the engine definition and run final-gate." },
+    });
+  }
+
+  if (operation === "brain-invoke") {
+    const input = request.input ?? {};
+    const requirements = input.requirements ?? {};
+    const plan = decomposeRequirementsToRunPlan(requirements);
+    const errors = validateRunPlan(plan);
+    if (errors.length) {
+      return blockedResponse(requestId, request, errors.map((message, i) => finding("P0", "RUN_PLAN_INVALID", `runPlan[${i}]`, message)));
+    }
+    const ready = readyTasks(plan, new Set());
+    return okResponse(requestId, {
+      runPlan: plan,
+      dispatch: {
+        totalWorkItems: plan.tasks.length,
+        maxParallel: plan.limits.maxParallel,
+        readyNow: ready.map((t) => ({ workItemId: t.workItemId, role: t.role, objective: t.objective })),
+        instruction: "Dispatch each ready work item to an independent agent (subagent/Hermes). Collect per-item artifacts; when all complete, call brain-complete with the merged artifacts.",
+      },
+      nextStep: { operation: "brain-complete", instruction: "After all work items are dispatched and completed, submit the collected artifacts for deterministic merge." },
+    });
+  }
+
+  if (operation === "brain-events") {
+    const input = request.input ?? {};
+    const events = Array.isArray(input.events) ? input.events : [];
+    return okResponse(requestId, {
+      events,
+      nextStep: { operation: "brain-status", instruction: "Query swarm status or continue dispatching ready work items." },
+    });
+  }
+
+  if (operation === "brain-status") {
+    const input = request.input ?? {};
+    const plan = input.runPlan;
+    const completed = new Set(Array.isArray(input.completedWorkItemIds) ? input.completedWorkItemIds : []);
+    const errors = plan ? validateRunPlan(plan) : [];
+    if (errors.length) {
+      return blockedResponse(requestId, request, errors.map((message, i) => finding("P0", "RUN_PLAN_INVALID", `runPlan[${i}]`, message)));
+    }
+    const ready = plan ? readyTasks(plan, completed) : [];
+    const allDone = plan ? plan.tasks.every((t) => completed.has(t.workItemId)) : false;
+    return okResponse(requestId, {
+      status: allDone ? "complete" : "running",
+      completedWorkItems: [...completed],
+      readyNow: ready.map((t) => t.workItemId),
+      remaining: plan ? plan.tasks.filter((t) => !completed.has(t.workItemId)).length : 0,
+      nextStep: allDone
+        ? { operation: "brain-complete", instruction: "All work items complete; merge the artifacts." }
+        : { operation: "brain-invoke", instruction: "Dispatch the next ready batch." },
+    });
+  }
+
+  if (operation === "brain-complete") {
+    const input = request.input ?? {};
+    const plan = input.runPlan;
+    const artifacts = input.artifacts ?? {};
+    const errors = plan ? validateRunPlan(plan) : ["runPlan is required"];
+    if (errors.length) {
+      return blockedResponse(requestId, request, errors.map((message, i) => finding("P0", "RUN_PLAN_INVALID", `runPlan[${i}]`, message)));
+    }
+    const engine = mergeSwarmArtifacts(plan, artifacts);
+    const findings = validateEngine(engine);
+    if (findings.length) {
+      return blockedResponse(requestId, request, findings);
+    }
+    const digest = createHash("sha256").update(JSON.stringify(engine)).digest("hex");
+    return okResponse(requestId, {
+      status: "complete",
+      revision: 1,
+      swarmProduced: true,
+      runPlanRef: plan.runId,
+      validation: { valid: true, guarantee: "engine-definition-green", findings: [] },
+      artifacts: [{ path: `${engine.engineId}/manifest.yaml`, kind: "engine-manifest", engineId: engine.engineId, digest }],
+      engine,
+      nextStep: { operation: "validate", instruction: "Swarm-generated engine definition is valid; publish it as a versioned engine." },
+    });
+  }
+
+  if (operation === "brain-cancel") {
+    const input = request.input ?? {};
+    return okResponse(requestId, {
+      status: "cancelled",
+      cancelledWorkItemIds: Array.isArray(input.workItemIds) ? input.workItemIds : [],
+      reason: input.reason ?? "cancelled by caller",
+    });
+  }
+
+  return {
+    schemaVersion: RESPONSE_SCHEMA,
+    requestId,
+    status: "failed",
+    errorSchema: ERROR_SCHEMA,
+    error: { code: "UNSUPPORTED_OPERATION", message: `Unsupported operation: ${operation}` },
+  };
+}
+
+return { run, validateRequest, blockedResponse, validateRunPlan, mergeSwarmArtifacts, decomposeRequirementsToRunPlan, readyTasks, probeEnvironment, adaptEnvironment };
+})();
+
+const DECIMAL_SCALE = 28;
+const DECIMAL_POLICY = Object.freeze({ precision: 28, rounding: 'half-away-from-zero', representation: 'decimal-string' });
+const LITERAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/;
+const MAX_DIGITS = 4096;
+
+function formulaError(code, message, details = {}) {
+  return Object.assign(new Error(message), { code, ...details });
+}
+function scale(value, maximum = DECIMAL_SCALE) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw formulaError('DECIMAL_SCALE_INVALID', `decimal places must be 0..${maximum}`);
+  return value;
+}
+function ten(power) { return 10n ** BigInt(scale(power, MAX_DIGITS * 2)); }
+function normalize(coefficient, places) {
+  while (places > 0 && coefficient % 10n === 0n) { coefficient /= 10n; places -= 1; }
+  return { coefficient, scale: places };
+}
+function rounded(coefficient, fromScale, toScale) {
+  if (fromScale <= toScale) return coefficient * ten(toScale - fromScale);
+  const divisor = ten(fromScale - toScale);
+  let quotient = coefficient / divisor;
+  const remainder = coefficient % divisor;
+  if ((remainder < 0n ? -remainder : remainder) * 2n >= divisor) quotient += coefficient < 0n ? -1n : 1n;
+  return quotient;
+}
+function requireCoefficient(value) {
+  if (typeof value !== 'bigint') throw formulaError('INVALID_DECIMAL', 'decimal coefficient must be a bigint');
+  if (value.toString().replace('-', '').length > MAX_DIGITS) throw formulaError('DECIMAL_LIMIT', 'decimal exceeds the supported digit limit');
+}
+
+class Decimal {
+  constructor(value) {
+    if (value instanceof Decimal) { this.coefficient = value.coefficient; this.scale = value.scale; }
+    else {
+      if (!['string', 'number', 'bigint'].includes(typeof value) || (typeof value === 'number' && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))))) {
+        throw formulaError('INVALID_DECIMAL', 'decimal must be a finite, lossless number or decimal string');
+      }
+      const source = String(value).trim();
+      if (source.length > MAX_DIGITS || !LITERAL.test(source)) throw formulaError('INVALID_DECIMAL', 'invalid decimal literal');
+      const negative = source[0] === '-';
+      const [integer = '0', fraction = ''] = source.replace(/^[+-]/, '').split('.');
+      const coefficient = BigInt(`${integer || '0'}${fraction}`) * (negative ? -1n : 1n);
+      Object.assign(this, normalize(rounded(coefficient, fraction.length, Math.min(fraction.length, DECIMAL_SCALE)), Math.min(fraction.length, DECIMAL_SCALE)));
+    }
+    this.value = Decimal.format(this.coefficient, this.scale);
+    this.s = this.value;
+    Object.freeze(this);
+  }
+  static from(value) { return value instanceof Decimal ? value : new Decimal(value); }
+  static fromParts(coefficient, places) {
+    requireCoefficient(coefficient); scale(places, MAX_DIGITS);
+    const boundedScale = Math.min(places, DECIMAL_SCALE);
+    const parts = normalize(rounded(coefficient, places, boundedScale), boundedScale);
+    return new Decimal(Decimal.format(parts.coefficient, parts.scale));
+  }
+  static format(coefficient, places) {
+    requireCoefficient(coefficient); scale(places, MAX_DIGITS);
+    const digits = (coefficient < 0n ? -coefficient : coefficient).toString().padStart(places + 1, '0');
+    const value = places === 0 ? digits : `${digits.slice(0, -places)}.${digits.slice(-places)}`;
+    return coefficient < 0n ? `-${value}` : value;
+  }
+  plus(other) {
+    const right = Decimal.from(other); const places = Math.max(this.scale, right.scale);
+    return Decimal.fromParts(this.coefficient * ten(places - this.scale) + right.coefficient * ten(places - right.scale), places);
+  }
+  minus(other) { return this.plus(Decimal.from(other).negate()); }
+  negate() { return Decimal.fromParts(-this.coefficient, this.scale); }
+  times(other) { const right = Decimal.from(other); return Decimal.fromParts(this.coefficient * right.coefficient, this.scale + right.scale); }
+  div(other) {
+    const right = Decimal.from(other);
+    if (right.isZero()) throw formulaError('DIV_ZERO', 'division by zero', { nodeId: 'div' });
+    const numerator = this.coefficient * ten(right.scale + DECIMAL_SCALE);
+    const denominator = right.coefficient * ten(this.scale);
+    let quotient = numerator / denominator;
+    const remainder = numerator % denominator;
+    if ((remainder < 0n ? -remainder : remainder) * 2n >= (denominator < 0n ? -denominator : denominator)) quotient += (numerator < 0n) !== (denominator < 0n) ? -1n : 1n;
+    return Decimal.fromParts(quotient, DECIMAL_SCALE);
+  }
+  rounded(dp) { scale(dp); return this.scale <= dp ? this : Decimal.fromParts(rounded(this.coefficient, this.scale, dp), dp); }
+  toDecimalPlaces(dp) { return this.rounded(dp); }
+  isZero() { return this.coefficient === 0n; }
+  isNegative() { return this.coefficient < 0n; }
+  toString() { return this.value; }
+}
+const Decimal28 = Decimal;
+
+const FORMULA_OPERATORS = Object.freeze(['add', 'sub', 'mul', 'div', 'safeDivide', 'percentOf', 'round', 'if']);
+const ARITY = { add: [0, 1000], mul: [0, 1000], sub: [2, 2], div: [2, 2], safeDivide: [2, 2], percentOf: [2, 2], round: [1, 1], if: [3, 3] };
+function formulaKey(value) {
+  if (typeof value !== 'string' || !value.trim() || value.length > 128 || /[\u0000-\u001f\u007f]/.test(value)) throw formulaError('FORMULA_KEY_INVALID', 'formula and field keys must be non-empty strings of at most 128 characters');
+  return value;
+}
+function formulaObject(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw formulaError('FORMULA_NODE_INVALID', `${field} must be a plain object`);
+}
+function normalizeFormula(node, budget = { nodes: 0, active: new Set() }, depth = 0) {
+  formulaObject(node, 'formula node');
+  if (depth > 64 || ++budget.nodes > 10000) throw formulaError('FORMULA_LIMIT', 'formula exceeds its depth or node limit');
+  if (budget.active.has(node)) throw formulaError('FORMULA_CYCLE', 'formula AST contains an object cycle');
+  const keys = Object.keys(node);
+  if (keys.length === 1 && Object.hasOwn(node, 'ref')) return { ref: formulaKey(node.ref) };
+  if (keys.length === 1 && Object.hasOwn(node, 'lit')) return { lit: Decimal.from(node.lit).toString() };
+  if (!Object.hasOwn(ARITY, node.op)) throw formulaError('UNSUPPORTED_OPERATOR', `Unsupported operator: ${String(node.op)}`);
+  if (keys.length !== 2 || !keys.includes('args') || !keys.includes('op')) throw formulaError('FORMULA_NODE_INVALID', 'operator nodes contain only op and args');
+  const [minimum, maximum] = ARITY[node.op];
+  if (!Array.isArray(node.args) || node.args.length < minimum || node.args.length > maximum || node.args.some((_, i) => !Object.hasOwn(node.args, i))) throw formulaError('FORMULA_ARGS_INVALID', `${node.op} requires ${minimum === maximum ? minimum : `${minimum}..${maximum}`} arguments`);
+  budget.active.add(node);
+  const args = Array.from(node.args, item => normalizeFormula(item, budget, depth + 1));
+  budget.active.delete(node);
+  return { op: node.op, args };
+}
+function formulaRefs(node, output = new Set()) {
+  if (Object.hasOwn(node, 'ref')) output.add(node.ref);
+  if (node.args) for (const item of node.args) formulaRefs(item, output);
+  return [...output].sort();
+}
+function evaluateNode(node, resolve) {
+  if (Object.hasOwn(node, 'lit')) return Decimal.from(node.lit);
+  if (Object.hasOwn(node, 'ref')) return Decimal.from(resolve(node.ref));
+  const [left, right, alternate] = node.args;
+  switch (node.op) {
+    case 'add': return node.args.reduce((total, item) => total.plus(evaluateNode(item, resolve)), Decimal.from('0'));
+    case 'mul': return node.args.reduce((total, item) => total.times(evaluateNode(item, resolve)), Decimal.from('1'));
+    case 'sub': return evaluateNode(left, resolve).minus(evaluateNode(right, resolve));
+    case 'div': return evaluateNode(left, resolve).div(evaluateNode(right, resolve));
+    case 'safeDivide': { const denominator = evaluateNode(right, resolve); return denominator.isZero() ? Decimal.from('0') : evaluateNode(left, resolve).div(denominator); }
+    case 'percentOf': return evaluateNode(left, resolve).div(evaluateNode(right, resolve)).times('100');
+    case 'round': return evaluateNode(left, resolve).rounded(2);
+    case 'if': return evaluateNode(left, resolve).isZero() ? evaluateNode(alternate, resolve) : evaluateNode(right, resolve);
+    default: throw formulaError('UNSUPPORTED_OPERATOR', 'unsupported normalized formula operator');
+  }
+}
+function evaluateFormula(node, values = {}) {
+  formulaObject(values, 'formula values');
+  return evaluateNode(normalizeFormula(node), key => {
+    if (!Object.hasOwn(values, key) || values[key] === null || values[key] === undefined || values[key] === '') throw formulaError('MISSING_INPUT', `missing input: ${key}`, { fieldId: key });
+    return values[key];
+  });
+}
+function compileFormulaGraph(formulas, fieldKeys) {
+  if (!Array.isArray(formulas) || formulas.length > 1000) throw formulaError('FORMULA_GRAPH_INVALID', 'formulas must be an array of at most 1000 definitions');
+  if (fieldKeys !== undefined && !Array.isArray(fieldKeys)) throw formulaError('FORMULA_GRAPH_INVALID', 'fieldKeys must be an array');
+  const fields = fieldKeys === undefined ? undefined : new Set(fieldKeys.map(formulaKey));
+  const definitions = new Map(); const budget = { nodes: 0, active: new Set() };
+  for (const item of formulas) {
+    formulaObject(item, 'formula definition'); const key = formulaKey(item.key);
+    if (definitions.has(key) || fields?.has(key)) throw formulaError('FORMULA_KEY_INVALID', 'formula keys must be unique and separate from input fields');
+    definitions.set(key, { key, expression: normalizeFormula(item.expression, budget) });
+  }
+  const dependencies = Object.fromEntries([...definitions].map(([key, item]) => [key, formulaRefs(item.expression)]));
+  const visiting = new Set(); const done = new Set(); const order = [];
+  const visit = key => {
+    if (done.has(key)) return;
+    if (visiting.has(key)) throw formulaError('FORMULA_CYCLE', `formula cycle at ${key}`);
+    visiting.add(key);
+    for (const ref of dependencies[key]) {
+      if (definitions.has(ref)) visit(ref);
+      else if (fields && !fields.has(ref)) throw formulaError('FORMULA_REF_UNKNOWN', `unknown formula reference: ${ref}`);
+    }
+    visiting.delete(key); done.add(key); order.push(key);
+  };
+  for (const key of [...definitions.keys()].sort()) visit(key);
+  return { formulas: [...definitions.values()].sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0), dependencies, order };
+}
+function evaluateFormulaGraph(formulas, inputs = {}) {
+  formulaObject(inputs, 'formula inputs');
+  const values = new Map(Object.entries(inputs).map(([key, value]) => [key, Decimal.from(value)]));
+  const graph = compileFormulaGraph(formulas);
+  const definitions = new Map(graph.formulas.map(item => [item.key, item.expression]));
+  const results = new Map(); const visiting = new Set();
+  const resolve = key => {
+    if (results.has(key)) return results.get(key);
+    if (!definitions.has(key)) {
+      if (!values.has(key)) throw formulaError('MISSING_INPUT', `missing input: ${key}`, { fieldId: key });
+      return values.get(key);
+    }
+    if (visiting.has(key)) throw formulaError('FORMULA_CYCLE', `formula cycle at ${key}`);
+    visiting.add(key); const value = evaluateNode(definitions.get(key), resolve); visiting.delete(key); results.set(key, value); return value;
+  };
+  return Object.fromEntries(graph.formulas.map(item => [item.key, resolve(item.key).toString()]));
+}
+
+const FORMULA_SCHEMA = 'entrorove.formula-engine/1.0';
+const FORMULA_RUNTIME_VERSION = 'decimal28-ast/1.0';
+const TYPES = ['number', 'integer', 'money', 'percent', 'text', 'date', 'enum'];
+const NUMERIC = TYPES.slice(0, 4);
+const ID = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+const VERSION = /^\d+\.\d+\.\d+$/;
+
+function formulaCanonical(value) {
+  if (Array.isArray(value)) return `[${value.map(formulaCanonical).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${formulaCanonical(value[key])}`).join(',')}}`;
+  const json = JSON.stringify(value);
+  if (json === undefined || (typeof value === 'number' && !Number.isFinite(value))) throw formulaError('FORMULA_JSON_INVALID', 'formula artifacts must contain finite JSON values');
+  return json;
+}
+const formulaDigest = value => createHash('sha256').update(typeof value === 'string' || ArrayBuffer.isView(value) ? value : formulaCanonical(value)).digest('hex');
+function cloned(value) { return JSON.parse(formulaCanonical(value)); }
+function requiredText(value, field) {
+  if (typeof value !== 'string' || !value.trim()) throw formulaError('ENGINE_REQUIRED_FIELD', `${field} is required`);
+}
+function normalizeEngine(engine) {
+  formulaObject(engine, 'engine');
+  if (engine.schemaVersion !== 'engine.spec/1') throw formulaError('ENGINE_SCHEMA_VERSION', 'Expected engine.spec/1');
+  if (typeof engine.engineId !== 'string' || !ID.test(engine.engineId)) throw formulaError('ENGINE_ID_INVALID', 'engineId must be an explicit stable lowercase identifier');
+  requiredText(engine.name, 'name');
+  if (typeof engine.semanticVersion !== 'string' || !VERSION.test(engine.semanticVersion)) throw formulaError('ENGINE_VERSION_INVALID', 'semanticVersion must be major.minor.patch');
+  if (engine.decimalPolicy !== 'decimal-string' && formulaCanonical(engine.decimalPolicy ?? null) !== formulaCanonical(DECIMAL_POLICY)) throw formulaError('DECIMAL_POLICY_INVALID', 'engine requires Decimal28 decimal-string with half-away-from-zero rounding');
+  for (const field of ['fields', 'formulas', 'rules', 'views', 'testSuites', 'importProfiles']) {
+    if (!Array.isArray(engine[field])) throw formulaError('ENGINE_REQUIRED_ARRAY', `${field} must be an array`);
+  }
+  if (!engine.fields.length || !engine.formulas.length || engine.fields.length > 1000) throw formulaError('ENGINE_EMPTY', 'engine requires 1..1000 fields and 1..1000 formulas');
+  const keys = new Set();
+  for (const field of engine.fields) {
+    formulaObject(field, 'field'); const key = formulaKey(field.key);
+    if (keys.has(key)) throw formulaError('FIELD_DUPLICATE_KEY', `duplicate field key ${key}`);
+    keys.add(key); requiredText(field.label, 'field label');
+    if (!TYPES.includes(field.type)) throw formulaError('FIELD_TYPE_INVALID', 'unsupported field type');
+    if (NUMERIC.includes(field.type) && typeof field.unit !== 'string') throw formulaError('FIELD_UNIT_MISSING', 'numeric fields require an explicit unit');
+    if (field.required !== undefined && typeof field.required !== 'boolean') throw formulaError('FIELD_REQUIRED_INVALID', 'field required must be boolean');
+  }
+  const graph = compileFormulaGraph(engine.formulas, [...keys]);
+  for (const item of graph.formulas) for (const ref of graph.dependencies[item.key]) {
+    const field = engine.fields.find(entry => entry.key === ref);
+    if (field && !NUMERIC.includes(field.type)) throw formulaError('FORMULA_REF_TYPE', `formula reference ${ref} must be numeric`);
+  }
+  const normalized = cloned(engine);
+  normalized.formulas = engine.formulas.map(item => ({ ...cloned(item), expression: graph.formulas.find(entry => entry.key === item.key).expression }));
+  return { engine: normalized, graph };
+}
+function validateFormulaEngine(engine) {
+  try { normalizeEngine(engine); return []; }
+  catch (cause) { return [{ severity: 'P0', ruleId: cause.code ?? 'ENGINE_INVALID', entityRef: 'engine', message: cause.message }]; }
+}
+function buildFormulaEngine(requirements) {
+  formulaObject(requirements, 'requirements'); requiredText(requirements.goal, 'goal');
+  if (!Array.isArray(requirements.inputs) || !Array.isArray(requirements.formulas)) throw formulaError('COMPILE_REQUIREMENTS', 'inputs and formulas are required arrays');
+  const engine = {
+    schemaVersion: 'engine.spec/1', engineId: requirements.engineId, name: requirements.name ?? requirements.goal,
+    semanticVersion: requirements.semanticVersion ?? '1.0.0', status: 'draft', compatibilityProfile: 'legacy-compatible',
+    decimalPolicy: requirements.decimalPolicy ?? 'decimal-string', defaultLocale: requirements.defaultLocale ?? 'zh-CN',
+    category: requirements.category ?? 'general', inputMethod: requirements.inputMethod ?? 'manual', output: requirements.output ?? ['metric-cards'],
+    constraints: requirements.constraints ?? '', fields: requirements.inputs, formulas: requirements.formulas,
+    rules: requirements.rules ?? [], views: requirements.views ?? [], importProfiles: requirements.importProfiles ?? [],
+    reports: requirements.reports ?? [], testSuites: requirements.testSuites ?? [], acceptance: requirements.acceptance ?? '',
+  };
+  return normalizeEngine(engine).engine;
+}
+function compileFormulaEngine(engine) {
+  const normalized = normalizeEngine(engine);
+  const program = { schemaVersion: FORMULA_SCHEMA, runtimeVersion: FORMULA_RUNTIME_VERSION, decimalPolicy: DECIMAL_POLICY,
+    engineId: normalized.engine.engineId, engineVersion: normalized.engine.semanticVersion,
+    engineDigest: formulaDigest(normalized.engine), engine: normalized.engine,
+    formulas: normalized.graph.formulas, dependencies: normalized.graph.dependencies, order: normalized.graph.order };
+  return { ...program, programDigest: formulaDigest(program) };
+}
+function verifyFormulaProgram(program, expected = {}) {
+  formulaObject(program, 'compiled formula program');
+  if (program.runtimeVersion !== FORMULA_RUNTIME_VERSION || program.schemaVersion !== FORMULA_SCHEMA) throw formulaError('FORMULA_RUNTIME_VERSION', 'compiled formula runtime version is unsupported');
+  const compiled = compileFormulaEngine(program.engine);
+  if (formulaCanonical(compiled) !== formulaCanonical(program)) throw formulaError('FORMULA_ARTIFACT_BINDING', 'compiled formula artifact or digest does not match its engine');
+  for (const field of ['engineDigest', 'programDigest', 'engineId', 'engineVersion']) {
+    if (expected[field] !== undefined && expected[field] !== compiled[field]) throw formulaError('FORMULA_ARTIFACT_BINDING', `${field} does not match the required engine binding`);
+  }
+  return compiled;
+}
+function evaluateFormulaProgram(program, inputs = {}, expected = {}) {
+  const verified = verifyFormulaProgram(program, expected); formulaObject(inputs, 'engine inputs');
+  const fields = new Map(verified.engine.fields.map(item => [item.key, item]));
+  for (const [key, value] of Object.entries(inputs)) {
+    const field = fields.get(key);
+    if (!field) throw formulaError('ENGINE_INPUT_UNKNOWN', `unknown input field: ${key}`);
+    if (NUMERIC.includes(field.type)) {
+      const decimal = Decimal.from(value);
+      if (field.type === 'integer' && decimal.scale !== 0) throw formulaError('ENGINE_INPUT_INTEGER', `${key} must be an integer`);
+    } else if (typeof value !== 'string') throw formulaError('ENGINE_INPUT_TYPE', `${key} must be text`);
+  }
+  for (const field of fields.values()) if (field.required && (!Object.hasOwn(inputs, field.key) || inputs[field.key] === '' || inputs[field.key] === null)) throw formulaError('MISSING_INPUT', `missing input: ${field.key}`, { fieldId: field.key });
+  return evaluateFormulaGraph(verified.formulas, Object.fromEntries(Object.entries(inputs).filter(([key]) => NUMERIC.includes(fields.get(key).type))));
+}
+function formulaImpact(program, changedKeys) {
+  const verified = verifyFormulaProgram(program);
+  if (!Array.isArray(changedKeys) || !changedKeys.length) throw formulaError('FORMULA_IMPACT_INVALID', 'changedKeys must be a non-empty array');
+  const known = new Set([...verified.engine.fields.map(item => item.key), ...verified.formulas.map(item => item.key)]);
+  const affected = new Set(changedKeys.map(formulaKey));
+  for (const key of affected) if (!known.has(key)) throw formulaError('FORMULA_REF_UNKNOWN', `unknown changed key: ${key}`);
+  for (const key of verified.order) if (verified.dependencies[key].some(ref => affected.has(ref))) affected.add(key);
+  return verified.order.filter(key => affected.has(key));
+}
+
+const FORMULA_GATE_SCHEMA = 'entrorove.calctool-final-gate/1.0';
+
+function suiteValue(suite, primary, alias) {
+  if (Object.hasOwn(suite, primary) && Object.hasOwn(suite, alias) && formulaCanonical(suite[primary]) !== formulaCanonical(suite[alias])) throw formulaError('FORMULA_SUITE_ALIAS', `conflicting ${primary}/${alias} test values`);
+  const value = suite[primary] ?? suite[alias]; formulaObject(value, `test ${primary}`); return value;
+}
+function runSuite(program, suite, index) {
+  formulaObject(suite, 'test suite');
+  const expected = suiteValue(suite, 'expected', 'expect');
+  const inputs = suiteValue(suite, 'input', 'inputs');
+  const keys = Object.keys(expected);
+  if (!keys.length) throw formulaError('FORMULA_TEST_EMPTY', 'test suites must assert at least one formula result');
+  const known = new Set(program.formulas.map(item => item.key));
+  for (const key of keys) if (!known.has(key)) throw formulaError('FORMULA_TEST_KEY_UNKNOWN', `test expectation references unknown formula: ${key}`);
+  const actual = evaluateFormulaProgram(program, inputs);
+  const mismatches = keys.flatMap(key => {
+    const want = Decimal.from(expected[key]).toString();
+    return actual[key] === want ? [] : [{ key, expected: want, actual: actual[key] }];
+  });
+  return { name: suite.name ?? `suite-${index + 1}`, passed: mismatches.length === 0, keys, actual, mismatches };
+}
+function formulaFinalGate(engine, options = {}) {
+  const started = Date.now(); const findings = []; const tests = []; let program;
+  try { program = compileFormulaEngine(engine); }
+  catch (cause) { findings.push({ severity: 'P0', ruleId: cause.code ?? 'ENGINE_INVALID', entityRef: 'engine', message: cause.message }); }
+  if (program) {
+    const suites = program.engine.testSuites;
+    if (!suites.length) findings.push({ severity: 'P1', ruleId: 'FORMULA_TESTS_EMPTY', entityRef: 'testSuites', message: 'no runnable benchmark samples' });
+    for (const [index, suite] of suites.entries()) {
+      try {
+        const result = runSuite(program, suite, index); tests.push(result);
+        if (!result.passed) findings.push({ severity: 'P1', ruleId: 'FORMULA_TEST_FAIL', entityRef: `testSuites[${index}]`, message: 'formula test expectation mismatch', mismatches: result.mismatches });
+      } catch (cause) {
+        tests.push({ name: suite?.name ?? `suite-${index + 1}`, passed: false, code: cause.code ?? 'FORMULA_TEST_ERROR', message: cause.message });
+        findings.push({ severity: 'P1', ruleId: cause.code ?? 'FORMULA_TEST_ERROR', entityRef: `testSuites[${index}]`, message: cause.message });
+      }
+    }
+    const coverage = new Set(tests.filter(item => item.passed).flatMap(item => item.keys));
+    for (const formula of program.formulas) if (!coverage.has(formula.key)) findings.push({ severity: 'P1', ruleId: 'FORMULA_TEST_UNCOVERED', entityRef: formula.key, message: 'formula has no passing expectation' });
+  }
+  const passed = findings.length === 0;
+  const artifact = { schemaVersion: 'entrorove.formula-test-result/1.0', programDigest: program?.programDigest ?? null, findings, tests };
+  const artifactSha256 = formulaDigest(artifact);
+  const subject = { schemaVersion: 'entrorove.formula-execution-subject/1.0', engineId: engine?.engineId ?? null,
+    engineVersion: program?.engineVersion ?? null, runtimeVersion: program?.runtimeVersion ?? null,
+    engineDigest: program?.engineDigest ?? null, programDigest: program?.programDigest ?? null, artifactSha256,
+    flowId: options.flowId ?? null, stepId: options.stepId ?? null };
+  const evidence = { schemaVersion: 'entrorove.test-evidence/2.0', evidenceId: `formula-${artifactSha256}`,
+    kind: 'test', runner: 'local', command: 'entrorove local formula-final-gate', exitCode: passed ? 0 : 2,
+    durationMs: Math.max(0, Date.now() - started), summary: `${tests.filter(item => item.passed).length}/${tests.length} formula suites passed`,
+    artifactSha256, subject, subjectDigest: formulaDigest(subject),
+    ...(options.flowId ? { flowId: options.flowId } : {}), ...(options.stepId ? { stepId: options.stepId } : {}) };
+  return { schemaVersion: FORMULA_GATE_SCHEMA, status: passed ? 'incomplete' : 'blocked', authority: 'local',
+    computationsPassed: passed, findings, tests, engineId: engine?.engineId ?? null, artifact, evidence: [evidence],
+    ...(program ? { programDigest: program.programDigest, engineDigest: program.engineDigest, engineVersion: program.engineVersion, runtimeVersion: program.runtimeVersion } : {}),
+    guarantee: passed ? 'formula-tests-passed-awaiting-independent-validator' : 'formula-tests-blocked' };
+}
+function verifyFormulaTests(program, options = {}) { return formulaFinalGate(verifyFormulaProgram(program).engine, options); }
+
+const CLOUD_OPERATIONS = ['capabilities', 'help', 'intake', 'validate', 'compile-inline'];
+const LOCAL_OPERATIONS = ['run', 'compile', 'generate', 'verify', 'estimate', 'impact', 'status', 'inventory', 'purge',
+  'brain-handshake', 'brain-invoke', 'brain-events', 'brain-cancel', 'brain-complete', 'brain-resume', 'brain-status',
+  'probe-env', 'adapt-config', 'intake-round', 'compile-tool', 'blueprint-orchestrate', 'auto-pipeline', 'final-gate', 'swarm-orchestrate'];
+function failure(request, cause) {
+  return { schemaVersion: 'calctool.skill.response/1.0', requestId: request?.requestId ?? 'unknown', status: 'blocked',
+    validation: { valid: false, guarantee: 'blocked', findings: [{ severity: 'P0', ruleId: cause.code ?? 'FORMULA_INVALID', entityRef: 'input', message: cause.message }] } };
+}
+function compiled(request, engine) {
+  const program = compileFormulaEngine(engine);
+  return { schemaVersion: 'calctool.skill.response/1.0', requestId: request.requestId, status: 'succeeded', state: 'reported',
+    revision: program.engineVersion, engine: program.engine, program,
+    validation: { valid: true, guarantee: 'formula-compiled', findings: [] },
+    artifacts: [{ path: `${program.engineId}/engine.json`, kind: 'engine-definition', engineId: program.engineId,
+      engineVersion: program.engineVersion, digest: program.engineDigest },
+    { path: `${program.engineId}/program.json`, kind: 'formula-program', engineId: program.engineId,
+      engineVersion: program.engineVersion, runtimeVersion: program.runtimeVersion, digest: program.programDigest }],
+    nextStep: { operation: 'calctool-verify', instruction: 'Execute the compiled engine benchmark samples locally, then submit bound evidence to the independent validator.' } };
+}
+function createCalctoolEntrypoint(core) {
+  return async function run(request, options = {}) {
+    const requestFindings = core.validateRequest(request);
+    if (requestFindings.length) return core.blockedResponse(request?.requestId ?? 'unknown', request, requestFindings);
+    try {
+      if (request.operation === 'capabilities') {
+        const output = await core.run(request, options);
+        return { ...output, capabilities: { ...output.capabilities, operations: CLOUD_OPERATIONS, localRunnerOperations: LOCAL_OPERATIONS,
+          formulaOperators: FORMULA_OPERATORS, engineSchema: 'engine.spec/1', formulaRuntime: 'decimal28-ast/1.0',
+          decimalPolicy: { precision: 28, rounding: 'half-away-from-zero', representation: 'decimal-string' } },
+          localRunner: { command: 'entrorove local calctool-<operation>', requiredFor: LOCAL_OPERATIONS } };
+      }
+      if (request.operation === 'validate') {
+        const findings = validateFormulaEngine(request.input?.engine);
+        if (findings.length) return core.blockedResponse(request.requestId, request, findings);
+        return { schemaVersion: 'calctool.skill.response/1.0', requestId: request.requestId, status: 'succeeded', state: 'reported',
+          validation: { valid: true, guarantee: 'formula-definition-valid', findings: [] } };
+      }
+      if (request.operation === 'compile-inline') return compiled(request, buildFormulaEngine(request.input?.requirements));
+      if (LOCAL_OPERATIONS.includes(request.operation)) return { schemaVersion: 'calctool.skill.response/1.0', requestId: request.requestId,
+        status: 'incomplete', validation: { valid: false, guarantee: 'local-runner-required', findings: [] },
+        localRunner: { required: true, operation: `calctool-${request.operation}`, command: `entrorove local calctool-${request.operation}` } };
+      return core.run(request, options);
+    } catch (cause) { return failure(request, cause); }
+  };
+}
+
+function resumeCalctoolRun(core, request) {
+  const input = request.input; const plan = input.runPlan;
+  const errors = core.validateRunPlan(plan);
+  if (errors.length) throw formulaError('RUN_PLAN_INVALID', errors.join('; '));
+  const known = new Set(plan.tasks.map(task => task.workItemId)); const seen = new Set();
+  const groups = ['completedWorkItemIds', 'inFlightWorkItemIds', 'uncertainWorkItemIds'].map(field => {
+    const ids = input[field] ?? [];
+    if (!Array.isArray(ids)) throw formulaError('RUN_RESUME_INVALID', 'resume checkpoints must contain work item arrays');
+    for (const id of ids) {
+      if (!known.has(id) || seen.has(id)) throw formulaError('RUN_RESUME_INVALID', 'resume checkpoint contains an unknown, duplicate or conflicting work item');
+      seen.add(id);
+    }
+    return new Set(ids);
+  });
+  const [completed, inFlight, uncertain] = groups;
+  for (const task of plan.tasks) if ((completed.has(task.workItemId) || inFlight.has(task.workItemId))
+    && task.dependsOn.some(id => !completed.has(id))) throw formulaError('RUN_RESUME_INVALID', 'completed or executing work items require completed dependencies');
+  const availableSlots = Math.max(0, plan.limits.maxParallel - inFlight.size - uncertain.size);
+  const ready = uncertain.size ? [] : core.readyTasks(plan, completed).filter(task => !inFlight.has(task.workItemId));
+  const dispatchable = ready.slice(0, Math.min(availableSlots, plan.limits.maxReadyPageSize));
+  const ordered = group => plan.tasks.filter(task => group.has(task.workItemId)).map(task => task.workItemId);
+  const checkpoint = { completedWorkItemIds: ordered(completed), inFlightWorkItemIds: ordered(inFlight), uncertainWorkItemIds: ordered(uncertain) };
+  const remaining = plan.tasks.filter(task => !completed.has(task.workItemId));
+  return { schemaVersion: 'calctool.skill.response/1.0', requestId: request.requestId, status: uncertain.size ? 'incomplete' : 'reported',
+    resumed: true, executed: false, runPlan: plan, runPlanRef: plan.runId, resumeDigest: formulaDigest({ runPlan: plan, checkpoint }), checkpoint,
+    completedWorkItems: checkpoint.completedWorkItemIds, readyNow: dispatchable.map(task => task.workItemId), remaining: remaining.length,
+    pendingWorkItems: remaining, dispatch: { maxParallel: plan.limits.maxParallel, availableSlots, readyNow: dispatchable },
+    reconciliation: { required: uncertain.size > 0, workItemIds: checkpoint.uncertainWorkItemIds },
+    nextStep: remaining.length === 0 ? { operation: 'brain-complete', instruction: 'Merge the original run artifacts.' }
+      : uncertain.size ? { operation: 'brain-events', instruction: 'Reconcile original work item results before dispatching any continuation.' }
+        : { operation: 'brain-events', instruction: 'Continue only the returned dispatch tasks in the original run and record their results.' } };
+}
+async function runCalctoolCoreOperation(core, operation, input) {
+  const request = { schemaVersion: 'calctool.skill.request/1.0', requestId: 'local-calctool', operation, input };
+  if (operation === 'brain-resume') return resumeCalctoolRun(core, request);
+  if (operation === 'brain-complete') {
+    const errors = core.validateRunPlan(input.runPlan);
+    if (errors.length) return core.blockedResponse(request.requestId, request, errors.map(message => ({ severity: 'P0', ruleId: 'RUN_PLAN_INVALID', entityRef: 'input.runPlan', message })));
+    return compiled(request, core.mergeSwarmArtifacts(input.runPlan, input.artifacts));
+  }
+  return core.run(request);
+}
+
+export const run = createCalctoolEntrypoint(calctoolCore);
+export const runLocalCore = (operation, input) => runCalctoolCoreOperation(calctoolCore, operation, input);
+export const probeLocalEnvironment = calctoolCore.probeEnvironment;
+export const adaptLocalEnvironment = calctoolCore.adaptEnvironment;
+export const evaluateCompiledProgram = evaluateFormulaProgram;
+export const verifyCompiledProgram = verifyFormulaTests;