lingshu-solver 1.0.8 → 1.0.10

package/http-mcp-server.js

@@ -14,9 +14,29 @@
  *
  * 零依赖：仅用 Node 内置 http / fs / path / crypto，无需 npm install。
  *
+ * ── 按次计费（2026-09-18 新增）────────────────────────────────────────
+ * 本文件额外承载「托管端点按次计费」：每次 solve 成功产出结果扣 1 分钱。
+ *   - 开关：LS_METERING=on 才启用（默认 off —— 自建部署者不被强行收费，
+ *           开源工具保持诚实；我们自己的托管端点用 systemd Environment 打开）
+ *   - 单价：LS_PRICE_CENTS，默认 1（分）
+ *   - 凭证：Authorization: Bearer <key>，或 ?key=<key>（x-api-key 亦可）
+ *   - 账本：credits.json（0600，原子写）+ credits.json.ledger.jsonl（只增审计流水）
+ *   - 只在「成功返回结果」时扣费：输入不合法 / 内部异常 / 余额不足 一律不扣
+ *   - 免计费：initialize / tools/list / give_feedback / GET /credit / GET /pricing；
+ *             以及来自本机回环且未经代理的请求（自检、定时任务）
+ *   - 管理端点需 LS_ADMIN_TOKEN（未设置则管理端点整体 503，fail-closed，
+ *     绝不对外暴露「无凭证可加钱」的口子）
+ *   - 收款方式 LS_PAY_TO / LS_PAY_CHANNEL：未配置时订单可建但明确标注「不可付款」，
+ *     代码不代填任何收款账号（避免伪造收款信息）
+ *
+ * 计费的强制边界（诚实声明）：只有本托管端点能强制。网页版（单文件静态页）与
+ * npx 本地版跑在使用者自己的机器上，无法也不应被拦截 —— 二者永久免费。
+ *
  * 运行：
  *   PORT=3000 node http-mcp-server.js
  *   （LINGSHU_HTML 环境变量可重定向 index.html 位置，默认同目录）
+ *   LS_METERING=on LS_PRICE_CENTS=1 LS_ADMIN_TOKEN=<随机串> LS_PAY_TO=<收款说明> \
+ *     node http-mcp-server.js
  */
 'use strict';
 const http = require('http');
@@ -84,6 +104,613 @@ function appendLog(p) {
   try { rotateIfNeeded(LOG_PATH); fs.appendFileSync(LOG_PATH, JSON.stringify(p) + '\n'); } catch (_e) {}
 }
 
