lingshu-solver 1.0.12 → 1.0.13

package/http-mcp-server.js

@@ -47,7 +47,7 @@ const solverCore = require('./solver-core');
 const { solve } = solverCore;
 
 const SERVER_NAME = 'lingshu-solver';
-const SERVER_VERSION = '1.0.12';
+const SERVER_VERSION = '1.0.13';
 const PORT = parseInt(process.env.PORT || '3000', 10);
 
 // ---- 护栏常量（防畸形/恶意输入耗尽资源，与 stdio 版一致）----

package/index.html

@@ -11192,7 +11192,63 @@ function _runTail(state) {
 
 // —— 可审计结构化溯源（切片A）：每个结果附带完整证据链元数据 ——
 // 设计目标：Agent / 上层系统拿到的不只是裸数字，而是"为什么是这个解"的可读证据链。
-var SOLVER_VERSION = "lingshu-solver/1.0.12-auditable";
+var SOLVER_VERSION = "lingshu-solver/1.0.13";
+
+// —— 确定性可复现契约（Certified Real-Root Computation 六属性之「确定性可复现」）——
+// 纯 JS 同步 SHA-256（零依赖，浏览器/Node 通用，免 Web Crypto 异步）。
+// reportId = 'ls1-' + sha256(输入+版本+预算)；相同输入跨运行/平台逐位重算一致 ⇒
+// 可复现性可被机器验证（Decision Physics DP-1），而非仅文字声称。
+function _utf8Bytes(str) {
+  var b = [];
+  for (var i = 0; i < str.length; i++) {
+    var c = str.charCodeAt(i);
+    if (c < 0x80) b.push(c);
+    else if (c < 0x800) { b.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f)); }
+    else if (c < 0xd800 || c >= 0xe000) { b.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f)); }
+    else { i++; var c2 = str.charCodeAt(i); var cp = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff); b.push(0xf0 | (cp >> 18), 0x80 | ((cp >> 12) & 0x3f), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f)); }
+  }
+  return b;
+}
+function _sha256(str) {
+  function rrot(x, n) { return (x >>> n) | (x << (32 - n)); }
+  var K = [0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2];
+  var H = [0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19];
+  var msg = _utf8Bytes(str);
+  var l = msg.length;
+  msg.push(0x80);
+  while (msg.length % 64 !== 56) msg.push(0x00);
+  var bitLen = l * 8;
+  for (var p = 0; p < 4; p++) msg.push(0x00);
+  msg.push((bitLen >>> 24) & 0xff, (bitLen >>> 16) & 0xff, (bitLen >>> 8) & 0xff, bitLen & 0xff);
+  for (var off = 0; off < msg.length; off += 64) {
+    var w = new Array(64);
+    for (var t = 0; t < 16; t++) { var j = off + t * 4; w[t] = (msg[j] << 24) | (msg[j+1] << 16) | (msg[j+2] << 8) | msg[j+3]; }
+    for (var t2 = 16; t2 < 64; t2++) { var s0 = rrot(w[t2-15],7) ^ rrot(w[t2-15],18) ^ (w[t2-15] >>> 3); var s1 = rrot(w[t2-2],17) ^ rrot(w[t2-2],19) ^ (w[t2-2] >>> 10); w[t2] = (w[t2-16] + s0 + w[t2-7] + s1) | 0; }
+    var a=H[0],b=H[1],c=H[2],d=H[3],e=H[4],f=H[5],g=H[6],h=H[7];
+    for (var t3 = 0; t3 < 64; t3++) {
+      var S1 = rrot(e,6) ^ rrot(e,11) ^ rrot(e,25); var ch = (e & f) ^ (~e & g); var t1 = (h + S1 + ch + K[t3] + w[t3]) | 0;
+      var S0 = rrot(a,2) ^ rrot(a,13) ^ rrot(a,22); var maj = (a & b) ^ (a & c) ^ (b & c); var t2v = (S0 + maj) | 0;
+      h=g; g=f; f=e; e=(d+t1)|0; d=c; c=b; b=a; a=(t1+t2v)|0;
+    }
+    H[0]=(H[0]+a)|0; H[1]=(H[1]+b)|0; H[2]=(H[2]+c)|0; H[3]=(H[3]+d)|0; H[4]=(H[4]+e)|0; H[5]=(H[5]+f)|0; H[6]=(H[6]+g)|0; H[7]=(H[7]+h)|0;
+  }
+  var hex = '';
+  for (var hi = 0; hi < 8; hi++) { var vv = H[hi]; for (var ss = 28; ss >= 0; ss -= 4) hex += ((vv >>> ss) & 0xf).toString(16); }
+  return hex;
+}
+function _computeReportId(state) {
+  try {
+    var seed = JSON.stringify([
+      state.equationStrs || [],
+      state.varNames || [],
+      state.decimals,
+      state._initD0 || null,
+      !!state.fastMode,
+      SOLVER_VERSION
+    ]);
+    return 'ls1-' + _sha256(seed);
+  } catch (e) { return null; }
+}
 
 // Movability 完整读取（切片B）：每变量携带 status + width，供 Agent 读懂"为何是这个解"
 function _movabilityFull(state) {
@@ -11216,6 +11272,7 @@ function _buildMeta(state) {
     var term = truncated ? 'resource_exhausted' : (state.fastMode ? 'fast_mode' : 'converged');
     return {
         solverVersion: SOLVER_VERSION,
+        reportId: _computeReportId(state),
         fastMode: !!state.fastMode,
         terminatedBy: term,
         truncated: truncated,
@@ -11734,6 +11791,46 @@ function _assignCompleteness(state) {
     };
 }
 
+// 认证实根计算层（Certified Real-Root Computation 六属性归一化输出）：
+// 把零散的 certified/certifiedRadius/tier/provenCount 收敛为一个机器可读契约。
+//  - 每个有限孤立解携带 cert:{ status, method, enclosure(闭世界 sound 误差包络), backwardError, krawczykRadius }
+//  - enclosure 仅对 Krawczyk 认证解给出 [v-r, v+r]；候选解 enclosure=null（绝不伪造误差界）
+//  - 全局 certification 汇总 proven/candidate/structural/emptyProof + 可复现方法，供 Agent 程序化判定保证边界
+function _assignCertBlock(state) {
+    if (!state || !state.result) return;
+    var sols = state.result.solutions || [];
+    for (var i = 0; i < sols.length; i++) {
+        var sol = sols[i];
+        var enclosure = null;
+        if (sol.certified === true && typeof sol.certifiedRadius === 'number') {
+            enclosure = (sol.values || []).map(function (v) {
+                var r = sol.certifiedRadius;
+                return [+(v - r).toFixed(12), +(v + r).toFixed(12)];
+            });
+        }
+        sol.cert = {
+            status: sol.tier || (sol.certified ? 'proven' : 'candidate'),
+            method: sol.source || (sol.certified ? 'krawczyk_newton' : 'numeric_newton'),
+            enclosure: enclosure,
+            backwardError: (typeof sol.residual === 'number') ? sol.residual : null,
+            krawczykRadius: (typeof sol.certifiedRadius === 'number') ? sol.certifiedRadius : null
+        };
+    }
+    var pc = state.result.provenCount || 0, cc = state.result.candidateCount || 0;
+    state.result.certification = {
+        proven: pc,
+        candidate: cc,
+        structural: state.result.structuralCount || 0,
+        emptyProof: state.result.emptyProof || null,
+        certifiedCoverage: (pc + cc) > 0 ? +(pc / (pc + cc)).toFixed(4) : null,
+        reproducibility: {
+            method: 'SHA-256(reportId)',
+            deterministic: true,
+            note: 'reportId 由「输入+版本+预算」逐位可重算；相同输入跨运行/平台产出相同 reportId 即证明可复现（Decision Physics DP-1）'
+        }
+    };
+}
+
 function _finish(state) {
     // 兜底保护（2026-08-21）：全局硬超时/异常路径可能只设 state.done 而未设 state.result，
     // 若直接返回 undefined/null，UI 会崩。此处构造诚实的截断结果，杜绝"求解器返回空"。
@@ -11824,6 +11921,7 @@ function _finish(state) {
     _assignTiers(state);
     _assignEmptiness(state);
     _assignCompleteness(state);
+    _assignCertBlock(state);   // 认证实根计算层：每解附加 cert 块 + 全局 certification 汇总
     return state.result;
 }
 

package/mcp-server.js

@@ -19,7 +19,7 @@ const path = require('path');
 const { solve } = require('./solver-core');
 
 const SERVER_NAME = 'lingshu-solver';
-const SERVER_VERSION = '1.0.12';
+const SERVER_VERSION = '1.0.13';
 
 // ---- 护栏常量（防畸形/恶意输入耗尽资源）----
 const MAX_TOTAL_CHARS = 100 * 1024;   // 单次请求方程文本总长上限 100KB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lingshu-solver",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "灵数求解器 · 确定性实数方程组求解 MCP 工具（≤6变量）：区间收缩 + Krawczyk 认证，离线零依赖零数据，诚实标记 truncated。本地 stdio 永久免费；另有常驻托管端点 https://hongchenlingjing.com/mcp（按次 ¥0.01/次，支持 honorPaid 免费放行）。",
   "homepage": "https://genesis-plan.github.io/lingshu-solver/",
   "repository": {