@whyshu/argent-engine 0.0.0-stage → 0.6.0

package/engine/scripts/poc-mcp-host.mjs

@@ -0,0 +1,455 @@
+#!/usr/bin/env node
+/**
+ * poc-mcp-host.mjs —— **第二宿主 PoC：极简 MCP stdio 宿主**（2026-10-05）
+ *
+ * ══════════════════════════════════════════════════════════════════════════
+ * 一、它要回答的问题（`docs/Argent-1.0-退出判据与版本规则.md` §2.4 **H1**）
+ * ══════════════════════════════════════════════════════════════════════════
+ * H1 = 「第二个宿主的 L2 六项接口跑通」= 1.0 唯一真"平台"判据。此前**没有任何非 `dsh web`
+ * 宿主**六项全绿 ⇒ 本文这个宿主（**不是 dsh**，只是一个 stdio JSON-RPC 客户端）就是被实跑的
+ * "第二个宿主"：它把 Argent 内核（`core/mcp/server.mjs`）挂上去，逐条量出六项里**哪些真的可达**。
+ *
+ * 分层口径（**只引用不复述**）：`docs/Argent-宿主适配契约.md` = 分层与宿主适配的唯一权威，
+ * 六项接口定义见其 §2、能力×宿主矩阵见其 §3。本脚本**不是**那份矩阵的第二份真源 —— 它只打印
+ * **实测事实**（initialize / tools/list / tools/call / 版本查询），六项可达性的权威口径以契约 §3 为准。
+ *
+ * ══════════════════════════════════════════════════════════════════════════
+ * 二、纪律（PoC 的硬约束）
+ * ══════════════════════════════════════════════════════════════════════════
+ *   · **只读**：`READ_ONLY_TOOLS` 白名单**硬编码**在代码里（不是配置），请求写类 tool（`argent_claim` /
+ *     `argent_writeback` / `argent_license` 之外的激活…）⇒ **拒绝调用**并 exit 2。
+ *     影子类（`*_shadow`）虽然"不写真台账"，但会 `cpSync` 整个数据目录 / 造临时文件 ⇒ **也不在白名单**。
+ *   · **零副作用**：本脚本自己不建临时文件、不写日志、不碰数据目录（只 spawn 子进程 + 读 stdout）。
+ *     证明方式是**外部**的：跑前跑后各拍一次真实数据目录快照再比对 ——
+ *     `node scripts/check-test-env-safety.mjs --snapshot <f>` → 跑本脚本 → `--verify <f>`（三层判据）。
+ *   · **子进程环境**：默认继承调用方 `process.env`（宿主就该继承），但**强制** `ARGENT_TELEMETRY_OFF=1`
+ *     —— PoC 绝不能因为被跑了一次就把事件推到生产告警。要真发遥测得显式 `--allow-telemetry`。
+ *   · **不依赖 dsh**：本脚本只用 `node:` 内置模块；`env -i` + 临时 HOME 下也能起（见 `--help` 的用法示例）。
+ *
+ * ══════════════════════════════════════════════════════════════════════════
+ * 三、用法与退出码
+ * ```
+ * node scripts/poc-mcp-host.mjs                          # 人读摘要（默认 3 个只读工具）
+ * node scripts/poc-mcp-host.mjs --json                   # 机器可读证据（逐条判据 + 耗时）
+ * node scripts/poc-mcp-host.mjs --tools argent_version,argent_license
+ * node scripts/poc-mcp-host.mjs --expect-tools 14        # tools/list 与冻结口径比对（默认 14）
+ * node scripts/poc-mcp-host.mjs --json --full            # 证据不瘦身（默认截断长值/长数组，便于安全外贴）
+ * env -i HOME=$(mktemp -d) PATH=/usr/bin:/bin:<node 目录> node scripts/poc-mcp-host.mjs --json   # 隔离启动
+ * ```
+ * 退出码：`0` 判据全过 / `1` 有判据不过 / `2` 用法错误（含**请求了写类 tool**）。
+ */
+import { spawn } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+// 数据目录**唯一判据**（内核件；宿主也照它取，⛔ 不自己拼链）—— 只用于输出脱敏，不做任何业务判断
+import { resolveDataDir } from '../core/lib/argent-datadir.mjs'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const REPO = resolve(HERE, '..')
+const DEFAULT_SERVER = join(REPO, 'core', 'mcp', 'server.mjs')
+const CLI = join(REPO, 'core', 'cli', 'argent.mjs')
+const CLIENT_INFO = { name: 'poc-mcp-host', version: '0.1.0' }
+const PROTOCOL_VERSION = '2024-11-05'
+
+/**
+ * **只读 tool 白名单**（硬编码 = 代码级门禁，不是配置）。
+ * 判据：该 tool 的 handler 只 `readFileSync` / 跑只读脚本（`--scan` / `--json` / `status`），
+ * 不写数据目录、不写生产表、不认领、不产生影子目录。逐个复核于 2026-10-05：
+ *   · `argent_version`  —— 读 `VERSION` + `dsh --version`（子进程，只读）
+ *   · `argent_license`  —— `core/lib/license.mjs#status` ⇒ `scripts/check-license.mjs`（只读，无 write 调用点）
+ *   · `argent_ledger`   —— 读 `flow-ledger.jsonl`
+ *   · `argent_report` / `argent_failures` —— `scripts/flow_failure.py`（分类 / `--scan`，只读）
+ *   · `argent_sop`      —— `core/lib/sop.mjs`（读 skill 目录 + 提示词）
+ *   · `argent_doctor` / `argent_preflight` —— `scripts/flow_preflight.py`（门禁体检，不写表、不认领）
+ *   · `argent_writeback_audit` —— 读 `invoice-writeback/audit.jsonl`
+ * ⛔ **不在**白名单：`argent_claim` / `argent_writeback`（写类）、`argent_claim_shadow` /
+ *    `argent_writeback_shadow`（会 cpSync 数据目录 / 造临时文件 ⇒ 不是"零副作用"）。
+ */
+const READ_ONLY_TOOLS = new Set([
+  'argent_version', 'argent_license', 'argent_ledger', 'argent_report', 'argent_failures',
+  'argent_sop', 'argent_doctor', 'argent_preflight', 'argent_writeback_audit',
+])
+const DEFAULT_TOOLS = ['argent_version', 'argent_license', 'argent_failures']
+/** 各只读 tool 的**最小**入参（不含任何业务词：本文件属 `scripts/`，engine-words 门禁盯着）。 */
+const DEFAULT_ARGS = {
+  argent_version: {},
+  argent_license: {},
+  argent_failures: {},
+  argent_report: { error: 'timeout' },
+  argent_ledger: { tail: 3 },
+  argent_writeback_audit: { tail: 2 },
+}
+/** 冻结口径（门禁 `scripts/check-judgment-drift.mjs` 自报 MCP tools 数）；`--expect-tools` 可覆盖。 */
+const FROZEN_TOOLS_COUNT = 14
+
+function usage() {
+  return readFileSync(fileURLToPath(import.meta.url), 'utf8').split('*/')[0].replace(/^\/\*\*?/, '').trim()
+}
+
+function parseArgs(argv) {
+  const o = {
+    server: DEFAULT_SERVER, tools: [...DEFAULT_TOOLS], timeoutMs: 30000,
+    expectTools: FROZEN_TOOLS_COUNT, json: false, cli: true, telemetryOff: true, full: false,
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    const val = () => {
+      const v = argv[i + 1]
+      if (v === undefined || v.startsWith('--')) throw new Error(`${a} 缺值`)
+      i++
+      return v
+    }
+    if (a === '--json') { o.json = true; continue }
+    if (a === '--full') { o.full = true; continue }
+    if (a === '--no-cli') { o.cli = false; continue }
+    if (a === '--allow-telemetry') { o.telemetryOff = false; continue }
+    if (a === '--server') { o.server = resolve(val()); continue }
+    if (a === '--timeout') { o.timeoutMs = Number(val()); continue }
+    if (a === '--expect-tools') { o.expectTools = Number(val()); continue }
+    if (a === '--tools') { o.tools = val().split(',').map((s) => s.trim()).filter(Boolean); continue }
+    if (a === '-h' || a === '--help') { console.log(usage()); process.exit(0) }
+    throw new Error(`未知参数：${a}`)
+  }
+  if (!Number.isFinite(o.timeoutMs) || o.timeoutMs <= 0) throw new Error('--timeout 必须是正数')
+  if (!Number.isFinite(o.expectTools) || o.expectTools < 0) throw new Error('--expect-tools 必须是非负数')
+  return o
+}
+
+// ── 脱敏：把真实家目录/数据目录/仓库路径换成占位符，并遮蔽令牌形态 ─────────────────────
+// 数据目录**只认内核唯一判据**（`core/lib/argent-datadir.mjs`）—— ⛔ 不在这里拼 `~/.dsh/argent`：
+// 那正是"第二份判据"，会踩门禁 `scripts/tests/argent-datadir.test.mjs`【3】（2026-10-05 实测踩到）。
+const DATA_DIR = resolveDataDir({ env: process.env }).dir
+const SECRET_RE = /\b(eyJ[A-Za-z0-9._-]{10,}|sk-[A-Za-z0-9._-]{8,})\b/g
+function redact(value) {
+  const home = homedir()
+  const subs = [
+    [REPO, '<REPO>'],
+    [DATA_DIR, '<ARGENT_DATA_DIR>'],
+    // 家目录是 `/` 或空 ⇒ 不做这条替换（否则每个路径都会被切碎）
+    [home && home !== '/' && home.length > 1 ? home : '', '<HOME>'],
+  ]
+  const walk = (v) => {
+    if (typeof v === 'string') {
+      let s = v
+      for (const [from, to] of subs) if (from) s = s.split(from).join(to)
+      return s.replace(SECRET_RE, '<REDACTED>')
+    }
+    if (Array.isArray(v)) return v.map(walk)
+    if (v && typeof v === 'object') {
+      const out = {}
+      for (const [k, x] of Object.entries(v)) out[k] = walk(x)
+      return out
+    }
+    return v
+  }
+  return walk(value)
+}
+const clip = (s, n = 220) => (String(s).length > n ? `${String(s).slice(0, n)}…（截断，共 ${String(s).length} 字）` : String(s))
+
+/**
+ * 输出**瘦身**（默认开；`--full` 关）：超长字符串截断、超长数组只留前 N 项。
+ * 为什么默认开：证据要能贴进回报/工单，而 `argent_failures`/`argent_ledger` 的载荷里可能带成片业务原文
+ * ⇒ 默认只带"够判读"的量（结构完整、逐字段仍在，只是长值被截）。要看全量给 `--full`。
+ */
+function shrink(value, { maxStr = 300, maxArr = 20 } = {}) {
+  const walk = (v) => {
+    if (typeof v === 'string') return clip(v, maxStr)
+    if (Array.isArray(v)) {
+      const head = v.slice(0, maxArr).map(walk)
+      return v.length > maxArr ? [...head, `…共 ${v.length} 项（要看全量加 --full）`] : head
+    }
+    if (v && typeof v === 'object') {
+      const out = {}
+      for (const [k, x] of Object.entries(v)) out[k] = walk(x)
+      return out
+    }
+    return v
+  }
+  return walk(value)
+}
+/** 证据出口：先瘦身（默认）再脱敏 —— 两者都只作用于**副本**，不影响判定用的原值。 */
+const present = (value, { full = false } = {}) => redact(full ? value : shrink(value))
+
+/**
+ * 起 MCP server 子进程 + 极简 JSON-RPC 客户端（每行一条消息；id 配对；超时即抛）。
+ * 只用 `node:` 内置模块 ⇒ 本文件在任何 Node ≥ 18 上都能跑（证明"不依赖 dsh 宿主"）。
+ */
+function connect({ serverPath, env, timeoutMs }) {
+  const child = spawn(process.execPath, [serverPath], { stdio: ['pipe', 'pipe', 'pipe'], env })
+  let buf = ''
+  let stderr = ''
+  let nextId = 1
+  const pending = new Map()
+  const done = { exited: false, code: null }
+
+  child.stdout.setEncoding('utf8')
+  child.stdout.on('data', (chunk) => {
+    buf += chunk
+    let i
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim()
+      buf = buf.slice(i + 1)
+      if (!line) continue
+      let msg = null
+      try { msg = JSON.parse(line) } catch { continue }
+      if (msg.id !== undefined && pending.has(msg.id)) {
+        const p = pending.get(msg.id)
+        pending.delete(msg.id)
+        clearTimeout(p.timer)
+        p.resolve(msg)
+      }
+    }
+  })
+  child.stderr.setEncoding('utf8')
+  child.stderr.on('data', (c) => { stderr += c })
+  child.on('exit', (code) => { done.exited = true; done.code = code })
+
+  const request = (method, params) => new Promise((res, rej) => {
+    const id = nextId++
+    const timer = setTimeout(() => {
+      pending.delete(id)
+      rej(new Error(`${method} 超时（${timeoutMs}ms）—— server stderr 末尾：${clip(stderr.slice(-300))}`))
+    }, timeoutMs)
+    pending.set(id, { resolve: res, timer })
+    child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`)
+  })
+  const notify = (method, params) => child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`)
+
+  return {
+    request, notify,
+    stderr: () => stderr,
+    child,
+    close: () => new Promise((res) => {
+      if (done.exited) return res(done.code)
+      child.once('exit', (code) => res(code))
+      child.stdin.end()          // server 见 stdin 结束即 exit 0（`process.stdin.on('end')`）
+      setTimeout(() => { try { child.kill('SIGKILL') } catch { /* 已退 */ } }, 5000).unref?.()
+    }),
+  }
+}
+
+/** 拆 `tools/call` 的响应：content[0].text 里是 JSON 字符串（MCP 既有形状）。 */
+function unpack(msg) {
+  const text = msg?.result?.content?.[0]?.text
+  if (typeof text !== 'string') return { ok: false, parseError: '响应里没有 content[0].text', raw: msg }
+  try { const v = JSON.parse(text); return { ok: true, value: v } } catch (e) { return { ok: false, parseError: `content JSON 解析失败：${e.message}`, text } }
+}
+
+/** 跑一条只读 CLI 命令（`--json`），拿机器可读结果；失败不抛（宿主应看到诊断而不是崩）。 */
+function runCli(args, { env, timeoutMs }) {
+  return new Promise((res) => {
+    const child = spawn(process.execPath, [CLI, ...args], { env, stdio: ['ignore', 'pipe', 'pipe'] })
+    let out = ''
+    let err = ''
+    const timer = setTimeout(() => { try { child.kill('SIGKILL') } catch { /* noop */ } }, timeoutMs)
+    child.stdout.setEncoding('utf8')
+    child.stdout.on('data', (c) => { out += c })
+    child.stderr.setEncoding('utf8')
+    child.stderr.on('data', (c) => { err += c })
+    child.on('exit', (code) => {
+      clearTimeout(timer)
+      let json = null
+      try { json = JSON.parse(out) } catch { /* 非 JSON */ }
+      res({ code, json, out: out.trim(), err: err.trim() })
+    })
+  })
+}
+
+async function main() {
+  const opt = parseArgs(process.argv.slice(2))
+
+  // ── 写类 tool 硬拒绝（在任何子进程起来**之前**）────────────────────────────────
+  const refused = opt.tools.filter((t) => !READ_ONLY_TOOLS.has(t))
+  if (refused.length) {
+    console.error(`❌ 拒绝调用非只读 tool：${refused.join(', ')}`)
+    console.error(`   白名单（只读）：${[...READ_ONLY_TOOLS].join(', ')}`)
+    console.error('   ⛔ 本 PoC 的纪律是零副作用：写类 tool（含 *_shadow：会 cpSync 数据目录/造临时文件）一律不调。')
+    process.exit(2)
+  }
+  if (!opt.tools.length) { console.error('❌ --tools 不能为空'); process.exit(2) }
+
+  const env = { ...process.env }
+  if (opt.telemetryOff) env.ARGENT_TELEMETRY_OFF = '1'
+  const childEnvKeys = Object.keys(env).sort()
+
+  const report = {
+    host: { kind: 'mcp-stdio', client: CLIENT_INFO, hostIsDsh: false, node: process.version, argv: process.argv.slice(2) },
+    server: { path: present(opt.server, opt), exists: true, envKeys: childEnvKeys.length, telemetryOff: opt.telemetryOff },
+    checks: {},
+    readonlyTools: opt.tools,
+    verdict: { pass: false, reasons: [] },
+  }
+
+  try { readFileSync(opt.server) } catch (e) {
+    report.server.exists = false
+    report.verdict.reasons.push(`server 文件读不到：${e.message}`)
+    return finish(report, opt)
+  }
+
+  const c = connect({ serverPath: opt.server, env, timeoutMs: opt.timeoutMs })
+  try {
+    // ── 判据① initialize（protocolVersion / serverInfo / capabilities）────────────
+    const t0 = Date.now()
+    const init = await c.request('initialize', {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: { tools: {} },
+      clientInfo: CLIENT_INFO,
+    })
+    const ir = init.result || {}
+    report.checks.initialize = {
+      ok: Boolean(ir.serverInfo && ir.protocolVersion),
+      elapsedMs: Date.now() - t0,
+      protocolVersion: ir.protocolVersion || null,
+      serverInfo: ir.serverInfo || null,
+      capabilities: ir.capabilities || null,
+      error: init.error || null,
+    }
+    if (!report.checks.initialize.ok) report.verdict.reasons.push('① initialize 没回 serverInfo/protocolVersion')
+    c.notify('notifications/initialized', {})
+
+    // ── ping（协议活性；顺带证明"服务端在 listen"）────────────────────────────────
+    const ping = await c.request('ping', {})
+    report.checks.ping = { ok: ping.error === undefined, error: ping.error || null }
+
+    // ── 判据② tools/list（数量必须与冻结口径一致）────────────────────────────────
+    const tl = await c.request('tools/list', {})
+    const tools = tl.result?.tools || []
+    const names = tools.map((t) => t.name)
+    const countOk = opt.expectTools === 0 || tools.length === opt.expectTools
+    report.checks.toolsList = {
+      ok: Array.isArray(tl.result?.tools) && countOk,
+      count: tools.length,
+      expected: opt.expectTools || null,
+      names,
+      schemasPresent: tools.every((t) => t && t.inputSchema && typeof t.inputSchema === 'object'),
+      error: tl.error || null,
+    }
+    if (!Array.isArray(tl.result?.tools)) report.verdict.reasons.push('② tools/list 没有返回 tools 数组')
+    else if (!countOk) report.verdict.reasons.push(`② tools/list 数量 ${tools.length} ≠ 冻结口径 ${opt.expectTools}`)
+
+    // ── 判据③ 只读 tool 实调（逐个贴脱敏结果）────────────────────────────────────
+    report.checks.toolCalls = []
+    for (const name of opt.tools) {
+      const t1 = Date.now()
+      const msg = await c.request('tools/call', { name, arguments: DEFAULT_ARGS[name] || {} })
+      const un = unpack(msg)
+      const value = un.ok ? un.value : null
+      // 三层分开判（**不把"业务结论为否"当成"调用失败"** —— 那会把真实判定链误报成红）：
+      //   · callOk「调用真跑通」= RPC 没报错 ∧ handler 没标 isError ∧ 载荷结构化；
+      //   · degraded「能力降级」= 载荷自报 `python_unavailable` / `code:2`（**是**能力缺口，**算红**）；
+      //   · verdict：`ok`（业务判 true，或该 tool 本就没有 `ok` 字段——如 `argent_version` 只回事实）
+      //             / `judged`（业务显式判 false，如本机未装许可 ⇒ 判定链照样走通）/ `degraded` / `failed`。
+      const rpcOk = msg.error === undefined && msg.result !== undefined
+      const isError = msg.result?.isError === true
+      const shapeOk = un.ok && value !== null && typeof value === 'object'
+      const callOk = Boolean(rpcOk && !isError && shapeOk)
+      const degraded = shapeOk && (value.reason === 'python_unavailable' || value.code === 2)
+        ? redact({ reason: value.reason || null, code: value.code ?? null, error: clip(value.error || '', 200) })
+        : null
+      const verdict = !callOk ? 'failed' : (degraded ? 'degraded' : (value.ok === false ? 'judged' : 'ok'))
+      report.checks.toolCalls.push({
+        name,
+        ok: callOk && !degraded,          // 判据③ 只数「真跑通且没降级」的
+        callOk, verdict, rpcOk, isError, elapsedMs: Date.now() - t1,
+        result: value === null ? { parseError: un.parseError, text: clip(un.text || '') } : present(value, opt),
+        degraded,
+      })
+    }
+    const okCalls = report.checks.toolCalls.filter((x) => x.ok).length
+    const judgedCalls = report.checks.toolCalls.filter((x) => x.verdict === 'judged').length
+    report.checks.readonlyCalls = {
+      ok: okCalls >= 2,
+      okCount: okCalls,
+      judgedCount: judgedCalls,          // 其中"业务判否但判定链走通"的（**不是**失败）
+      total: report.checks.toolCalls.length,
+      required: 2,
+      degradedCount: report.checks.toolCalls.filter((x) => x.degraded).length,
+    }
+    if (okCalls < 2) report.verdict.reasons.push(`③ 只读 tool 真调成功 ${okCalls} 个（判据要求 ≥ 2）`)
+
+    // ── 判据④ 版本/能力可查（CLI 面；MCP 面的等价物 = `argent_version` tool）────────
+    if (opt.cli) {
+      const v = await runCli(['version', '--json'], { env, timeoutMs: opt.timeoutMs })
+      const h = await runCli(['--help', '--json'], { env, timeoutMs: opt.timeoutMs })
+      report.checks.cliCapability = {
+        ok: v.code === 0 && h.code === 0 && Boolean(h.json?.verbs),
+        version: { code: v.code, argent: v.json?.argent ?? null, raw: clip(v.out, 160) },
+        help: { code: h.code, verbs: (h.json?.verbs || []).map((x) => x.name ?? x), verbCount: (h.json?.verbs || []).length },
+      }
+      if (!report.checks.cliCapability.ok) report.verdict.reasons.push('④ 版本/能力查询（CLI --json）失败')
+    } else {
+      report.checks.cliCapability = { ok: true, skipped: true }
+    }
+  } catch (e) {
+    report.verdict.reasons.push(`RPC 层失败：${e.message}`)
+  } finally {
+    report.server.exitCode = await c.close()
+    report.server.stderrTail = clip(c.stderr().trim().slice(-400))
+  }
+
+  // ── 六项接口的**实测可达性**（PoC 判定；权威矩阵列见契约 §3，本块只记"这个宿主量到了什么"）
+  const entryOk = report.checks.toolsList?.ok === true && report.checks.readonlyCalls?.ok === true
+  const versionOk = report.checks.cliCapability?.ok === true
+  report.hostSurface = [
+    { face: '① 入口/工具暴露', status: entryOk ? '✅' : '❌', how: `initialize + tools/list(${report.checks.toolsList?.count ?? '?'}) + tools/call(成功 ${report.checks.readonlyCalls?.okCount ?? 0} 个只读)` },
+    { face: '② 设置面板', status: '—', why: 'stdio 宿主**无 UI**（设计性缺失）', substitute: `配置文件（数据目录下的 *.json/*.env）+ CLI 只读查询；宿主自己解析` },
+    { face: '③ 通知通道', status: '—', why: '本宿主无投递通道（设计性缺失）', substitute: 'CLI `notify` verb + `core/lib/notify/*`（宿主负责把事实转成自己的通道）' },
+    { face: '④ 会话/权限', status: '—', why: 'stdio 无会话概念、无权限 UI（设计性缺失）', substitute: '宿主进程自身的权限模型（本 PoC = 调用者的 uid/umask）' },
+    { face: '⑤ 后台/定时', status: '—', why: '宿主无 scheduler（设计性缺失）', substitute: '系统定时器（launchd/systemd）+ `scripts/flow-timers.sh`' },
+    { face: '⑥ 升级/版本', status: versionOk ? '✅' : '❌', how: `CLI \`version --json\`（${report.checks.cliCapability?.version?.argent ?? '?'}）+ \`--help --json\`（verb ${report.checks.cliCapability?.help?.verbCount ?? '?'}）+ MCP \`argent_version\`` },
+  ]
+
+  report.verdict.pass = report.verdict.reasons.length === 0
+  return finish(report, opt)
+}
+
+function finish(report, opt) {
+  if (opt.json) {
+    console.log(JSON.stringify(report, null, 2))
+  } else {
+    printHuman(report)
+  }
+  process.exit(report.verdict.pass ? 0 : 1)
+}
+
+function printHuman(r) {
+  const mark = (b) => (b ? '✅' : '❌')
+  console.log('\n【MCP 宿主 PoC】宿主 = 本脚本（极简 stdio JSON-RPC 客户端，**不是 dsh**）')
+  console.log(`  server = ${r.server.path}（node ${r.host.node}；子进程 env ${r.server.envKeys} 键；遥测 ${r.server.telemetryOff ? 'OFF' : 'ON⚠️'}）`)
+  const i = r.checks.initialize || {}
+  console.log(`\n  ① initialize ${mark(i.ok)} protocolVersion=${i.protocolVersion} serverInfo=${JSON.stringify(i.serverInfo)} capabilities=${JSON.stringify(i.capabilities)} (${i.elapsedMs}ms)`)
+  if (r.checks.ping) console.log(`     ping       ${mark(r.checks.ping.ok)}`)
+  const t = r.checks.toolsList || {}
+  console.log(`  ② tools/list ${mark(t.ok)} ${t.count} 个（冻结口径 ${t.expected ?? '—'}）inputSchema 齐备=${mark(t.schemasPresent)}`)
+  console.log(`     ${(t.names || []).join(', ')}`)
+  const rc = r.checks.readonlyCalls || {}
+  console.log(`  ③ 只读 tool 实调 ${mark(rc.ok)} 真跑通 ${rc.okCount}/${rc.total}（判据 ≥${rc.required}；其中"业务判否但判定链走通" ${rc.judgedCount ?? 0} 个；降级 ${rc.degradedCount ?? 0} 个）`)
+  const MARK = { ok: '✅', judged: '🟡', degraded: '🔴', failed: '❌' }
+  const NOTE = {
+    ok: '业务判 true',
+    judged: '业务判 false —— **判定链走通**（不是调用失败；本机真实状态）',
+    degraded: '能力降级（诚实诊断，非崩溃）',
+    failed: '调用失败',
+  }
+  for (const c of r.checks.toolCalls || []) {
+    console.log(`     · ${c.name.padEnd(24)} ${MARK[c.verdict] || '❓'} ${String(c.elapsedMs).padStart(5)}ms  ${NOTE[c.verdict] || ''}`)
+    console.log(`       ${clip(JSON.stringify(c.result), 220)}`)
+    if (c.degraded) console.log(`       ↳ reason=${c.degraded.reason} code=${c.degraded.code} ${clip(c.degraded.error || '', 140)}`)
+  }
+  const cc = r.checks.cliCapability || {}
+  console.log(`  ④ 版本/能力   ${mark(cc.ok)}${cc.skipped ? '（--no-cli 跳过）' : ` CLI version=${cc.version?.argent} ｜ --help --json verb ${cc.help?.verbCount} 个`}`)
+  console.log('\n  六项接口可达性（实测；权威口径见 docs/Argent-宿主适配契约.md §3 矩阵）')
+  for (const s of r.hostSurface || []) {
+    console.log(`     ${s.status} ${s.face}  ${s.how || `— ${s.why}`}`)
+    if (s.substitute) console.log(`        替代：${s.substitute}`)
+  }
+  console.log(`\n  结论：${r.verdict.pass ? '✅ PoC 判据全过' : `❌ 未过 —— ${r.verdict.reasons.join('；')}`}`)
+  console.log('  零副作用证明（外部判据）：跑前 `node scripts/check-test-env-safety.mjs --snapshot <f>`，跑后 `--verify <f>`\n')
+}
+
+main().catch((e) => {
+  console.error(`❌ ${e.message}`)
+  process.exit(2)
+})