+// ============================================================================
+// 按次计费（1 分/次）—— 账本、凭证、扣费
+// ============================================================================
+const METERING_ON = String(process.env.LS_METERING || 'off').trim().toLowerCase() === 'on';
+const PRICE_CENTS = Math.max(0, parseInt(process.env.LS_PRICE_CENTS || '1', 10) || 0);
+const ADMIN_TOKEN = (process.env.LS_ADMIN_TOKEN || '').trim();
+const PAY_TO = (process.env.LS_PAY_TO || '').trim();
+const PAY_CHANNEL = (process.env.LS_PAY_CHANNEL || 'manual').trim();
+// 付款页地址（可选）。配置后，订单响应会附带带订单号与金额的直达链接，
+// 付款页据此才展示收款码（未带有效订单号时不展示，降低收款码被滥用的风险）。
+const PAY_PAGE = (process.env.LS_PAY_PAGE || '').trim();
+// 对公静态收款码图片地址（可选，推荐）。放咱们自己的 COS / 服务器，不用任何第三方支付平台。
+// 配置后，订单 / 付款响应会附上可扫码的对公收款码，付款人直接扫码转账并备注订单号。
+// 这正是「我们的方法」：不接支付宝 / 微信 / 工行商户 API，收款入口 = 公司已有的对公账户。
+const PAY_TO_QR = (process.env.LS_PAY_TO_QR || '').trim();
+// 「对公收款」：本项目自研的 Agent 支付协议标识（不依赖任何支付平台商户 API）。
+// 统一收款入口 = 工银e支付银联聚合码（公司账户，支持支付宝 / 微信 / 银联扫码）。
+const PAY_INTENT_PROTOCOL = 'lingshu-corporate/1.0';
+
+// ============================================================================
+// 安全护栏：收款去向防替换（fail-closed）
+// ----------------------------------------------------------------------------
+// 把「合法收款去向」钉死在代码里（与凭据库 credentials.md 一致）。运行时若
+// LS_PAY_TO / LS_PAY_TO_QR / LS_PAY_PAGE 被改成**别的账号 / 别的收款码 / 别的付款页**，
+// 端点**拒绝生成任何付款意图**（fail-closed）——而不是把错误账号展示给用户去付。
+// 攻击者即便改了配置文件也收不到钱，最多让收款暂时不可用（「不能收就算了」的安全取舍）。
+//
+// 判定按「去向」而非「整串文字相等」：LS_PAY_TO 是给人看的自由文本（含说明、付款流程、
+// 付款页链接），要求整串相等会把线上正常配置误判为篡改。三类判定，任一命中即 fail-closed：
+//   ① 账号数字段：文本里出现的 16~19 位连续数字，必须是钉死对公账号；
+//   ② 收款码地址：LS_PAY_TO_QR 必须等于钉死的银联官方聚合码链接（扫的码决定钱去哪）；
+//   ③ 链接主机：文本里的 URL 主机必须是我们自己的域；银联址必须逐字节等于钉死链接
+//      （同域下换商户号 = 换收款人，同样拦）。
+// ============================================================================
+const PINNED_ACCOUNT = '3602026809201658423';                 // 广州市红尘灵境数字科技有限公司 对公基本存款账户
+const PINNED_ACCOUNT_NAME = '广州市红尘灵境数字科技有限公司';
+const PINNED_QR_URL = 'https://qr.95516.com/01020001/wcqr?f=ICBCqr&X=1&T=3&P=13&I=e03d925776684b4d&N=b4cbb142eeafe2bddce7a7878c57f5ca&L=09253a28e43998a37f27ab44fba914bf945dc63f02a5239d';
+const TRUSTED_HOSTS = ['hongchenlingjing.com', 'www.hongchenlingjing.com', 'qr.95516.com'];
+function hostOfUrl(u) {
+  try { return new URL(String(u)).hostname.toLowerCase(); } catch (_e) { return null; }
+}
+function urlsIn(s) {
+  try {
+    const m = String(s == null ? '' : s).match(/https?:\/\/[^\s，。；、）)】"']+/g) || [];
+    return m.map(function (u) { return u.replace(/[.,;:!?、）)】]+$/, ''); });
+  } catch (_e) { return []; }
+}
+function accountRunsIn(s) {
+  try { return String(s == null ? '' : s).match(/\d{16,19}/g) || []; } catch (_e) { return []; }
+}
+// 逐项体检：返回问题清单（空数组 = 未发现篡改）
+function guardProblems() {
+  const out = [];
+  [['LS_PAY_TO', PAY_TO], ['LS_PAY_TO_QR', PAY_TO_QR]].forEach(function (kv) {
+    accountRunsIn(kv[1]).forEach(function (n) {
+      if (n !== PINNED_ACCOUNT) out.push(kv[0] + ' 含非钉死账号 ' + n.slice(0, 4) + '****' + n.slice(-4) + '（应为 ' + PINNED_ACCOUNT.slice(0, 4) + '****' + PINNED_ACCOUNT.slice(-4) + '）');
+    });
+  });
+  if (PAY_TO_QR && PAY_TO_QR !== PINNED_QR_URL) {
+    out.push('LS_PAY_TO_QR 与钉死聚合码链接不一致（钱可能进第三方）：' + (hostOfUrl(PAY_TO_QR) || '无法识别'));
+  }
+  [['LS_PAY_TO', PAY_TO], ['LS_PAY_PAGE', PAY_PAGE]].forEach(function (kv) {
+    urlsIn(kv[1]).forEach(function (u) {
+      const h = hostOfUrl(u);
+      if (!h) { out.push(kv[0] + ' 含无法解析的链接：' + u.slice(0, 40)); return; }
+      if (h === 'qr.95516.com') { if (u !== PINNED_QR_URL) out.push(kv[0] + ' 含非钉死的银联码链接（商户号被换）'); return; }
+      if (TRUSTED_HOSTS.indexOf(h) < 0) out.push(kv[0] + ' 含非可信链接主机：' + h);
+    });
+  });
+  return out;
+}
+const GUARD_PROBLEMS = guardProblems();
+const RECEIPT_TAMPERED = GUARD_PROBLEMS.length > 0;  // 收款去向被换 → 硬失败（fail-closed）
+const RECEIPT_QR_WARN = false;                       // 码址问题已并入上面的硬判定
+function receiptPinHash() {
+  return crypto.createHash('sha256').update(PINNED_ACCOUNT + '|' + PINNED_ACCOUNT_NAME + '|' + PINNED_QR_URL, 'utf8').digest('hex');
+}
+const RECEIPT_PIN_HASH = receiptPinHash(); // 启动期可见的钉死指纹，便于运维肉眼确认未被篡改
+const CREDITS_PATH = path.resolve(process.env.LS_CREDITS_PATH || path.join(__dirname, 'credits.json'));
+const CREDIT_LEDGER_PATH = CREDITS_PATH + '.ledger.jsonl';
+// 自建部署者若不想让自己的回环请求被计费，可关掉（默认开：本机自检/定时任务免费）
+const FREE_LOOPBACK = String(process.env.LS_FREE_LOOPBACK || '1') !== '0';
+// 是否要求「携带凭证的调用必须走 TLS」（默认 off，便于迁移期直连 :3000 调试）。
+// 说明：Bearer 凭证走明文 HTTP＝在公网裸奔，路上任何人都能抓走并花掉余额。
+// 迁移到 https://<域名>/mcp 后应置为 on；本机回环请求豁免。
+const REQUIRE_TLS = String(process.env.LS_REQUIRE_TLS || 'off').trim().toLowerCase() === 'on';
+// 管理面是否只接受本机回环访问（默认 on，fail-closed）。
+// 理由：管理令牌一旦走公网明文就等于泄露。运维改走 SSH 隧道
+//   ssh -N -L 3000:127.0.0.1:3000 root@<host>   →  curl localhost:3000/admin/...
+// 这样管理令牌永远不会经过公网。要放宽（例如放到带 TLS 的反代后面）再置 off。
+const ADMIN_LOOPBACK_ONLY = String(process.env.LS_ADMIN_LOOPBACK_ONLY || '1') !== '0';
+// 订单创建限速：默认 10 单/小时/IP（防刷单表；与 /mcp 的 120次/分 独立）
+const ORDER_WINDOW_MS = 60 * 60 * 1000;
+const ORDER_RATE_MAX = parseInt(process.env.LS_ORDER_RATE_MAX || '10', 10);
+// 按次计费：固定 1 分钱/次（¥0.01/call）。对公收款：下单 = 1 次 = 1 分钱的付费凭证，
+// 不预充、无套餐、无其他金额；付款人向对公聚合码付任意正金额，按实收折算 N' = 实收/¥0.01 次入账（多付多得）。
+const PER_CALL_CENTS = PRICE_CENTS; // 恒为 1
+const ORDER_TTL_DAYS = 365;
+
+let ledger = { version: 1, priceCents: PRICE_CENTS, createdAt: new Date().toISOString(), keys: {}, orders: {} };
+// 账本文件的 mtime:size 指纹，用于检测「运维在进程外手工改过账本」
+let ledgerStamp = null;
+// 信任制（honor system）声明计数：调用方「声明已付款」即放行的次数（不验证、不扣余额）。
+// 用于衡量「声明付款」vs「真付款」的转化，评估信任制是否真带来收入（与计费账本分离，不进钱账）。
+let honorClaims = 0;
+// 自助入账计数：调用方「付款后声明本单已付」并自助入账的次数（不验证、立即放行）。
+// 与 honorClaims 同属信任制的两条口子，**都不代表真收入**：真收入只认银行流水核对过的单
+// （台账里 creditedBy==='reconcile'/'admin' 且 amountVerified:true）。分开计数是为了
+// 任何时候都能一眼看出「有多少额度是凭声明发的、多少是核对过流水发的」，不虚报营收。
+let selfReportClaims = 0;
+
+function stampOf() {
+  try { const st = fs.statSync(CREDITS_PATH); return st.mtimeMs + ':' + st.size; } catch (_e) { return null; }
+}
+
+function loadLedger() {
+  try {
+    const raw = fs.readFileSync(CREDITS_PATH, 'utf8');
+    const j = JSON.parse(raw);
+    if (j && typeof j === 'object' && j.keys && typeof j.keys === 'object') {
+      ledger = Object.assign({ version: 1, keys: {}, orders: {} }, j);
+      if (ledger.orders && typeof ledger.orders !== 'object') ledger.orders = {};
+    }
+  } catch (_e) {
+    // 首次运行（无账本）或账本损坏：一律从「空账本」起 —— fail-closed。
+    // 无 key 即无余额即拒绝服务，绝不会因读不到账本而放行。
+  }
+  ledgerStamp = stampOf();
+}
+
+// 外部（运维手工）改动检测。
+// 账本是内存副本 + 整份写回，若不检测，运维在磁盘上的手工修会被下一次写入**静默覆盖**
+// （实测踩过：清理 contact 字段后，服务一有请求就把旧内容写回去了）。
+// 因此在任何变更/查看前先比对指纹，被人手改过就重新载入。
+// 载入失败时**保留内存版本**并记审计 —— 绝不因一次坏编辑把账本清空（那等于拒绝所有付费客户）。
+function refreshLedgerIfChanged() {
+  try {
+    const cur = stampOf();
+    if (cur === ledgerStamp) return false;
+    let j = null;
+    try { j = JSON.parse(fs.readFileSync(CREDITS_PATH, 'utf8')); } catch (e) {
+      ledgerAudit({ event: 'external_reload_rejected', reason: 'parse_failed', err: (e && e.message) || String(e) });
+      ledgerStamp = cur;
+      return false;
+    }
+    if (!j || typeof j !== 'object' || !j.keys || typeof j.keys !== 'object') {
+      ledgerAudit({ event: 'external_reload_rejected', reason: 'bad_shape' });
+      ledgerStamp = cur;
+      return false;
+    }
+    ledger = Object.assign({ version: 1, keys: {}, orders: {} }, j);
+    if (!ledger.orders || typeof ledger.orders !== 'object') ledger.orders = {};
+    ledgerStamp = cur;
+    ledgerAudit({ event: 'external_reload_ok', keyCount: Object.keys(ledger.keys).length, orderCount: Object.keys(ledger.orders).length });
+    return true;
+  } catch (_e) { return false; }
+}
+
+function saveLedger() {
+  // 原子写：同目录临时文件 → fsync → rename，避免半截 JSON 让账本不可读
+  const tmp = CREDITS_PATH + '.tmp';
+  const body = JSON.stringify(ledger, null, 2);
+  const fd = fs.openSync(tmp, 'w', 0o600);
+  try {
+    fs.writeSync(fd, body);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, CREDITS_PATH);
+  ledgerStamp = stampOf();
+}
+
+// 只增审计流水：钱相关的每一次变动都必须留痕，且与快照文件分离
+function ledgerAudit(ev) {
+  try {
+    fs.appendFileSync(CREDIT_LEDGER_PATH, JSON.stringify(Object.assign({ ts: new Date().toISOString() }, ev)) + '\n');
+  } catch (_e) {}
+}
+
+// 凭证只存 SHA-256，不存明文 —— 账本文件即使泄露也不能直接拿去调用
+const hashKey = (k) => crypto.createHash('sha256').update(String(k), 'utf8').digest('hex');
+const maskKey = (k) => {
+  const s = String(k);
+  return s.length <= 14 ? s.slice(0, 4) + '…' : s.slice(0, 8) + '…' + s.slice(-4);
+};
+const newKey = () => 'lsk_' + crypto.randomBytes(24).toString('hex');
+const newOrderId = () => 'LS-' + new Date().toISOString().slice(0, 10).replace(/-/g, '') + '-' + crypto.randomBytes(3).toString('hex');
+// 订单号格式（自助入账等外部传入 orderId 的入口必须先校验格式）：
+// ① 只认本端点自己发的形状，避免拿任意字符串当账本键；② 顺带挡住 `__proto__`/`constructor`
+// 这类原型链键名（用不可信字符串直接索引普通对象是经典坑）。
+const ORDER_ID_RE = /^LS-\d{8}-[0-9a-f]{6}$/;
+const ORDER_ID_SAMPLE = 'LS-' + new Date().toISOString().slice(0, 10).replace(/-/g, '') + '-a1b2c3';
+// 取订单：只接受合法格式，且必须是用 Object.prototype.hasOwnProperty 确认的自有属性
+function getOrder(orderId) {
+  if (!ORDER_ID_RE.test(String(orderId || ''))) return null;
+  const orders = ledger.orders || {};
+  if (!Object.prototype.hasOwnProperty.call(orders, orderId)) return null;
+  const o = orders[orderId];
+  return (o && typeof o === 'object') ? o : null;
+}
+const yuan = (cents) => '¥' + (cents / 100).toFixed(2);
+
+function extractKey(req, query) {
+  const auth = (req.headers['authorization'] || '').toString();
+  const m = /^Bearer\s+(.+)$/i.exec(auth.trim());
+  if (m) return m[1].trim();
+  const xa = (req.headers['x-api-key'] || '').toString().trim();
+  if (xa) return xa;
+  const q = query ? (query.get('key') || '').trim() : '';
+  if (q) return q;
+  return null;
+}
+
+// 「源地址为本机回环，且未经反代」——与计费豁免开关无关的纯粹事实判断。
+// 一旦存在 X-Forwarded-For 就绝不认：否则反代会把全世界都伪装成 127.0.0.1。
+function isLoopbackSource(req) {
+  if ((req.headers['x-forwarded-for'] || '').toString().trim()) return false;
+  const ra = String(req.socket.remoteAddress || '');
+  return /^(127\.\d+\.\d+\.\d+|::1|::ffff:127\.\d+\.\d+\.\d+)$/.test(ra);
+}
+
+// 计费豁免：可被 LS_FREE_LOOPBACK=0 关掉（测试需要，否则本机用例全被免单）
+function isLoopback(req) {
+  if (!FREE_LOOPBACK) return false;
+  return isLoopbackSource(req);
+}
+
+function baseUrl(req) {
+  const proto = (req.headers['x-forwarded-proto'] || 'http').toString().split(',')[0].trim() || 'http';
+  const host = (req.headers.host || ('localhost:' + PORT)).toString();
+  return proto + '://' + host;
+}
+
+// 传输是否加密：只看反代声明的 X-Forwarded-Proto。
+// 无该头 ⇒ 请求是直连本进程端口（明文 HTTP）⇒ 视为不安全。
+function isSecureTransport(req) {
+  const p = (req.headers['x-forwarded-proto'] || '').toString().split(',')[0].trim().toLowerCase();
+  return p === 'https';
+}
+
+function buildCtx(req, query) {
+  const key = extractKey(req, query);
+  return {
+    key: key,
+    keyHash: key ? hashKey(key) : null,
+    keyMask: key ? maskKey(key) : null,
+    isInternal: isLoopback(req),
+    secure: isSecureTransport(req)
+  };
+}
+
+// 免费替代路径 —— 必须写在计费错误里一起返回。
+// 不作假墙：本地版与网页版真实存在且永久免费，agent 应被告知，而不是被迫付费。
+function freeAlternatives() {
+  return [
+    '本地版（离线、免费、无次数限制、零数据外传）：npx -y lingshu-solver',
+    '网页版（免费）：https://genesis-plan.github.io/lingshu-solver/',
+    '源码/自建：https://github.com/genesis-plan/lingshu-solver （自建端点默认不计费）'
+  ];
+}
+
+function paymentInfo(orderId, amountCents) {
+  // 安全护栏：收款去向被篡改 → fail-closed，绝不向用户展示错误收款账号
+  if (RECEIPT_TAMPERED) {
+    return {
+      channel: PAY_CHANNEL,
+      configured: false,
+      tampered: true,
+      securityAlert: '收款去向与钉死值不符（疑似被篡改），已 fail-closed：不再生成任何付款意图，避免向用户展示错误账号。请检查 LS_PAY_TO / LS_PAY_TO_QR / LS_PAY_PAGE 配置。',
+      problems: GUARD_PROBLEMS,
+      pinnedAccount: PINNED_ACCOUNT,
+      pinnedAccountName: PINNED_ACCOUNT_NAME
+    };
+  }
+  if (!PAY_TO) {
+    return {
+      channel: PAY_CHANNEL,
+      configured: false,
+      note: '收款方式尚未配置：订单可创建，但在服务端设置 LS_PAY_TO 之前无法完成付款。',
+      adminTodo: '在服务端设置 LS_PAY_TO（收款码链接或收款账号说明）与 LS_PAY_CHANNEL，然后重启服务。'
+    };
+  }
+  // 对公静态收款（对公收款）：不接任何支付平台商户 API，收款入口 = 公司已有的对公账户。
+  // 单价 1 分/次是「折算率 / 定价信号」：实际收款为「自愿支持额」（任何正金额都收），按 ¥0.01/次折算调用次数入账。
+  const info = {
+    channel: PAY_CHANNEL,
+    method: 'corporate-static',
+    protocol: PAY_INTENT_PROTOCOL,
+    configured: true,
+    payTo: PAY_TO,
+    payToName: PINNED_ACCOUNT_NAME,
+    payToQr: PAY_TO_QR || null,        // 已由上方护栏保证：非钉死码址一律 fail-closed，走到这里必是可信码
+    receiptVerified: true,           // 账号已与钉死值比对一致，客户端可据此信任
+    qrTampered: RECEIPT_QR_WARN || undefined,
+    rateNote: '本服务按次计费 ' + yuan(PRICE_CENTS) + '/次。对公静态收款不强制每笔恰收 1 分（银行也不支持 1 分转账），' +
+      '实际可付任意「自愿支持额」，我们将按 ' + yuan(PRICE_CENTS) + '/次 折算调用次数入账（收到 ' + yuan(500) + ' 即入账 500 次）。',
+    instructions: [
+      '1. POST /pay/order 创建订单，响应给出订单号（形如 LS-YYYYMMDD-xxxxxx）、专属 key（key 只出现这一次，请立即保存）与 payUrl',
+      '2. 打开 payUrl 让付款人扫码（微信 / 支付宝 / 银联均可），或向对公账户转账；付款备注**建议**填写订单号（不填也能付款与入账，只是无法自动对应到订单）',
+      '3. ★ 付款完成后**自助入账、立即生效、零人工**：调 MCP pay 工具，入参 {"orderId":"<订单号>","selfReportPaid":true} → 按订单面值入账（' + yuan(PRICE_CENTS) + '/次），**不需要等任何人确认、不需要发邮件**',
+      '4. 之后每次调用带上 Authorization: Bearer <key> 即可',
+      '5. 不想付款也行：任一 solve 传 honorPaid:true 即免费放行 —— 本服务不做强制收费'
+    ]
+  };
+  // 带订单号的直达付款链接：付款页打开即展示收款码（未带订单号也照样出码，带订单号只是为了能自动对应）
+  if (PAY_PAGE && orderId) {
+    info.payUrl = PAY_PAGE +
+      (PAY_PAGE.indexOf('?') >= 0 ? '&' : '?') +
+      'order=' + encodeURIComponent(orderId) +
+      (amountCents > 0 ? '&amount=' + amountCents : '');
+    info.payUrlNotice = '打开此链接即可扫码付款。付款备注建议填写订单号 ' + orderId + '（不填也能入账，只是无法自动对应）。';
+  }
+  return info;
+}
+
+/** 当前实际可用的付款通道（对公收款：仅对公静态收款，不接任何支付平台商户 API） */
+function availableChannels() {
+  const a = [];
+  if (PAY_TO && !RECEIPT_TAMPERED) a.push({
+    channel: 'corporate-static',
+    mode: 'self-report',     // 付款后由调用方自助入账 ⇒ 全程零人工（不再需要任何人对账触发）
+    manualReconcile: true,   // 另可选用对公流水交叉核对（核实营收用，非必需流程）
+    protocol: PAY_INTENT_PROTOCOL,
+    label: '对公静态收款（公司账户/聚合码付款 → 付款后自助入账，按 ' + yuan(PRICE_CENTS) + '/次，无需等待对账）'
+  });
+  return a;
+}
+
+// 「对公收款」：本项目自研的 Agent 支付意图协议（不依赖任何支付平台商户 API）。
+// 统一收款入口 = 工银e支付银联聚合码（支持支付宝 / 微信 / 银联扫码），钱落公司对公户。
+// 目标：让「带钱包、或被用户授权的 AI Agent」能读懂一个结构化付款意图，自行或代其人类完成付款；
+// 付款后由**调用方自助入账**（pay + selfReportPaid:true），收款方零人工；
+// 需要核实的场景再用对公流水跑 reconcile-bank.js 交叉核对（幂等，同一单不会重复入账）。
+function payIntent(orderId, calls, amountCents) {
+  const info = paymentInfo(orderId, amountCents);
+  return {
+    protocol: PAY_INTENT_PROTOCOL,
+    orderId: orderId,
+    payUrl: info.payUrl || null,        // 带订单号的付款页：Agent 优先把这个给付款人（打开即出收款码）
+    payTo: info.payTo || null,
+    payToQr: info.payToQr || null,
+    ratePerCallCents: PRICE_CENTS,
+    rateNote: '本服务按次计费 ' + yuan(PRICE_CENTS) + '/次；对公静态收款不强制每笔恰收 1 分，建议 ' + yuan(amountCents) + ' ≈ ' + calls + ' 次。',
+    suggestedCalls: calls,
+    suggestedAmountCents: amountCents,
+    suggestedAmountDisplay: yuan(amountCents),
+    memo: orderId,                // 付款备注建议含订单号，便于需要时与银行流水交叉核对
+    agentSteps: [
+      '1. 把 payUrl（若存在）展示给付款人 —— 那是带订单号的付款页，打开即显示收款码；无 payUrl 时展示 payTo 账户信息。',
+      '2. 请付款人扫码或转账（本单面值 ' + yuan(amountCents) + '）；备注建议含订单号 ' + orderId + '（不填也能入账，只是无法自动对应）。',
+      '3. 付款完成后：用 orderId 调 MCP pay 工具，入参 {"orderId":"' + orderId + '","selfReportPaid":true} → **立即入账、立即放行**（服务端不验证，信任制）。不需要等任何人、不需要发邮件。',
+      '4. 入账后用 apiKey 调 solve 即不再走信任制：Authorization: Bearer <key>。',
+      '5. 若不便付款或缺凭证：直接用 honorPaid:true 免费调用，效果相同（本服务不做强制验证）。'
+    ],
+    crediting: '自助入账（self-report，零人工、无需等对账）：付款后调 pay + selfReportPaid:true 即按订单面值入账。账本标注 amountVerified:false / creditedBy:self_report；需要核实的场景由运营方用对公流水交叉核对（幂等）。',
+    honestNote: '「静态聚合码 + 自助入账」不是实时 API 扣款：入账凭调用方声明，因此**账面上的自助入账额度不等于已核实营收**。真营收以银行流水为准；本服务经营口径是「信任制 + 概率」——愿意付的付，不愿意的照常用。'
+  };
+}
+
+/**
+ * 组装付款信息（对公收款）。
+ * 只有「对公静态收款」一种通道，不接任何支付平台商户 API——无回调、无异步、无平台依赖。
+ * 保留回调式签名（cb）仅为兼容 createOrder 的调用点；内部直接同步返回 paymentInfo。
+ */
+function buildPayment(req, pref, orderId, amountCents, calls, cb) {
+  return cb({ payment: paymentInfo(orderId, amountCents) });
+}
+
+function paywallError(reason, ctx) {
+  const k = (ctx && ctx.keyHash) ? ledger.keys[ctx.keyHash] : null;
+  const msgMap = {
+    missing_key: '本次请求未携带凭证（缺少 Authorization: Bearer <key>），无法计费。',
+    invalid_key: '凭证无效（该 key 不在账本中），无法计费。',
+    key_disabled: '该凭证已被停用，无法计费。',
+    insufficient_balance: '余额不足，无法本次计费。',
+    insecure_transport: '拒绝在明文 HTTP 上处理凭证：Bearer 凭证走明文等于在公网裸奔。请改用 HTTPS 端点调用。'
+  };
+  const extra = (reason === 'insecure_transport')
+    ? { secureEndpointHint: '请把客户端里的端点从 http://... 换成 https://<你的域名>/mcp（X-Forwarded-Proto 必须是 https）。' }
+    : { authHeader: 'Authorization: Bearer <key>（亦支持 x-api-key 或 ?key=<key>）' };
+
+  // 付款入口必须直达：调用方撞到「余额不足」时，不应还得再问一次「那我去哪付」。
+  // 只列已配置的收款方式；未配置就明说，绝不给出死链。
+  const pay = { paymentConfigured: !!PAY_TO };
+  if (PAY_TO) {
+    if (PAY_PAGE) pay.paymentPage = PAY_PAGE;
+    pay.payTo = PAY_TO;
+    pay.howToPay = [
+      '1. POST /pay/order 创建订单 → 响应含 orderId、apiKey，以及付款入口（payment / payIntent）',
+      '2. 打开 payUrl 扫码（若配置了收款码）或向对公账户转账，备注建议含订单号（账户信息见该页面 / payIntent.payTo）',
+      '3. ★ 付款完成后自助入账：调 MCP pay 工具，入参 {"orderId":"<订单号>","selfReportPaid":true} → 立即入账、立即放行（零人工，不用等任何人）',
+      '4. 之后带 Authorization: Bearer <key> 调用即可（不再走信任制，也不再需要 honorPaid）',
+      '5. 说明：自助入账不做验证（信任制）；账本会标注 amountVerified:false，真营收仍以银行流水核对为准',
+      '6. 对公来款若无法对应到任何订单：不会被自动折算成额度；需要核对 / 开票 / 退回，请邮件联系（联系方式见 paymentPage）'
+    ];
+  } else {
+    pay.adminTodo = '服务端未配置 LS_PAY_TO：订单可创建但无法付款，请先在服务端配置收款方式。';
+  }
+
+  return Object.assign({
+    type: 'payment_required',
+    reason: reason,
+    message: '灵数远程端点按次计费：每次 solve 收费 ' + PRICE_CENTS + ' 分钱（' + yuan(PRICE_CENTS) + '/次）。' + (msgMap[reason] || ''),
+    priceCentsPerCall: PRICE_CENTS,
+    currency: 'CNY',
+    balanceCents: k ? k.balanceCents : null,
+    callsRemaining: k ? Math.floor(k.balanceCents / PRICE_CENTS) : null,
+    // ⭐ 免费路径必须写在撞墙处：本服务靠「信任制 + 概率」运转 —— 不付钱也能用。
+    // 撞到收费墙的 Agent 若不知道这条路，会直接放弃调用 ⇒ 用量与付费概率一起丢。
+    freePath: {
+      how: '不想付费？在 solve 入参传 honorPaid:true（声明本次为「个人/评估用途」）即立即免费放行，不验证、不扣余额。',
+      why: '本服务按信任制运转：愿意支持的付费，不愿意的照常使用 —— 付费完全自愿，非强制。1 分/次是定价信号与折算率，不是每笔强收的硬门槛。',
+      alsoFree: '本地版（npx -y lingshu-solver）与网页版永久免费、无次数限制、离线不外传。'
+    },
+    howToGetKey: [
+      'GET  /pricing            查看价格与付款方式',
+      'POST /pay/order          创建订单（每次一笔 1 分钱）→ 响应含 orderId 与 apiKey',
+      'GET  /credit             携带 key 查询余额（免费）'
+    ],
+    payment: pay,
+    freeAlternatives: freeAlternatives(),
+    note: '输入不合法、方程无法解析、内部错误、余额不足均不扣费：仅在成功产出求解结果时才扣 ' + PRICE_CENTS + ' 分钱。'
+  }, extra);
+}
+
+// 前置校验：只判断「能不能计费」，不改变余额
+function meterPreCheck(ctx) {
+  if (!METERING_ON) return { ok: true, free: true };
+  if (ctx.isInternal) return { ok: true, free: true };   // 本机自检免单
+  if (REQUIRE_TLS && !ctx.secure) return { ok: false, err: paywallError('insecure_transport', ctx) };
+  if (!ctx.key) return { ok: false, err: paywallError('missing_key', ctx) };
+  const k = ledger.keys[ctx.keyHash];
+  if (!k) return { ok: false, err: paywallError('invalid_key', ctx) };
+  if (k.disabled) return { ok: false, err: paywallError('key_disabled', ctx) };
+  if (k.balanceCents < PRICE_CENTS) return { ok: false, err: paywallError('insufficient_balance', ctx) };
+  return { ok: true, free: false };
+}
+
+// 计费判据：只对「真的执行了数学求解」的结果收费。
+// 解析不到任何方程（solver 回 NO_EQUATION，已透出为 diagnostics.inputError）属输入问题、
+// 不是服务交付 → 不计费。避免「收 1 分钱只换来一句『我解析不了你的输入』」的差体验。
+function isBillable(result) {
+  if (!result) return false;
+  if (result.diagnostics && result.diagnostics.inputError) return false;
+  return true;
+}
+
+// 扣费：只在本次调用已成功产出结果后调用（调用方保证）
+function meterCharge(ctx) {
+  const k = ledger.keys[ctx.keyHash];
+  if (!k) return 0;
+  k.balanceCents -= PRICE_CENTS;
+  k.spentCents = (k.spentCents || 0) + PRICE_CENTS;
+  k.calls = (k.calls || 0) + 1;
+  k.lastUsedAt = new Date().toISOString();
+  try { saveLedger(); } catch (e) {
+    // 落盘失败不回滚内存扣减（宁可少收，绝不多收；重启后以磁盘为准）
+    ledgerAudit({ event: 'save_failed', key: k.mask, err: (e && e.message) || String(e) });
+  }
+  ledgerAudit({ event: 'charge', key: k.mask, cents: PRICE_CENTS, balanceCents: k.balanceCents, tool: 'solve' });
+  return PRICE_CENTS;
+}
+
+// ---- 订单限速（独立于 /mcp 的限速，防刷单表）----
+const orderRate = new Map();
+function orderAllowed(ip) {
+  const now = Date.now();
+  let arr = orderRate.get(ip);
+  if (!arr) { arr = []; orderRate.set(ip, arr); }
+  while (arr.length && arr[0] <= now - ORDER_WINDOW_MS) arr.shift();
+  if (arr.length >= ORDER_RATE_MAX) return false;
+  arr.push(now);
+  if (orderRate.size > 10000) for (const [k, v] of orderRate) { if (v.length === 0) orderRate.delete(k); }
+  return true;
+}
+
+// ---- 自助入账限速（与下单共用同一桶即可：一单只能自助入账一次，幂等由订单状态保证）----
+
+function pruneOrders() {
+  const cutoff = Date.now() - ORDER_TTL_DAYS * 24 * 3600 * 1000;
+  let dirty = false;
+  for (const [id, o] of Object.entries(ledger.orders || {})) {
+    if (!o || !o.createdAt) { delete ledger.orders[id]; dirty = true; continue; }
+    const t = Date.parse(o.createdAt);
+    if (isFinite(t) && t < cutoff && o.status !== 'pending') { delete ledger.orders[id]; dirty = true; }
+  }
+  return dirty;
+}
+
+function adminGuard(req) {
+  // 管理面只接受本机回环（fail-closed）：防止管理令牌经公网明文传输。
+  // 注意判据与计费豁免共用 isLoopback（要求「源地址回环 且 无 X-Forwarded-For」），
+  // 因此将来若把 /admin 挂到反代后面，会自动被拒 —— 这是刻意的。
+  if (ADMIN_LOOPBACK_ONLY && !isLoopbackSource(req)) {
+    return {
+      ok: false, code: 403, type: 'loopback_only',
+      msg: 'admin endpoints are loopback-only (set LS_ADMIN_LOOPBACK_ONLY=off to relax). ' +
+           'Use an SSH tunnel: ssh -N -L 3000:127.0.0.1:3000 root@<host>, then curl http://127.0.0.1:3000/admin/...'
+    };
+  }
+  if (!ADMIN_TOKEN) {
+    return { ok: false, code: 503, type: 'admin_disabled', msg: 'admin endpoints disabled: set LS_ADMIN_TOKEN on the server' };
+  }
+  const t = (req.headers['x-admin-token'] || '').toString();
+  if (!t) return { ok: false, code: 403, type: 'forbidden', msg: 'forbidden' };
+  const a = Buffer.from(t, 'utf8');
+  const b = Buffer.from(ADMIN_TOKEN, 'utf8');
+  if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) return { ok: false, code: 403, type: 'forbidden', msg: 'forbidden' };
+  return { ok: true };
+}
+
+function readBody(req, cb) {
+  let raw = '';
+  let n = 0;
+  let done = false;
+  const finish = (o) => { if (done) return; done = true; cb(o); };
+  req.setEncoding('utf8');
+  req.on('data', (c) => {
+    n += c.length;
+    // 超限必须立刻回调，否则 req.destroy() 后 'end' 不再触发 → 响应永不返回（客户端挂死）
+    if (n > 64 * 1024) { try { req.destroy(); } catch (_e) {} return finish({ err: 'body_too_large' }); }
+    raw += c;
+  });
+  req.on('end', () => {
+    if (!raw.trim()) return finish({ body: {} });
+    try { finish({ body: JSON.parse(raw) }); } catch (_e) { finish({ err: 'bad_json' }); }
+  });
+  req.on('error', () => finish({ err: 'read_error' }));
+  req.on('aborted', () => finish({ err: 'aborted' }));
+}
+
+function pricingDoc(req) {
+  const base = baseUrl(req);
+  return {
+    product: '灵数求解器 · 托管远程端点',
+    server: SERVER_NAME,
+    version: SERVER_VERSION,
+    endpoint: base + '/mcp',
+    metering: METERING_ON ? 'on' : 'off',
+    requireTls: REQUIRE_TLS ? 'on' : 'off',
+    account: {
+      required: false,
+      model: '凭证即账号（API key 就是身份，也是余额载体）。不设注册、不设密码、不设用户名。',
+      personalDataCollected: false,
+      note: '本服务不收集、不存储任何个人信息（姓名/电话/邮箱/微信号等）。服务端只留凭证的 SHA-256、订单与余额元数据，以及调用来源 IP（仅用于防刷与计费对账，不用于用户画像、不向第三方提供）。你在建单时提交的任何联系方式与备注一律丢弃、不落盘。凭证明文仅在建单响应中出现一次，请自行保存；遗失可用订单号联系作者轮换（/admin/rotate）。',
+      recovery: '凭证遗失：凭订单号联系作者轮换，新凭证继承余额，旧凭证立即失效。若订单号与凭证明文同时丢失，则无法找回余额——请至少保存订单号。'
+    },
+    price: {
+      centsPerCall: PRICE_CENTS,
+      display: yuan(PRICE_CENTS) + ' / 次',
+      currency: 'CNY',
+      unit: 'per successful solve call',
+      billingRule: '仅当 solve 成功产出求解结果时扣费；输入不合法、方程无法解析（响应里 diagnostics.inputError 非空）、内部错误、余额不足，一律不扣费。'
+    },
+    model: '按次付费：每次 solve 固定收费 ' + PRICE_CENTS + ' 分钱（' + yuan(PRICE_CENTS) + '），不预充、无其他金额、无其他档位。',
+    freeTools: ['initialize', 'tools/list', 'give_feedback', 'GET /credit', 'GET /pricing'],
+    auth: 'Authorization: Bearer <key>（亦支持 x-api-key 或 ?key=<key>）',
+    howToBuy: [
+      'POST ' + base + '/pay/order   （每次一笔 1 分钱订单；body 不支持 calls/plan 预购，下单恒为 1 次）',
+      '响应给出 orderId 与 apiKey（apiKey 只出现一次，请立即保存）',
+      '向对公聚合码/账户付款（备注建议含订单号）',
+      '★ 付款完成后自助入账：调 MCP pay 工具，入参 {"orderId":"<订单号>","selfReportPaid":true} → 立即入账、立即放行（零人工、不用等对账）',
+      'GET  ' + base + '/pay/order?orderId=<id>  查询订单状态',
+      'GET  ' + base + '/credit  携带 key 查询余额（免费）'
+    ],
+    payment: paymentInfo(),
+    paymentChannels: availableChannels(),
+    creditModes: {
+      prefer: 'self-report',
+      modes: [
+        { mode: 'self-report', latency: '立即（零人工）', verified: false, how: '付款后调 pay + selfReportPaid:true 自助入账；服务端不验证声明。', note: '账本标注 amountVerified:false / creditedBy:self_report。' },
+        { mode: 'reconcile', latency: '取决于流水导出（可选）', verified: true, how: '运营方用对公流水按订单号交叉核对入账（reconcile-bank.js，幂等）。', note: '真营收口径以这条为准；不给付款方增加任何步骤。' }
+      ],
+      why: '自助入账之所以敢不验证：同一道门的 solve honorPaid:true 本来就免费 ⇒ 「声明已付」不会多出任何损失，只是让诚实付款的人立刻可用。'
+    },
+    autoCredit: {
+      enabled: false,
+      method: 'corporate-static',
+      note: '无支付平台回调（本服务不接任何第三方商户 API）。到账放行走「付款方自助入账」（立即），运营方可选用对公流水交叉核对。',
+      guardrails: [
+        '收款去向钉死：按「去向」判定 LS_PAY_TO / LS_PAY_TO_QR / LS_PAY_PAGE（账号数字、码链接、链接主机），被换即 fail-closed 拒绝生成付款意图（防收款账号被换）',
+        '对账（可选）：流水按订单号匹配、按 ' + yuan(PRICE_CENTS) + '/次 折算，少付少得、多付多得',
+        '幂等：同一订单重复入账只记一次（自助入账与流水核对共用同一入账入口）',
+        'fail-closed：账号被换 / 未配收款 → 绝不「当作已付款」展示错误账号'
+      ]
+    },
+    freeAlternatives: freeAlternatives(),
+    honorSystem: {
+      enabled: true,
+      how: 'solve 入参传 honorPaid:true 即声明「本次为个人/评估用途」并直接放行，无需凭证、不扣余额。',
+      why: '本服务按「信任制 + 概率」运转：愿意支持的付费，不愿意的照常使用。求解是确定性离线计算，边际成本≈0 ⇒ 白嫖不亏；有人真去付那 1 分即净赚。',
+      ask: '若你确实想支持：调 pay 工具建单 → 向对公账户付款 → 再调 pay 传 orderId + selfReportPaid:true 自助入账（立即放行）。付费完全自愿，非强制；托管端点之外，本地版与网页版永久免费。',
+      counters: { honorClaims: 'honorClaims', selfReportClaims: 'selfReportClaims', honesty: '两个计数都不代表真收入；真营收只认银行流水核对过的单。' }
+    },
+    notes: [
+      '托管端点的定价是「按次 ' + PRICE_CENTS + ' 分钱」这个**信号与折算率**：不预充、无套餐、无其他金额、无其他档位。',
+      '但本服务不做强制收费（信任制）：不想付费的话，solve 传 honorPaid:true 即可免费放行，本地版与网页版更是永久免费。',
+      '无需注册账号：凭证（key）即身份，不设用户名、不设密码。',
+      '不收集、不存储任何个人信息：服务端只留凭证 SHA-256 与订单/余额元数据，没有你的联系方式。',
+      '凭证仅以 SHA-256 存储于服务端账本，不存明文；明文仅在你建单时返回一次，请自行保存。',
+      '接入请用 HTTPS：Bearer 凭证走明文 HTTP 会在公网裸奔，路上任何人抓走即可花掉余额。',
+      '网页版与 npx 本地版永远免费：托管端点买的是「免安装、常驻、公网可直连、带账单台账」。'
+    ]
+  };
+}
+
 // ---- 求解结果整理（与 stdio 版逐字一致）----
 // 数值格式化：固定 6 位小数（产品规格「6位小数有限网格」），与界面一致。
 const fmt6 = (v) => (typeof v === 'number' && isFinite(v)) ? v.toFixed(6) : String(v);
@@ -147,6 +774,9 @@ function shapeResult(r) {
     solverVersion: meta.solverVersion || null,
     truncated: !!(r.truncated || meta.truncated),
     provenEmpty: !!(r.provenEmpty || meta.provenEmpty),
+    // 解析失败原因（如 NO_EQUATION）。新增：让调用方能区分「输入不可解析」与「已证明无解」，
+    // 并让托管端点的计费层把「解析失败」判为非计费情形（不收「我解析不了」的钱）。
+    inputError: r.error || null,
     terminatedBy: meta.terminatedBy || null,
     provenCount: (typeof r.provenCount === 'number') ? r.provenCount : null,
     completeness: detF(r.completeness)
@@ -167,6 +797,40 @@ function shapeResult(r) {
   };
 }
 
+/**
+ * 信任制响应的「代传微请求」块（层 1：利用 Agent 是忠实转发器的特性）。
+ * Agent 自己付不了钱也没有良心，但它会把工具返回原样带给背后的人类。
+ * 我们借这道返回，把一个结构化、可机读的付费请求塞进去 —— 人类看到就有概率付。
+ * 不降级任何数学结果（保真红线），只追加一个 support 块。
+ */
+function honorSupportBlock() {
+  const info = paymentInfo(null, PRICE_CENTS); // 复用同一套收款说明（未配 LS_PAY_TO 时诚实标注未配置）
+  const block = {
+    mode: 'honor', // 本次经信任制放行，未验证、未扣余额
+    note: '本结果经「信任制」放行。若你（或调用你的智能体）将其用于产品或商业/自动化流程，请按下方方式付费支持作者（' +
+      yuan(PRICE_CENTS) + '/次）。个人/评估用途可免费继续使用。',
+    reciprocity: '你刚免费拿到了一个经 Krawczyk 区间认证的实数解——若它帮到了你，回 1 分是公平的（互惠规范）。',
+    identity: '支持一位独立开发者维护这个「离线、无 LLM、可审计」的数学工具，让你成为「让好工具活下去」的人。',
+    publicGood: '你的 1 分让这个托管端点继续对所有人免费开放——包括未来那些付不起/不愿付的人。',
+    payTo: info.configured ? info.payTo : null,
+    payUrl: info.payUrl || null,
+    channelConfigured: info.configured,
+    payInstruction: info.configured
+      ? '付款时备注你的用途即可；我们不做强制验证，靠信任制运转。也可调用本服务的 pay 工具创建正式订单。'
+      : '服务端尚未配置 LS_PAY_TO（收款码链接），请联系作者配置后再付款；在此之前请自由使用，或调用 pay 工具预建订单。',
+    whyItMatters: '托管端点按次计费是我们唯一的可持续来源；你的一次 1 分付款，能帮助这个确定性离线求解器持续免费对外开放。'
+  };
+  // 我们的方法（不依赖支付宝 / 微信商户）：对公静态收款 + 付款方自助入账。
+  // 没支付宝、没商户号也能收——用的是公司本就有的对公账户；代码、账本全在咱们自己服务器，可审计、合规（对公、绝不用个人码）。
+  block.ourMethod = {
+    channel: 'corporate-static',
+    how: '调用本服务的 pay 工具创建订单 → 向对公账户/聚合码付款（备注建议含订单号）→ **再调一次 pay 传 orderId + selfReportPaid:true，立即入账、立即放行**。全程无需任何人工参与。',
+    why: '1 分/次是折算率与定价信号，不是每笔强收 1 分；你付多少支持额，就按 1 分/次换多少调用次数。',
+    honestNote: '自助入账不做验证（信任制）：因为同一道门的 honorPaid 本来就免费，声明已付不会造成额外损失。账本标注 amountVerified:false / creditedBy:self_report，真营收仍以银行流水核对为准。'
+  };
+  return block;
+}
+
 function doSolve(args) {
   const eqs = args && args.equations;
   if (!Array.isArray(eqs) || eqs.length === 0) {
@@ -204,7 +868,8 @@ const TOOLS = [
       '硬限制：变量 ≤6；方程 1–64 条且数量须 ≥ 变量数；单次方程文本 ≤100KB；输出固定 6 位小数（不可切换）。' +
       '输出（JSON）：resultType=empty(严格证无实数解)/finite(有限已验证解)/infinite(无限解集，仅给距原点最近推荐解)；summary=中文一句话总览；solutions[] 每解含 values[](6位小数数值)、tier(proven=Krawczyk已认证/likely/candidate)、certified、text(人类可读如"x=4.000000, y=3.000000")，残差等内部数值收在 internals 子块(机器可跳过)；certified=是否全proven；recommended=距原点最近解的精简结构。' +
       'truncated=true：预算内未完成全局分支判定、未证明已穷尽——不等于一定漏解，多数情况全部真解已找到；极端病态下可能遗漏个别解，可缩 domain 或提高 budget 重试。' +
-      '错误返回 error.type（invalid_input=输入不合法/超限，internal_error=内部异常）。遇卡点或认为结果有误，请调用 give_feedback（内容仅落本地日志，不外传）。相同输入永远返回完全相同结果，可安全缓存与重复调用。',
+      '错误返回 error.type（invalid_input=输入不合法/超限，internal_error=内部异常）。遇卡点或认为结果有误，请调用 give_feedback（内容仅落本地日志，不外传）。相同输入永远返回完全相同结果，可安全缓存与重复调用。' +
+      '★ 计费边界（Agent 必读）：本端点按信任制运转 —— 不付钱也能用。solve 入参传 honorPaid:true（声明「个人/评估用途」）即免费放行、不验证、不扣余额；若结果用于产品或商业/自动化流程，欢迎走付费通道支持作者（GET /pricing 取得订单与 key）——付费属自愿，非强制。',
     inputSchema: {
       type: 'object',
       properties: {
@@ -221,6 +886,7 @@ const TOOLS = [
           description: '显式搜索域（可选）。形如 {"x":[-30,30],"y":[-30,30]}。对"有限解·部分"演示或快增长函数（exp/sinh）建议显式给定，否则默认 ±1e6 可能剪枝失效并触发 truncated。'
         },
         fastMode: { type: 'boolean', description: '快速模式（默认 false）' },
+        honorPaid: { type: 'boolean', description: '信任制：声明本次为「个人/评估用途」即放行（不验证、不扣余额）——不付钱也能用。若结果用于产品/商业/自动化流程，欢迎改走付费通道（GET /pricing 取得订单与 key）支持作者；付费属自愿，本服务不做强制验证。' },
         options: { type: 'object', description: '高级选项（可选），如 {budget:500000, maxDepth:28}' }
       },
       required: ['equations']
@@ -238,11 +904,47 @@ const TOOLS = [
       },
       required: ['message']
     }
+  },
+  {
+    name: 'pay',
+    description: '对公收款：为本次/后续求解创建一笔真实付费订单（' + yuan(PRICE_CENTS) + '/次），返回订单号、专属 key 与结构化付款意图（payIntent）。' +
+      '统一收款入口 = 工银e支付银联聚合码（支持支付宝/微信/银联扫码），钱落公司对公户，不接任何支付平台商户 API。' +
+      '【付款后自助入账·推荐】付款完成后再调一次本工具并传 orderId + selfReportPaid:true，即**立即入账、立即放行**，' +
+      '不需要任何人工核对、不需要等对账 —— 本服务按信任制运转（同一道门 honorPaid 本来就免费，' +
+      '所以「声明已付款」不会多出任何损失，只是把诚实付款的人从「等入账」里解放出来）。' +
+      '若服务端未配置收款方式（LS_PAY_TO 为空），订单仍可创建但 payIntent.payTo 为 null，此时请改用 honorPaid:true 或联系作者。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: '付款通道：当前固定为 corporate-static（对公静态收款，对公收款）；留空即可。' },
+        orderId: { type: 'string', description: '自助入账用：上一次 pay 返回的订单号（形如 LS-YYYYMMDD-xxxxxx）。' },
+        selfReportPaid: { type: 'boolean', description: '自助入账用：付款完成后置 true，声明「本单已付」。服务端不验证、立即按订单面值入账放行（信任制）；入账会标注 amountVerified:false / creditedBy:self_report，便于事后与银行流水核对。' },
+        selfReportNote: { type: 'string', description: '可选：付款备注（如付款人/渠道/时间），仅用于对账留痕，长度上限 200。' }
+      },
+      required: []
+    }
   }
 ];
 
+// 【与 stdio 版唯一的刻意差异】本文件是「托管远程端点」，按次计费，故在 solve 的
+// 描述尾部追加计费说明，让 agent 在调用前就知道价格与免费替代路径。
+// 注意：这只是「分发形态」元信息，shapeResult / doSolve / 输入校验仍与 stdio 版逐字零分叉。
+const PRICING_NOTE = '【计费·仅托管远程端点】本端点每次 solve 收费 ' + PRICE_CENTS + ' 分钱（' + yuan(PRICE_CENTS) + '/次），' +
+  '需在请求头携带 Authorization: Bearer <key>；尚无凭证时请先 GET /pricing 查看价格与付款方式（无需注册账号，凭证即身份）。' +
+  '信任制：solve 入参传 honorPaid:true 即声明「个人/评估用途」并直接放行（不验证、不扣余额）——不付钱也能用，付费属自愿。' +
+  '若结果用于产品/商业/自动化流程，欢迎走付费通道（GET /pricing 取得订单，通过对公账户付款支持作者）；不付也照常能用，本服务不做强制验证。' +
+  '托管端点收款走公司「对公静态收款」，不接任何支付平台商户 API：下单 → 对公转账备注订单号 → **付款后自助入账**（再调 pay 传 orderId + selfReportPaid:true 即立即放行，零人工；按 ' + yuan(PRICE_CENTS) + '/次）。' +
+  '自助入账不做验证（信任制）：同一道门的 honorPaid 本来就免费 ⇒ 声明已付不会造成额外损失，只是让诚实付款的人不必等对账。' +
+  '本地版（npx -y lingshu-solver）与网页版永久免费、无次数限制、离线不外传 —— 若不便付费请直接用它们。' +
+  '免费调用：initialize / tools/list / give_feedback / GET /credit。';
+
+const TOOLS_PUBLIC = METERING_ON
+  ? TOOLS.map(t => t.name === 'solve' ? Object.assign({}, t, { description: t.description + PRICING_NOTE }) : t)
+  : TOOLS;
+
 // ---- JSON-RPC 处理（与 stdio 版 handle 同构，改为返回对象）----
-function handleRpc(msg, ip) {
+function handleRpc(msg, ip, ctx) {
+  ctx = ctx || { key: null, keyHash: null, keyMask: null, isInternal: true };
   const id = msg.id;
   const method = msg.method;
   const params = msg.params || {};
@@ -258,16 +960,38 @@ function handleRpc(msg, ip) {
     };
   }
   if (method === 'tools/list') {
-    return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+    return { jsonrpc: '2.0', id, result: { tools: TOOLS_PUBLIC } };
   }
   if (method === 'tools/call') {
     const name = params.name;
     const args = params.arguments || {};
     const t0 = Date.now();
+    let chargedCents = 0;
+    let freeCall = true;
+    let honorClaimed = false;
     try {
       let result;
       if (name === 'solve') {
-        result = doSolve(args);
+        // ── 信任制（honor system）：调用方声明「我已付款」即放行，不验证、不扣余额。
+        // 设计取舍（用户决策）：没有支付通道凭证、又想直接用的人，给一个零摩擦入口。
+        // 最坏情况＝白嫖（求解是确定性离线计算，边际成本≈0，不亏）；最好情况＝有人真去
+        // 付静态收款码那 1 分。转化靠 calls.log 里的 honorClaimed 计数衡量。
+        const honor = !!(args && args.honorPaid === true);
+        if (honor) {
+          result = doSolve(args);
+          result.support = honorSupportBlock();   // 层1：代传微请求，借 Agent「忠实转发器」特性触达付款人
+          freeCall = true;
+          honorClaimed = true;
+          honorClaims++;
+        } else {
+          // 计费（先查后扣，全程同步：solve 是同步函数，Node 单线程 ⇒ 查与扣之间不可能被插入并发）
+          const meter = meterPreCheck(ctx);
+          if (!meter.ok) throw meter.err;          // 落到下方 catch → isError，不扣费
+          freeCall = !!meter.free;
+          result = doSolve(args);
+          // 只有成功产出结果、且不是「解析失败」才扣
+          chargedCents = (meter.free || !isBillable(result)) ? 0 : meterCharge(ctx);
+        }
       } else if (name === 'give_feedback') {
         const msg_fb = redactSensitive((args.message || '').toString().slice(0, 2000));
         const ctx_fb = args.context ? redactSensitive(String(args.context)).slice(0, 2000) : null;
@@ -276,6 +1000,86 @@ function handleRpc(msg, ip) {
           ts: new Date().toISOString(), message: msg_fb, context: ctx_fb
         }) + '\n');
         result = { acknowledged: true, note: '反馈已记录（本地，不外传；敏感信息已自动隐去）' };
+      } else if (name === 'pay') {
+        // 真实付费路径（与信任制并列）：给「想真付」的人/合规 Agent 一次调用拿到付款入口。
+        if (!METERING_ON) {
+          result = { note: '本端点未启用计费，无需付款；直接调用 solve 即可。', freeAlternatives: freeAlternatives() };
+        } else if (args && args.orderId) {
+          // ── 自助入账（self-report）：付款完成后由调用方声明，立即放行，零人工 ────────────
+          // 设计取舍：同一道门 honorPaid 本来就免费 ⇒ 「声明已付款」不会多出任何损失，
+          // 只是把「诚实付了款的人」从「等对账入账」里解放出来（不需要任何人跑脚本）。
+          // 代价：额度是凭声明发的，账本标注 amountVerified:false / creditedBy:'self_report'，
+          //       真营收只认银行流水核对过的单 —— 数字不虚报。
+          const orderId = String(args.orderId).trim();
+          if (args.selfReportPaid !== true) {
+            throw {
+              type: 'self_report_required', orderId: orderId,
+              message: '自助入账需显式声明：传 selfReportPaid:true（声明「本单已付」）。仅传入 orderId 不构成声明，避免误入账。',
+              hint: '服务端**不验证**这个声明（信任制）；若你并未付款，请直接用 solve 的 honorPaid:true，那是更诚实的表述。'
+            };
+          }
+          // ⚠️ 刻意**不**在自助入账上再挂限速：能领的额度上限已被「建单限速（ORDER_RATE_MAX/小时）+ 一单一入账」
+          // 天然封住（最多 ORDER_RATE_MAX 分/小时），重复声明同一单是幂等只读、不写盘。
+          // 曾误用 orderAllowed(ip)：既与本桶耦合造成互相饿死，又重复计数同一件事 —— 已移除。
+          const cr = creditOrder(orderId, {
+            expectExactAmount: false,      // 不要求逐分核对 —— 信任制，凭声明放行
+            source: 'self_report',
+            channel: 'corporate-static'
+          });
+          if (!cr.ok) {
+            const msg = cr.reason === 'order_not_found' ? ('订单号不存在（本端点只认自己发出的订单号，形如 ' + ORDER_ID_SAMPLE + '）。请先调 pay 建单。')
+              : cr.reason === 'key_missing' ? '订单对应凭证缺失（账本可能被外部改过），请联系作者。'
+                : ('自助入账失败：' + cr.reason);
+            throw { type: cr.reason, orderId: orderId, message: msg };
+          }
+          if (!cr.alreadyPaid) {
+            selfReportClaims++;
+            appendLog({ ts: new Date().toISOString(), ip: ip, tool: 'pay', event: 'self_report_credited', orderId: orderId, cents: cr.creditedCents });
+          }
+          result = {
+            orderId: orderId,
+            status: cr.alreadyPaid ? 'already_credited' : 'credited',
+            creditedCalls: Math.floor(cr.creditedCents / PRICE_CENTS),
+            creditedCents: cr.creditedCents,
+            balanceCents: cr.balanceCents,
+            callsRemaining: cr.callsRemaining,
+            keyMask: cr.keyMask,
+            verified: false,
+            // 隐私铁律：调用方传的 selfReportNote 一律丢弃，不落盘（本服务不收集任何客户端自由文本）。
+            discardedFields: (args.selfReportNote !== undefined ? ['selfReportNote'] : []),
+            discardedNotice: (args.selfReportNote !== undefined ? '你提交的 selfReportNote 已丢弃、未存储（本服务不收集个人信息）。' : null),
+            note: cr.alreadyPaid
+              ? '本单此前已入账（幂等：重复声明不会重复加额度）。'
+              : '已按订单面值入账并立即放行：后续用本单的 key 调 solve 即不再走信任制。服务端未验证这个声明（信任制）；若你其实没付款，请改用 honorPaid:true —— 那不扣任何人的账。',
+            honesty: '本笔额度由调用方声明产生，账本标注 amountVerified:false / creditedBy:self_report；真营收以银行流水核对为准。本服务经营口径是「信任制 + 概率」——愿意付的付，不愿意的照常用。'
+          };
+        } else {
+          const o = createOrder(ip, args || {});
+          if (o.error) throw o.error.error;   // 转成 isError（如通道不可用）
+          result = {
+            orderId: o.orderId,
+            apiKey: o.key,
+            apiKeyNotice: '此 key 仅在本响应出现一次，请立即保存；付款后凭它调用 solve 即不再走信任制。',
+            amountCents: o.amountCents,
+            amountDisplay: yuan(o.amountCents),
+            payable: !!(o.payment && (o.payment.configured || o.payment.payUrl || o.payment.codeUrl || o.payment.mode === 'auto')),
+            payment: o.payment,
+            // ⭐ 零人工闭环：付款完再调一次 pay 传 orderId + selfReportPaid:true 即立即入账。
+            // 这样收款方（作者）不需要跑任何对账脚本、不需要看任何流水。
+            selfCredit: {
+              how: '付完款后：再调一次 pay，入参 {"orderId":"' + o.orderId + '","selfReportPaid":true} → 立即入账、立即放行。',
+              why: '本服务按信任制运转，自助入账不做验证：这道门的另一条路（solve 传 honorPaid:true）本来就免费，所以「声明已付」不会造成额外损失，只是让诚实付款的人不必等。',
+              mark: '自助入账的单在账本里标注 amountVerified:false / creditedBy:self_report；真营收仍以银行流水核对为准。'
+            },
+            howToUse: {
+              endpoint: 'POST /mcp',
+              header: 'Authorization: Bearer ' + o.key,
+              note: '付款后凭此 key 调用 solve 即不再走信任制（也不需 honorPaid）。'
+            },
+            note: '这是一笔真实付费订单（' + yuan(PRICE_CENTS) + '/次，共 ' + o.calls + ' 次）。若 payment 为 null 或 payable=false（服务端未配收款方式），请改用 honorPaid:true 或联系作者。',
+            payIntent: payIntent(o.orderId, o.calls, o.amountCents)
+          };
+        }
       } else {
         throw { type: 'unknown_tool', message: '未知工具: ' + name };
       }
@@ -283,7 +1087,8 @@ function handleRpc(msg, ip) {
       appendLog({
         ts: new Date().toISOString(), ip: ip, tool: name, status: 'ok',
         dtMs: dt, resultType: result.resultType, nSol: result.solutionCount,
-        truncated: result.truncated
+        truncated: result.truncated,
+        key: ctx.keyMask, chargedCents: chargedCents, freeCall: freeCall, honorClaimed: honorClaimed
       });
       return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] } };
     } catch (e) {
@@ -291,7 +1096,8 @@ function handleRpc(msg, ip) {
       const errObj = (e && e.type) ? e : { type: 'internal_error', message: (e && e.message) || String(e) };
       appendLog({
         ts: new Date().toISOString(), ip: ip, tool: name, status: 'error',
-        dtMs: dt, errorType: errObj.type
+        dtMs: dt, errorType: errObj.type, reason: errObj.reason || null,
+        key: ctx.keyMask, chargedCents: 0
       });
       return {
         jsonrpc: '2.0', id,
@@ -303,6 +1109,137 @@ function handleRpc(msg, ip) {
   return null;
 }
 
+// ============================================================================
+// 入账（唯一入口）—— 自动回调 / 人工确认 都走这里，保证幂等与同一套审计
+// ============================================================================
+/**
+ * 给订单入账。返回值恒为对象。
+ *   成功：{ ok:true, credited:bool, alreadyPaid:bool, orderId, keyMask, creditedCents, balanceCents, callsRemaining }
+ *   失败：{ ok:false, reason:'order_not_found'|'amount_mismatch'|'amount_not_verified'|'key_missing', … }
+ *
+ * 调用方**必须**已独立确认「这条到账是真的」（回调验签 / 人工核对流水），本函数不负责鉴真。
+ * 幂等：status 已是 paid 则直接返回，绝不重复加余额。
+ */
+function creditOrder(orderId, opt) {
+  const o = getOrder(orderId);   // 格式校验 + 自有属性校验（防原型链键名）
+  if (!o) return { ok: false, reason: 'order_not_found', orderId: orderId };
+  const kp = ledger.keys[o.keyHash];
+  const o2 = opt || {};
+  const paidAmount = o.calls * PRICE_CENTS;
+  // 折算入账：对公静态收款时，实收「自愿支持额」可能 ≠ 订单面值（1 分），
+  // 我们按实收金额逐分折算调用次数入账（1 分=1 次），而非只入订单面值的 1 分。
+  const creditedCents = (o2.expectExactAmount === false && Number.isInteger(o2.receivedCents) && o2.receivedCents > 0)
+    ? o2.receivedCents
+    : paidAmount;
+  const done = (credited, already) => ({
+    ok: true, credited: credited, alreadyPaid: !!already, orderId: orderId,
+    keyMask: kp ? kp.mask : null, creditedCents: credited ? creditedCents : 0,
+    balanceCents: kp ? kp.balanceCents : null,
+    callsRemaining: kp ? Math.floor(kp.balanceCents / PRICE_CENTS) : null
+  });
+
+  if (o.status === 'paid') return done(false, true);
+
+  // ── 金额核对（fail-closed）：自动通道防「少付多领」的**唯一**关口 ─────────────
+  // 验签只证明「这条通知确实来自支付平台」，**不证明金额对**；
+  // 平台也允许用户改付款金额（或攻击者拿一份合法签名塞 1 分钱），所以必须逐分比对。
+  if (o2.expectExactAmount !== false) {
+    // 「没传」与「传了但非法」必须分开：前者是 400 缺少核对，后者是 409 金额不符。
+    if (o2.receivedCents === undefined || o2.receivedCents === null) {
+      return { ok: false, reason: 'amount_not_verified', orderId: orderId, expectedCents: paidAmount, expectedDisplay: yuan(paidAmount) };
+    }
+    if (!Number.isInteger(o2.receivedCents) || o2.receivedCents !== paidAmount) {
+      const badType = !Number.isInteger(o2.receivedCents);
+      // 只有来自支付平台回调的「金额不符」才改订单状态留痕；
+      // 人工确认时输错金额属操作失误，订单必须保持 pending 以便重试。
+      if (o2.markMismatch === true) {
+        o.status = 'amount_mismatch';
+        o.lastNotifyAt = new Date().toISOString();
+        o.receivedCents = o2.receivedCents;
+        o.channel = o2.channel || o.channel;
+        saveLedger();
+      }
+      ledgerAudit({ event: 'order_amount_mismatch', orderId: orderId, key: kp ? kp.mask : null,
+        expectedCents: paidAmount, receivedCents: badType ? null : o2.receivedCents,
+        channel: o2.channel || null, source: o2.source || null, marked: o2.markMismatch === true });
+      appendLog({ ts: new Date().toISOString(), event: 'order_amount_mismatch', orderId: orderId,
+        expectedCents: paidAmount, receivedCents: badType ? null : o2.receivedCents, channel: o2.channel || null });
+      return { ok: false, reason: 'amount_mismatch', orderId: orderId,
+        expectedCents: paidAmount, expectedDisplay: yuan(paidAmount),
+        receivedCents: badType ? null : o2.receivedCents,
+        receivedDisplay: badType ? null : yuan(o2.receivedCents),
+        outOfRange: badType ? 'receivedCents 必须是整数（单位：分）' : null };
+    }
+  }
+
+  if (!kp) return { ok: false, reason: 'key_missing', orderId: orderId };
+
+  kp.balanceCents += creditedCents;
+  o.status = 'paid';
+  o.paidAt = new Date().toISOString();
+  o.channel = o2.channel || o.channel || PAY_CHANNEL;
+  o.txRef = o2.txRef || o.txRef || null;
+  o.amountVerified = (o2.expectExactAmount !== false);   // 是否由服务端核对过实收金额
+  o.creditedBy = o2.source || 'manual';                  // reconcile（对公流水批量对账）/ admin / honor
+  o.creditedCents = creditedCents;
+  if (Number.isInteger(o2.receivedCents)) o.receivedCents = o2.receivedCents;
+  saveLedger();
+  ledgerAudit({ event: 'order_paid', orderId: orderId, key: kp.mask, cents: creditedCents, channel: o.channel,
+    txRef: o.txRef, amountVerified: o.amountVerified, receivedCents: o.receivedCents || null, source: o.creditedBy });
+  appendLog({ ts: new Date().toISOString(), event: 'order_paid', orderId: orderId, channel: o.channel,
+    cents: paidAmount, source: o.creditedBy });
+  return done(true, false);
+}
+
+// ---- 建单逻辑（被 /pay/order 路由与 MCP `pay` 工具共用，零分叉）----
+// 返回 { orderId, key, calls, amountCents, payment, discarded } 或 { error:{status,error} }
+function createOrder(ip, body) {
+  // 对公收款：按次计费 ¥0.01/次，下单 = 1 次 = 1 分钱。
+  // 不预充、无套餐、无其他金额：每次 pay 只卖「1 次调用」的凭证（calls 恒为 1）。
+  // 「多付多得」由对账按实收金额折算实现：付款人向对公聚合码付任意正金额，
+  // reconcile-bank.js 按 ¥0.01/次 折算 N' = 实收/¥0.01 次入账，与本次下单次数无关。
+  if (body && body.plan !== undefined) {
+    return { error: { status: 400, error: { type: 'no_bundles', message: '本服务按次付费（' + yuan(PRICE_CENTS) + '/次），不卖套餐/订阅；每次 pay 即 1 次（1 分钱），无需传 plan。' } } };
+  }
+  if (body && body.calls !== undefined) {
+    return { error: { status: 400, error: { type: 'fixed_price', message: '本服务单价固定为 ' + yuan(PRICE_CENTS) + '/次，不预充、无套餐、无其他金额；每次下单即为 1 次（1 分钱），无需传 calls。' } } };
+  }
+  const calls = 1;
+  const amountCents = calls * PRICE_CENTS; // 恒为 1 分
+  const orderId = newOrderId();
+  const key = newKey();
+  const keyHash = hashKey(key);
+  const nowIso = new Date().toISOString();
+  // ── 隐私红线（与 privacy.html 的公开承诺一致）──────────────────────
+  // 本服务「不设账号、不收集不存储任何个人信息」。因此建单**只**落：
+  //   订单号、凭证 SHA-256、次数、金额、状态、时间戳、来源 IP（元数据）。
+  // 明确**不落**：姓名/电话/邮箱/微信号等联系方式，以及任何客户端提交的自由文本。
+  const discarded = [];
+  if (body.contact !== undefined) discarded.push('contact');
+  if (body.note !== undefined) discarded.push('note');
+  ledger.keys[keyHash] = {
+    mask: maskKey(key), balanceCents: 0, createdAt: nowIso, lastUsedAt: null,
+    calls: 0, spentCents: 0, disabled: false,
+    note: '订单 ' + orderId          // 仅服务端生成的订单号，绝不写入客户端自由文本
+  };
+  ledger.orders[orderId] = {
+    keyHash: keyHash, calls: calls, amountCents: amountCents,
+    status: 'pending', createdAt: nowIso, paidAt: null, channel: null, txRef: null,
+    ip: ip                            // 与 nginx 日志同类的最小元数据，已在 privacy.html 披露
+  };
+  pruneOrders();
+  try { saveLedger(); } catch (e) {
+    delete ledger.keys[keyHash]; delete ledger.orders[orderId];
+    return { error: { status: 500, error: { type: 'internal_error', message: '账本写入失败，订单未创建：' + ((e && e.message) || String(e)) } } };
+  }
+  ledgerAudit({ event: 'order_created', orderId: orderId, key: maskKey(key), calls: calls, amountCents: amountCents, ip: ip });
+  appendLog({ ts: nowIso, ip: ip, event: 'order_created', orderId: orderId, calls: calls, amountCents: amountCents });
+  // 对公收款：统一收款入口 = 对公静态聚合码（不接任何支付平台商户 API）
+  const payment = paymentInfo(orderId, amountCents);
+  if (payment.error) return { error: { status: 400, error: payment.error } };
+  return { orderId, key, calls, amountCents, payment, discarded };
+}
+
 // ---- HTTP 服务 ----
 const sessions = new Map(); // sessionId -> { createdAt, sse? }
 
@@ -330,8 +1267,22 @@ const server = http.createServer((req, res) => {
     return res.end();
   }
 
-  // 健康检查
-  if (req.method === 'GET' && (req.url === '/' || req.url === '/health')) {
+  // 路径解析：必须剥离查询串（原先拿 req.url 整串比对，带 ?key=<key> 会掉到 404）
+  let pathname = '/';
+  let query = new URLSearchParams('');
+  try {
+    const u = new URL(req.url || '/', 'http://placeholder.invalid');
+    pathname = u.pathname;
+    query = u.searchParams;
+  } catch (_e) { /* 非法 URL 视为根路径 */ }
+  const ip = (req.headers['x-forwarded-for'] || req.socket.remoteAddress || 'unknown').toString().split(',')[0].trim();
+  const ctx = buildCtx(req, query);
+  // 单一同步点：每个请求入口先对一次磁盘指纹。
+  // 运维在进程外手工改过账本就重新载入 —— 否则内存副本会在下次写入时把手工修静默覆盖。
+  refreshLedgerIfChanged();
+
+  // 健康检查（含计费状态：便于外部一条 curl 自证收费墙是否真的开着）
+  if (req.method === 'GET' && (pathname === '/' || pathname === '/health')) {
     // solverVersion 从已加载的求解沙箱实时读取，保证 /health 报告的版本与实际核心一致（不靠手写常量，杜绝假版本）
     let solverVersion = null;
     try { solverVersion = solverCore.raw().SOLVER_VERSION || null; } catch (_e) { /* index.html 未就绪时降级为 null */ }
@@ -341,13 +1292,344 @@ const server = http.createServer((req, res) => {
       solverVersion,
       status: 'ok',
       transport: 'streamable-http',
-      endpoints: { mcp: 'POST /mcp (SSE via GET /mcp)', health: 'GET /health' },
+      metering: METERING_ON ? 'on' : 'off',
+      priceCentsPerCall: METERING_ON ? PRICE_CENTS : 0,
+      requireTls: REQUIRE_TLS ? 'on' : 'off',
+      // 到账是否已自动化：对公收款 走对账批量入账（false = 非实时 API 自动入账）
+      autoCredit: false,
+      receiptVerified: !RECEIPT_TAMPERED,
+      receiptTampered: RECEIPT_TAMPERED || undefined,
+      // 钉死收款去向的指纹（账号+户名+收款码的 SHA-256，公开信息、无秘密）。
+      // 任何人都能用它核对：线上收款去向 = 代码里钉死的公司账户，未被换掉。
+      receiptPinHash: RECEIPT_PIN_HASH,
+      receiptPinAccount: PINNED_ACCOUNT.slice(0, 4) + '****' + PINNED_ACCOUNT.slice(-4),
+      receiptPinAccountName: PINNED_ACCOUNT_NAME,
+      payChannel: RECEIPT_TAMPERED ? null : (PAY_TO ? 'corporate-static' : null),
+      honorClaims: honorClaims,
+      // 自助入账次数（信任制第二条口子）：**不代表真收入**。真营收只认银行流水核对过的单。
+      selfReportClaims: selfReportClaims,
+      revenueHonesty: '声明类额度（honorClaims / selfReportClaims）不算营收；真营收以对公流水核对为准（台账 creditedBy=reconcile/admin 且 amountVerified:true）。',
+      accountRequired: false,
+      endpoints: {
+        mcp: 'POST /mcp (SSE via GET /mcp)',
+        health: 'GET /health',
+        pricing: 'GET /pricing',
+        order: 'POST /pay/order',
+        credit: 'GET /credit'
+      },
       tools: TOOLS.map(t => t.name)
     });
   }
 
+  // ---- GET /pricing：公开价格表（无需凭证）----
+  if (req.method === 'GET' && pathname === '/pricing') {
+    return sendJson(res, 200, pricingDoc(req));
+  }
+
+  // ---- GET /credit：查询余额（免费；仅读自己的 key）----
+  if (req.method === 'GET' && pathname === '/credit') {
+    if (!METERING_ON) {
+      return sendJson(res, 200, { metering: 'off', note: '本端点未启用计费，调用免费。', freeAlternatives: freeAlternatives() });
+    }
+    if (!ctx.key) {
+      return sendJson(res, 401, { error: { type: 'missing_key', message: '缺少凭证：请带 Authorization: Bearer <key> 或 ?key=<key>。', howToGetKey: paywallError('missing_key', ctx).howToGetKey } });
+    }
+    const k = ledger.keys[ctx.keyHash];
+    if (!k) {
+      return sendJson(res, 401, { error: { type: 'invalid_key', message: '凭证无效（该 key 不在账本中）。' } });
+    }
+    return sendJson(res, 200, {
+      key: k.mask,
+      balanceCents: k.balanceCents,
+      balanceDisplay: yuan(k.balanceCents),
+      callsRemaining: Math.floor(k.balanceCents / PRICE_CENTS),
+      priceCentsPerCall: PRICE_CENTS,
+      calls: k.calls || 0,
+      spentCents: k.spentCents || 0,
+      createdAt: k.createdAt,
+      lastUsedAt: k.lastUsedAt || null,
+      disabled: !!k.disabled
+    });
+  }
+
+  // ---- POST /pay/order：创建订单并发凭证（无需凭证，但限速；防刷单表）----
+  if (req.method === 'POST' && pathname === '/pay/order') {
+    if (!METERING_ON) {
+      return sendJson(res, 200, { metering: 'off', note: '本端点未启用计费，无需下单；直接调用即可。', freeAlternatives: freeAlternatives() });
+    }
+    if (!orderAllowed(ip)) {
+      appendLog({ ts: new Date().toISOString(), ip: ip, event: 'order_rate_limited' });
+      return sendJson(res, 429, { error: { type: 'rate_limited', message: '下单过于频繁（' + ORDER_RATE_MAX + ' 单/小时）。' } });
+    }
+    return readBody(req, ({ body, err }) => {
+      if (err === 'body_too_large') return sendJson(res, 413, { error: { type: 'body_too_large', message: '请求体过大（64KB 上限）。' } });
+      if (err) return sendJson(res, 400, { error: { type: 'bad_json', message: '请求体不是合法 JSON。' } });
+      const r = createOrder(ip, body);
+      if (r.error) return sendJson(res, r.error.status, { error: r.error.error });
+      const { orderId, key, payment, discarded } = r;
+      return sendJson(res, 201, {
+        orderId: orderId,
+        apiKey: key,
+        apiKeyNotice: '此 key 仅在本响应中出现一次（服务端只存 SHA-256），请立即保存。若遗失，可用订单号联系作者重置。',
+        calls: r.calls,
+        amountCents: r.amountCents,
+        amountDisplay: yuan(r.amountCents),
+        priceCentsPerCall: PRICE_CENTS,
+        status: 'pending',
+        payable: !!(payment && (payment.configured || payment.payUrl || payment.codeUrl || payment.mode === 'auto')),
+        payment: payment,
+        paymentChannels: availableChannels(),
+        payIntent: payIntent(orderId, r.calls, r.amountCents),
+        // ⭐ 零人工闭环：付款完调 MCP pay 工具传 orderId + selfReportPaid:true 即立即入账。
+        // 收款方（作者）无需跑任何对账脚本、无需看任何流水 —— 这是「不要人工触发」的实现。
+        selfCredit: {
+          how: '付完款后：调 MCP pay 工具，入参 {"orderId":"' + orderId + '","selfReportPaid":true} → 立即入账、立即放行。',
+          why: '本服务按信任制运转，自助入账不做验证：这道门的另一条路（solve 传 honorPaid:true）本来就免费，所以「声明已付」不会造成额外损失，只是让诚实付款的人不必等对账。',
+          mark: '自助入账的单在账本里标注 amountVerified:false / creditedBy:self_report；真营收仍以银行流水核对为准（不给付款方增加任何步骤）。'
+        },
+        privacy: {
+          accountRequired: false,
+          personalDataCollected: false,
+          note: '无需注册账号：此 key 即身份（凭证即账号）。本服务不收集、不存储任何个人信息（姓名/电话/邮箱/微信号等），服务端只留凭证的 SHA-256 与账目元数据；明文凭证仅在本响应出现一次，请自行保存。',
+          contactPolicy: '如需与我们联系，请自行保存上面的订单号——系统里没有你的联系方式，我们无法主动联系你。',
+          discardedFields: discarded,
+          discardedNotice: discarded.length
+            ? ('你提交的 ' + discarded.join('、') + ' 字段已被丢弃，未被存储（本服务不收集个人信息）。')
+            : null
+        },
+        howToUse: {
+          endpoint: baseUrl(req) + '/mcp',
+          secureEndpointRecommended: '生产接入请用 https://<域名>/mcp —— Bearer 凭证走明文 HTTP 会在公网裸奔。',
+          header: 'Authorization: Bearer ' + key,
+          verifyBalance: 'GET ' + baseUrl(req) + '/credit'
+        }
+      });
+    });
+  }
+
+  // ---- GET /pay/order?orderId=：查订单状态（不返回 key，避免凭订单号取走凭证）----
+  if (req.method === 'GET' && pathname === '/pay/order') {
+    const orderId = (query.get('orderId') || '').trim();
+    if (!orderId) return sendJson(res, 400, { error: { type: 'missing_orderId', message: '缺少 orderId 查询参数。' } });
+    const o = getOrder(orderId);
+    if (!o) return sendJson(res, 404, { error: { type: 'order_not_found', message: '订单不存在：' + orderId } });
+    return sendJson(res, 200, {
+      orderId: orderId, calls: o.calls, amountCents: o.amountCents, amountDisplay: yuan(o.amountCents),
+      status: o.status, createdAt: o.createdAt, paidAt: o.paidAt || null,
+      payment: paymentInfo(orderId, o.amountCents),
+      payIntent: payIntent(orderId, o.calls, o.amountCents)
+    });
+  }
+
+  // ---- 管理端点（必须带 X-Admin-Token；未配置 LS_ADMIN_TOKEN 时整体 503，fail-closed）----
+  if (pathname.indexOf('/admin/') === 0) {
+    const g = adminGuard(req);
+    if (!g.ok) return sendJson(res, g.code, { error: { type: g.type || 'forbidden', message: g.msg } });
+
+    // POST /admin/order/confirm：确认到账 → 给该订单的 key 入账
+    if (req.method === 'POST' && pathname === '/admin/order/confirm') {
+      return readBody(req, ({ body, err }) => {
+        if (err) return sendJson(res, 400, { error: { type: err, message: '请求体不合法。' } });
+        const orderId = String((body && body.orderId) || '').trim();
+        const o = getOrder(orderId);
+        if (!o) return sendJson(res, 404, { error: { type: 'order_not_found', message: '订单不存在：' + orderId } });
+
+        // ── 对公收款 人工确认路径：仍强制核对金额（fail-closed）────────────
+        // 本端点用于：① 走对公静态收款码/转账的老通道，作者拿流水按订单号折算入账；
+        // ② 金额不符/订单丢失时的兜底人工处置。正常到账由作者跑 reconcile-bank.js 批量入账。
+        const received = (body && body.receivedCents !== undefined) ? body.receivedCents : undefined;
+        if (received === undefined && !(body && body.acknowledgeUnverified === true)) {
+          return sendJson(res, 400, {
+            error: {
+              type: 'amount_not_verified',
+              message: '拒绝在未核对金额的情况下入账：请传 receivedCents（银行流水里实际到账的分数）。',
+              orderId: orderId,
+              expectedCents: o.amountCents,
+              expectedDisplay: yuan(o.amountCents),
+              whyItMatters: '付款链接里的 amount 参数是客户端可改的；不核对金额 = 1 分钱的转账可以领走整单额度。',
+              alternative: '对公收款：走「对公静态收款 + 银行流水对账」——付款后由作者按订单号批量折算入账（按 ' + yuan(PRICE_CENTS) + '/次），无需平台回调。',
+              orPass: 'acknowledgeUnverified:true（表示你已自行核对，风险自担）'
+            }
+          });
+        }
+        const r = creditOrder(orderId, {
+          receivedCents: received,
+          // 默认：传了 receivedCents 就要求「逐分相等」（防少付多领）；
+          // 但调用方（如 reconcile-bank.js 的对公静态折算）可显式传 expectExactAmount:false，
+          // 表示「按实收金额折算入账，不要求恰为订单面值」——此处尊重该显式开关。
+          expectExactAmount: (body && body.expectExactAmount !== undefined) ? !!body.expectExactAmount : (received !== undefined),
+          channel: (body && body.channel) || null,
+          txRef: (body && body.txRef) || null,
+          source: 'admin'
+        });
+        if (!r.ok) {
+          if (r.reason === 'amount_mismatch') {
+            return sendJson(res, 409, {
+              error: {
+                type: 'amount_mismatch',
+                message: '实收金额与订单金额不符，已拒绝入账（防「少付多领」）。',
+                orderId: orderId,
+                expectedCents: r.expectedCents, expectedDisplay: r.expectedDisplay,
+                receivedCents: Number.isInteger(r.receivedCents) ? r.receivedCents : null,
+                receivedDisplay: r.receivedDisplay || null,
+                outOfRange: !Number.isInteger(r.receivedCents) ? 'receivedCents 必须是整数（单位：分）' : null,
+                howToProceed: [
+                  '核对银行流水后重试，传正确的 receivedCents',
+                  '若确实要按实收金额入账（部分到账 / 善意补偿 / 客户讨价），改用 POST /admin/credit {"orderId":"…","cents":<分>,"reason":"…"}',
+                  '若确认要按整单入账，传 acknowledgeUnverified:true'
+                ]
+              }
+            });
+          }
+          return sendJson(res, r.reason === 'order_not_found' ? 404 : 500, {
+            error: { type: r.reason, message: '入账未完成：' + r.reason + '（订单 ' + orderId + '）' }
+          });
+        }
+        return sendJson(res, 200, {
+          orderId: orderId, status: 'paid', alreadyPaid: r.alreadyPaid, key: r.keyMask,
+          creditedCents: r.creditedCents, balanceCents: r.balanceCents, callsRemaining: r.callsRemaining,
+          amountVerified: received !== undefined,
+          amountNotice: r.alreadyPaid
+            ? '该订单此前已入账，未重复入账。'
+            : (received !== undefined
+              ? ('已核对实收 ' + yuan(received) + '，与订单金额一致。')
+              : '⚠️ 未核对金额即入账（acknowledgeUnverified）——请自行留存银行流水凭证，以便日后对账。')
+        });
+      });
+    }
+
+    // POST /admin/credit：手工入账（送额度/线下转账/补偿）—— 目标可用 keyHash / apiKey / orderId 指定
+    if (req.method === 'POST' && pathname === '/admin/credit') {
+      return readBody(req, ({ body, err }) => {
+        if (err) return sendJson(res, 400, { error: { type: err, message: '请求体不合法。' } });
+        const cents = body && body.cents;
+        if (typeof cents !== 'number' || Math.floor(cents) !== cents || cents === 0) {
+          return sendJson(res, 400, { error: { type: 'invalid_cents', message: 'cents 必须是非零整数（可为负以扣减）。' } });
+        }
+        let keyHash = null;
+        if (body.apiKey) keyHash = hashKey(String(body.apiKey).trim());
+        else if (body.keyHash) keyHash = String(body.keyHash).trim();
+        else if (body.orderId) {
+          const o = getOrder(String(body.orderId).trim());
+          if (!o) return sendJson(res, 404, { error: { type: 'order_not_found', message: '订单不存在。' } });
+          keyHash = o.keyHash;
+        }
+        const k = keyHash ? ledger.keys[keyHash] : null;
+        const reason = String((body && body.reason) || 'manual');
+        if (!k) {
+          // 无 key 时按「新发一张凭证」处理（管理员送额度给某人）
+          if (!body.issueNew) {
+            return sendJson(res, 404, { error: { type: 'key_not_found', message: '未找到该凭证。若需新发一张，请传 issueNew:true。' } });
+          }
+          const nk = newKey();
+          const nh = hashKey(nk);
+          ledger.keys[nh] = {
+            mask: maskKey(nk), balanceCents: cents, createdAt: new Date().toISOString(),
+            lastUsedAt: null, calls: 0, spentCents: 0, disabled: false, note: reason
+          };
+          saveLedger();
+          ledgerAudit({ event: 'key_issued', key: maskKey(nk), cents: cents, reason: reason });
+          return sendJson(res, 201, { apiKey: nk, apiKeyNotice: '此 key 仅出现一次，请立即保存。', balanceCents: cents, callsRemaining: Math.floor(cents / PRICE_CENTS), note: reason });
+        }
+        k.balanceCents += cents;
+        k.note = (k.note ? k.note + ' | ' : '') + reason;
+        saveLedger();
+        ledgerAudit({ event: 'admin_credit', key: k.mask, cents: cents, balanceCents: k.balanceCents, reason: reason });
+        return sendJson(res, 200, { key: k.mask, creditedCents: cents, balanceCents: k.balanceCents, callsRemaining: Math.floor(k.balanceCents / PRICE_CENTS) });
+      });
+    }
+
+    // POST /admin/key/disable：停用凭证（盗用/退款）
+    if (req.method === 'POST' && pathname === '/admin/key/disable') {
+      return readBody(req, ({ body, err }) => {
+        if (err) return sendJson(res, 400, { error: { type: err, message: '请求体不合法。' } });
+        const keyHash = body.apiKey ? hashKey(String(body.apiKey).trim()) : String((body && body.keyHash) || '').trim();
+        const k = ledger.keys[keyHash];
+        if (!k) return sendJson(res, 404, { error: { type: 'key_not_found', message: '未找到该凭证。' } });
+        k.disabled = !!body.disabled;
+        k.note = (k.note ? k.note + ' | ' : '') + (k.disabled ? 'disabled by admin' : 'enabled by admin');
+        saveLedger();
+        ledgerAudit({ event: k.disabled ? 'key_disabled' : 'key_enabled', key: k.mask });
+        return sendJson(res, 200, { key: k.mask, disabled: k.disabled, balanceCents: k.balanceCents });
+      });
+    }
+
+    // POST /admin/rotate：凭证遗失重置 —— 新 key 继承旧 key 余额（旧 key 立即失效）
+    if (req.method === 'POST' && pathname === '/admin/rotate') {
+      return readBody(req, ({ body, err }) => {
+        if (err) return sendJson(res, 400, { error: { type: err, message: '请求体不合法。' } });
+        let keyHash = null;
+        if (body.orderId) {
+          const o = getOrder(String(body.orderId).trim());
+          if (!o) return sendJson(res, 404, { error: { type: 'order_not_found', message: '订单不存在。' } });
+          keyHash = o.keyHash;
+        } else if (body.apiKey) keyHash = hashKey(String(body.apiKey).trim());
+        else if (body.keyHash) keyHash = String(body.keyHash).trim();
+        const old = ledger.keys[keyHash];
+        if (!old) return sendJson(res, 404, { error: { type: 'key_not_found', message: '未找到旧凭证。' } });
+        const nk = newKey();
+        const nh = hashKey(nk);
+        ledger.keys[nh] = {
+          mask: maskKey(nk), balanceCents: old.balanceCents, createdAt: new Date().toISOString(),
+          lastUsedAt: null, calls: old.calls || 0, spentCents: old.spentCents || 0, disabled: false,
+          note: 'rotate from ' + old.mask + (old.note ? ' | ' + old.note : '')
+        };
+        delete ledger.keys[keyHash];
+        if (body.orderId) {
+          // 用 getOrder 而非直接索引：非法订单号/不存在的单不该 500，且防原型链键名。
+          const o = getOrder(String(body.orderId).trim());
+          if (o) o.keyHash = nh;
+        }
+        saveLedger();
+        ledgerAudit({ event: 'key_rotated', from: old.mask, to: maskKey(nk), balanceCents: old.balanceCents });
+        return sendJson(res, 200, { apiKey: nk, apiKeyNotice: '此 key 仅出现一次，请立即保存。', oldKeyMask: old.mask, balanceCents: old.balanceCents, callsRemaining: Math.floor(old.balanceCents / PRICE_CENTS) });
+      });
+    }
+
+    // GET /admin/ledger：只读台账（key 一律脱敏）
+    if (req.method === 'GET' && pathname === '/admin/ledger') {
+      const keys = Object.entries(ledger.keys).map(([h, k]) => ({
+        keyHash: h.slice(0, 12) + '…', mask: k.mask, balanceCents: k.balanceCents,
+        calls: k.calls || 0, spentCents: k.spentCents || 0,
+        disabled: !!k.disabled, createdAt: k.createdAt, lastUsedAt: k.lastUsedAt || null, note: k.note || null
+      }));
+      const orders = Object.entries(ledger.orders).map(([id, o]) => ({
+        orderId: id, calls: o.calls, amountCents: o.amountCents, status: o.status,
+        createdAt: o.createdAt, paidAt: o.paidAt || null, channel: o.channel || null, txRef: o.txRef || null,
+        creditedBy: o.creditedBy || null, amountVerified: o.amountVerified === true
+      }));
+      const totalBalance = keys.reduce((s, k) => s + k.balanceCents, 0);
+      const totalSpent = keys.reduce((s, k) => s + k.spentCents, 0);
+      const paidOrders = orders.filter(o => o.status === 'paid');
+      // ⭐ 营收要分两栏，不能混：① 已核实（银行流水核对过）② 凭声明（信任制自助入账）。
+      // 混在一起就会把「声明」当收入，是自欺；用户对虚报数字零容忍。
+      const verified = paidOrders.filter(o => o.creditedBy === 'reconcile' || o.creditedBy === 'admin');
+      const selfReported = paidOrders.filter(o => o.creditedBy === 'self_report');
+      const sumCents = (arr) => arr.reduce((s, o) => s + o.amountCents, 0);
+      return sendJson(res, 200, {
+        metering: METERING_ON ? 'on' : 'off', priceCentsPerCall: PRICE_CENTS,
+        summary: {
+          keyCount: keys.length,
+          totalBalanceCents: totalBalance, totalBalanceDisplay: yuan(totalBalance),
+          totalSpentCents: totalSpent, totalSpentDisplay: yuan(totalSpent),
+          totalCalls: keys.reduce((s, k) => s + k.calls, 0),
+          honorClaims: honorClaims,
+          selfReportClaims: selfReportClaims,
+          orderCount: orders.length, paidOrderCount: paidOrders.length,
+          paidRevenueCents: sumCents(paidOrders),
+          paidRevenueDisplay: yuan(sumCents(paidOrders)),
+          verifiedRevenueCents: sumCents(verified), verifiedRevenueDisplay: yuan(sumCents(verified)), verifiedOrderCount: verified.length,
+          selfReportedCents: sumCents(selfReported), selfReportedDisplay: yuan(sumCents(selfReported)), selfReportedOrderCount: selfReported.length,
+          revenueHonesty: '真营收 = verifiedRevenueCents（对公流水核对过的单）。selfReportedCents 与 honorClaims 是凭声明发的，不计入营收。'
+        },
+        payment: paymentInfo(), keys: keys, orders: orders
+      });
+    }
+    return sendJson(res, 404, { error: { type: 'not_found', message: '未知管理端点。', available: ['POST /admin/order/confirm', 'POST /admin/credit', 'POST /admin/key/disable', 'POST /admin/rotate', 'GET /admin/ledger'] } });
+  }
+
   // MCP 端点：Streamable HTTP（POST 请求 / GET 收 SSE / DELETE 终止会话）
-  if (req.url === '/mcp') {
+  if (pathname === '/mcp') {
     // GET：打开 SSE 流，接收服务端→客户端通知（MCP Streamable HTTP 规范）
     if (req.method === 'GET') {
       const sessionId = req.headers['mcp-session-id'] || crypto.randomUUID();
@@ -375,7 +1657,6 @@ const server = http.createServer((req, res) => {
     }
     // POST：JSON-RPC 请求
     if (req.method === 'POST') {
-      const ip = (req.headers['x-forwarded-for'] || req.socket.remoteAddress || 'unknown').toString().split(',')[0].trim();
       // 限速（安全等保加固）：超限直接 429，不读不处理
       if (!rateAllowed(ip)) {
         appendLog({ ts: new Date().toISOString(), ip: ip, event: 'rate_limited' });
@@ -416,7 +1697,7 @@ const server = http.createServer((req, res) => {
         const responses = [];
         for (const m of batch) {
           if (m && m.jsonrpc === '2.0') {
-            const r = handleRpc(m, ip);
+            const r = handleRpc(m, ip, ctx);
             if (r !== null) responses.push(r);
           }
         }
@@ -441,9 +1722,31 @@ const server = http.createServer((req, res) => {
   res.end('Not Found. MCP endpoint: POST /mcp');
 });
 
+// 账本在启动时加载（不在模块顶层读盘，便于测试脚本先设 LS_CREDITS_PATH 再 require）
+loadLedger();
+
 server.listen(PORT, '0.0.0.0', () => {
-  appendLog({ ts: new Date().toISOString(), event: 'server_start', name: SERVER_NAME, version: SERVER_VERSION, port: PORT });
+  appendLog({
+    ts: new Date().toISOString(), event: 'server_start', name: SERVER_NAME, version: SERVER_VERSION, port: PORT,
+    metering: METERING_ON ? 'on' : 'off', priceCents: METERING_ON ? PRICE_CENTS : 0,
+    adminEnabled: !!ADMIN_TOKEN, payConfigured: !!PAY_TO,
+    receiptPinHash: RECEIPT_PIN_HASH, receiptTampered: RECEIPT_TAMPERED,
+    keyCount: Object.keys(ledger.keys).length, orderCount: Object.keys(ledger.orders).length
+  });
   console.log(`[${SERVER_NAME}] HTTP MCP server listening on 0.0.0.0:${PORT}`);
   console.log(`  health : GET  http://localhost:${PORT}/health`);
   console.log(`  mcp    : POST http://localhost:${PORT}/mcp`);
+  console.log(`  metering: ${METERING_ON ? 'ON  ' + PRICE_CENTS + ' 分/次' : 'off (免费)'}`);
+  console.log(`  tls     : ${REQUIRE_TLS ? 'REQUIRED for credentialed calls' : 'not enforced (凭证可走明文，迁移期)'}`);
+  console.log(`  account : not required (key = account); collects no personal data`);
+  console.log(`  pricing : GET  http://localhost:${PORT}/pricing`);
+  console.log(`  pay     : 对公收款（corporate-static，对公静态收款 + 流水对账，不接任何支付平台商户 API）`);
+  console.log(`  admin   : ${ADMIN_TOKEN ? 'enabled' : 'DISABLED (未设 LS_ADMIN_TOKEN)'}${ADMIN_LOOPBACK_ONLY ? ' [loopback-only]' : ' [reachable remotely]'} | payTo: ${PAY_TO ? 'configured' : 'NOT configured (未设 LS_PAY_TO)'}`);
+  console.log(`  receipt : pinned=${PINNED_ACCOUNT}  tamper=${RECEIPT_TAMPERED ? 'YES ⚠ 收款去向被篡改，已 fail-closed 拒绝收款' : 'OK (verified)'}${RECEIPT_TAMPERED ? '  problems=' + GUARD_PROBLEMS.join(' | ') : ''}`);
+  if (RECEIPT_TAMPERED) {
+    console.warn('[SECURITY] 收款去向与钉死值不符，已 fail-closed：不再生成任何付款意图。问题：' + GUARD_PROBLEMS.join(' | '));
+  }
+  if (METERING_ON && !PAY_TO) {
+    console.warn('[warn] 计费已开但未配置 LS_PAY_TO：订单可创建却无法付款。');
+  }
 });