@lqc123qwe/car-runtime 1.9.0 → 1.10.0

package/test/s13.spec.ts

@@ -1,117 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { resolvePackage, isWhitelisted, type RegistryConfig } from '../src/load/registry.ts'
-import { HOST_MAPPINGS } from '../src/host/mappings.ts'
-import { HostGateway } from '../src/host/hostGateway.ts'
-import { createRuntimeFacade } from '../src/host/facade.ts'
-import { deriveSessionId } from '../src/host/mappings.ts'
-
-// ==================== registry resolution（T-3/T-4 fail-closed 组合） ====================
-
-const enterprise: RegistryConfig = {
-  registries: [
-    { url: 'https://verdaccio.corp.local', priority: 1, signed: false },
-    { url: 'https://artifactory.corp.local/npm', priority: 2, signed: true },
-  ],
-  allowNpmFallback: false,
-  offline: false,
-}
-
-test('registry: resolution 四级顺序——② 白名单 priority 升序', () => {
-  const r = resolvePackage({ name: 'pkg', version: '1.0.0' }, enterprise)
-  assert.equal(r.source, 'registry')
-  assert.equal(r.url, 'https://verdaccio.corp.local')
-  assert.match(r.decisionId, /^RD-[0-9a-f]{16}$/)
-})
-
-test('registry: ① 显式源绑定命中 → 直连；未命中 → 硬失败不降级', () => {
-  const hit = resolvePackage({ name: 'pkg', version: '1.0.0', pinnedRegistry: 'https://artifactory.corp.local/npm' }, enterprise)
-  assert.equal(hit.source, 'registry')
-  assert.equal(hit.url, 'https://artifactory.corp.local/npm')
-  const miss = resolvePackage({ name: 'pkg', version: '1.0.0', pinnedRegistry: 'https://evil.example.com' }, enterprise)
-  assert.equal(miss.source, 'rejected')
-  assert.match(miss.detail, /硬失败不换源/)
-})
-
-test('registry: ③ 兜底可关——企业默认拒绝；④ 离线最高优先级', () => {
-  const empty: RegistryConfig = { registries: [], allowNpmFallback: false, offline: false }
-  const r = resolvePackage({ name: 'pkg', version: '1.0.0' }, empty)
-  assert.equal(r.source, 'rejected')
-  assert.match(r.detail, /白名单为空且兜底关闭/)
-  const open: RegistryConfig = { registries: [], allowNpmFallback: true, offline: false }
-  assert.equal(resolvePackage({ name: 'pkg', version: '1.0.0' }, open).source, 'npm-fallback')
-  const offline = resolvePackage({ name: 'pkg', version: '1.0.0', pinnedRegistry: 'https://artifactory.corp.local/npm' }, { ...enterprise, offline: true })
-  assert.equal(offline.source, 'rejected', '离线覆盖一切（含显式绑定）')
-})
-
-test('registry: 审计回调全量落盘（含拒绝决策）+ isWhitelisted', () => {
-  const audited: string[] = []
-  resolvePackage({ name: 'a', version: '1.0.0' }, enterprise, d => audited.push(d.kind))
-  resolvePackage({ name: 'b', version: '1.0.0', pinnedRegistry: 'https://evil' }, enterprise, d => audited.push(d.kind))
-  assert.equal(audited.length, 2)
-  assert.ok(auditsAllRegistry(audited))
-  function auditsAllRegistry(kinds: string[]) { return kinds.every(k => k === 'registry-resolution') }
-  assert.equal(isWhitelisted('https://verdaccio.corp.local', enterprise), true)
-  assert.equal(isWhitelisted('https://evil.example.com', enterprise), false)
-})
-
-// ==================== 双宿主契约测试：五类语义扩全（S11 v0 → S13 v1） ====================
-
-function setup() {
-  const profiles = new Map(HOST_MAPPINGS.map(h => [h.hostId, h]))
-  const facade = createRuntimeFacade({ profiles })
-  const gw = new HostGateway({ facade, audit: () => {} })
-  for (const h of HOST_MAPPINGS) gw.registerHost({ hostId: h.hostId, profile: h, transport: {} as never })
-  return gw
-}
-
-/** 五类语义 × 双宿主 fixture（契约测试数据源——host-mappings-v1 的行为化规约） */
-const FIVE_CLASSES = [
-  { semantic: 'user-input', cc: ['user_message', { content: 'hi' }], cx: ['input_item', { text: 'hi' }] },
-  { semantic: 'assistant-output', cc: ['assistant_message', { content: 'done' }], cx: ['agent_message', { message: 'done' }] },
-  { semantic: 'tool-call', cc: ['tool_use', { tool_name: 'fs', tool_call_id: 'c1' }], cx: ['function_call', { name: 'fs', call_id: 'c1' }] },
-  { semantic: 'tool-result', cc: ['tool_result', { tool_call_id: 'c1', status: 'ok' }], cx: ['function_call_output', { call_id: 'c1', status: 'ok' }] },
-  { semantic: 'turn-end', cc: ['turn_complete', { reason: 'completed' }], cx: ['task_complete', { reason: 'completed' }] },
-] as const
-
-test('契约测试 v1: 五类语义双宿主全链路投影等价（经 facade 落哈希链）', async () => {
-  const gw = setup()
-  const ccId = ((await gw.handle('claude-code', 'session_start', { hostSessionId: 'fx' })).result as { sessionId: string }).sessionId
-  const cxId = ((await gw.handle('codex', 'session_start', { hostSessionId: 'fx' })).result as { sessionId: string }).sessionId
-  await gw.handle('claude-code', 'session_turn', { sessionId: ccId, input: { events: FIVE_CLASSES.map(f => ({ hostEvent: f.cc[0], payload: f.cc[1] })) } })
-  await gw.handle('codex', 'session_turn', { sessionId: cxId, input: { events: FIVE_CLASSES.map(f => ({ hostEvent: f.cx[0], payload: f.cx[1] })) } })
-  const r1 = await gw.handle('claude-code', 'session_replay', { sessionId: ccId })
-  const r2 = await gw.handle('codex', 'session_replay', { sessionId: cxId })
-  const m1 = (r1.result as { messages: unknown[] }).messages
-  const m2 = (r2.result as { messages: unknown[] }).messages
-  assert.deepEqual(m1, m2, '五类语义投影逐字节一致')
-  assert.equal(m1.length, 4, 'user/assistant/toolCall(assistant)/toolResult 入投影；turnEnd 不入消息流')
-  // 两侧哈希链独立完整
-  const v1 = await gw.handle('claude-code', 'session_verify', { sessionId: ccId })
-  const v2 = await gw.handle('codex', 'session_verify', { sessionId: cxId })
-  assert.equal((v1.result as { ok: boolean }).ok, true)
-  assert.equal((v2.result as { ok: boolean }).ok, true)
-})
-
-test('契约测试 v1: 降级同步——未知宿主事件在两侧同构落 hostRaw', async () => {
-  const gw = setup()
-  const ccId = ((await gw.handle('claude-code', 'session_start', { hostSessionId: 'dg' })).result as { sessionId: string }).sessionId
-  const cxId = ((await gw.handle('codex', 'session_start', { hostSessionId: 'dg' })).result as { sessionId: string }).sessionId
-  await gw.handle('claude-code', 'session_turn', { sessionId: ccId, input: { events: [{ hostEvent: 'future_thing', payload: { p: 1 } }] } })
-  await gw.handle('codex', 'session_turn', { sessionId: cxId, input: { events: [{ hostEvent: 'future_thing', payload: { p: 1 } }] } })
-  const e1 = await gw.handle('claude-code', 'session_export', { sessionId: ccId })
-  const e2 = await gw.handle('codex', 'session_export', { sessionId: cxId })
-  for (const e of [e1, e2]) {
-    const jsonl = (e.result as { bundle: { files: { name: string; content: string }[] } }).bundle.files[0].content
-    assert.ok(jsonl.includes('"hostRaw"'), 'hostRaw 载体')
-    assert.ok(jsonl.includes('future_thing'), '原事件名留痕')
-  }
-})
-
-test('契约测试 v1: 会话隔离与确定性派生（同 hostSessionId 跨宿主独立）', async () => {
-  assert.notEqual(deriveSessionId('claude-code', 's'), deriveSessionId('codex', 's'))
-  const gw = setup()
-  const a = await gw.handle('claude-code', 'session_start', { hostSessionId: 'dup' })
-  const b = await gw.handle('claude-code', 'session_start', { hostSessionId: 'dup' })
-  assert.equal((a.result as { sessionId: string }).sessionId, (b.result as { sessionId: string }).sessionId, '同宿主幂等')
-})

package/test/s14.spec.ts

@@ -1,117 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { convergeBudget, PTC_BUDGET_BASELINE } from '../src/ptc/budget.ts'
-import { checkErasableOnly } from '../src/ptc/erasable.ts'
-import { runCode, makePtcToolDefinition, type ToolBridge } from '../src/ptc/runCode.ts'
-import { runTurn, type ModelStep, type ToolDef } from '../src/loop/stop.ts'
-import { SessionLog } from '../src/session/log.ts'
-
-// ==================== 预算收敛（只许下调） ====================
-
-test('PTC 预算: 基线对齐 dsh 一手口径（60s/600s/64MB）', () => {
-  assert.deepEqual(PTC_BUDGET_BASELINE, { computeMs: 60_000, maxWallMs: 600_000, maxOutputBytes: 64 * 1024 * 1024 })
-  const b = convergeBudget()
-  assert.deepEqual(b, { computeMs: 60_000, maxWallMs: 600_000, maxOutputBytes: 64 * 1024 * 1024 })
-})
-
-test('PTC 预算: 下调通过；上调 = CAR-E-BUDGET 显式报错（fail-closed）', () => {
-  const b = convergeBudget({ computeMs: 30_000, maxWallMs: 1000, maxOutputBytes: 1024 })
-  assert.deepEqual(b, { computeMs: 30_000, maxWallMs: 1000, maxOutputBytes: 1024 })
-  assert.throws(() => convergeBudget({ maxWallMs: 700_000 }), /只许下调/)
-  assert.throws(() => convergeBudget({ maxOutputBytes: 65 * 1024 * 1024 }), /CAR-E-BUDGET/)
-  assert.throws(() => convergeBudget({ computeMs: -1 }), /positive/)
-})
-
-// ==================== erasable-only 检查 ====================
-
-test('erasable: enum/namespace/参数属性/装饰器/import=require 全拒绝', () => {
-  const cases: Array<[string, string]> = [
-    ['enum 声明', 'enum Color { Red }\nreturn 1'],
-    ['namespace 声明', 'namespace Util {\n  export const x = 1\n}\nreturn 1'],
-    ['构造器参数属性', 'class A { constructor(private x: number) {} }\nreturn 1'],
-    ['import=require', "import fs = require('node:fs')\nreturn 1"],
-    ['装饰器', 'const y = Object()\n@Component()\nclass B {}\nreturn 1'],
-  ]
-  for (const [name, code] of cases) {
-    const r = checkErasableOnly(code)
-    assert.equal(r.ok, false, `${name} 应被拒绝`)
-    assert.match(r.violation!, /non-erasable/)
-  }
-  // 普通 erasable async 函数体通过
-  assert.equal(checkErasableOnly('const x: number = 1\nawait Promise.resolve()\nreturn x + 1').ok, true)
-})
-
-// ==================== runCode：worker 隔离 + 工具桥 + 预算 ====================
-
-function tools(): Map<string, ToolBridge> {
-  return new Map([
-    ['add', { run: async (a: unknown) => (a as { x: number; y: number }).x + (a as { x: number; y: number }).y }],
-  ])
-}
-
-test('runCode: code+description 双必填（description = 授权门人审凭据）', async () => {
-  const t = tools()
-  await assert.rejects(() => runCode({ code: '   ', description: 'd', toolCallId: 'p1', budget: { maxWallMs: 1000 } }, { tools: t }), /code is required/)
-  await assert.rejects(() => runCode({ code: 'return 1', description: '', toolCallId: 'p1', budget: { maxWallMs: 5000 } }, { tools: t }), /description is required/)
-})
-
-test('runCode: worker 执行程序体 return 值回传（每次新 worker）', async () => {
-  const r = await runCode({ code: 'const a = await tools.add({ x: 2, y: 3 })\nreturn { sum: a }', description: '两数相加验证工具桥', toolCallId: 'p2', budget: { maxWallMs: 10_000 } }, { tools: tools() })
-  assert.equal(r.ok, true, r.error)
-  assert.deepEqual(r.result, { sum: 5 })
-  assert.ok(r.wallMs < 10_000)
-})
-
-test('runCode: 未知工具调用 = 显式错误（不静默）', async () => {
-  const r = await runCode({ code: 'await tools.nope({})\nreturn 1', description: '未知工具调用路径验证', toolCallId: 'p3', budget: { maxWallMs: 5000 } }, { tools: tools() })
-  assert.equal(r.ok, false)
-  assert.match(r.error!, /unknown tool/)
-})
-
-test('runCode: maxWallMs 超限 = budget-exceeded 工具错误结果（不掐 turn 不抛异常）', async () => {
-  const r = await runCode({ code: 'while (true) { await new Promise(r => setTimeout(r, 10)) }\nreturn 1', description: '死循环预算护栏验证', toolCallId: 'p4', budget: { maxWallMs: 300 } }, { tools: tools() })
-  assert.equal(r.ok, false)
-  assert.equal(r.budgetExceeded, true)
-  assert.match(r.error!, /budget-exceeded \(maxWallMs=300\)/)
-})
-
-test('runCode: erasable 违规在入口拒绝（不产生 worker）', async () => {
-  await assert.rejects(() => runCode({ code: 'enum E { A }\nreturn 1', description: 'erasable 挂点验证', toolCallId: 'p5', budget: { maxWallMs: 1000 } }, { tools: tools() }), /CAR-E-PTC.*non-erasable/)
-})
-
-// ==================== 停止语义衔接（ADR-001：预算到期不掐 turn） ====================
-
-test('PTC × runTurn: 一等 ToolDefinition 强制 write；程序错误结果交回模型后 turn 正常收口', async () => {
-  const log = new SessionLog()
-  const ptc = makePtcToolDefinition({ tools: tools() })
-  assert.equal(ptc.declaredSideEffect, 'write') // containment 非安全边界 → 最高约束
-  const all = new Map<string, ToolDef>([['run_code', ptc as unknown as ToolDef]])
-  let n = 0
-  const r = await runTurn({
-    log, turnId: 'PTC', tools: all, preset: { mode: 'full' },
-    model: async (): Promise<ModelStep> => {
-      if (n++ === 0) return { stopReason: 'toolUse', toolCalls: [{ id: 'pc1', tool: 'run_code', args: { code: 'return await tools.add({ x: 20, y: 22 })', description: '求和演示' } }] }
-      return { stopReason: 'stop', text: 'sum is 42' }
-    },
-  })
-  assert.equal(r.reason, 'completed') // 预算语义外：正常收口
-  const call = log.events.find(e => e.kind === 'toolCall')
-  assert.ok(call, 'PTC 调用落哈希链（与其他工具同链路，无旁路）')
-})
-
-test('PTC × runTurn: 程序体抛错 = 工具错误结果交回模型（turn 不 interrupted/aborted）', async () => {
-  const log = new SessionLog()
-  const ptc = makePtcToolDefinition({ tools: tools() })
-  const all = new Map<string, ToolDef>([['run_code', ptc as unknown as ToolDef]])
-  let n = 0
-  const r = await runTurn({
-    log, turnId: 'PTC2', tools: all, preset: { mode: 'full' },
-    model: async (): Promise<ModelStep> => {
-      if (n++ === 0) return { stopReason: 'toolUse', toolCalls: [{ id: 'pc2', tool: 'run_code', args: { code: 'throw new Error("boom")', description: '错误路径验证' } }] }
-      return { stopReason: 'stop', text: 'handled' }
-    },
-  })
-  assert.equal(r.reason, 'completed') // 错误结果交回模型继续，六值枚举不被 PTC 扩展
-  const res = log.events.find(e => e.kind === 'toolResult') as { payload: { error?: string } } | undefined
-  assert.ok(res, 'toolResult 落链')
-})

package/test/s15.spec.ts

@@ -1,80 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { renderSdk, renderSdkFromRegistry } from '../src/ptc/sdk.ts'
-import { runCode, makePtcToolDefinition, type ToolBridge } from '../src/ptc/runCode.ts'
-
-// ==================== TS SDK 渲染（声明面 = 授权面） ====================
-
-test('SDK 渲染: 注册表快照 → system prompt TS 声明（非 .d.ts 文件）', () => {
-  const reg = new Map<string, ToolBridge & { description?: string; paramHint?: string }>([
-    ['add', { run: async () => {}, description: '两数相加', paramHint: 'args: { x: number; y: number }' }],
-    ['fs_read', { run: async () => {} }],
-  ])
-  const sdk = renderSdkFromRegistry(reg)
-  assert.ok(sdk.includes('declare const tools: {'))
-  assert.ok(sdk.includes('"add": (args: { x: number; y: number }) => Promise<unknown> // 两数相加'))
-  assert.ok(sdk.includes('"fs_read": (args: unknown) => Promise<unknown>'), '无 paramHint 落 unknown 形状')
-  // 空注册表 = 空声明面（授权面同步为空）
-  assert.ok(renderSdkFromRegistry(new Map()).includes('declare const tools: {\n};'))
-})
-
-test('SDK 渲染: 声明面/授权面一致性——同一 Map 快照两处消费', () => {
-  // 红线的可执行化：渲染函数只接受注册表自身（无独立声明通道），结构上不可能漂移
-  const reg = new Map<string, ToolBridge>([['only', { run: async () => {} }]])
-  const sdk = renderSdkFromRegistry(reg as never)
-  assert.ok(sdk.includes('"only"'))
-  assert.ok(!sdk.includes('"hidden"'), '未注册工具不可能出现在声明面')
-})
-
-// ==================== 授权门集成（authorizationId 幂等） ====================
-
-test('PTC 授权门: 拒绝 = 无 worker 启动 + ptc-denied 审计留痕', async () => {
-  const audits: Array<{ kind: string; authorizationId?: string }> = []
-  const r = await runCode(
-    { code: 'return 1', description: '拒绝路径验证', toolCallId: 'tc-42', budget: { maxWallMs: 1000 } },
-    { tools: new Map(), audit: d => audits.push(d as never), authorize: async () => false },
-  )
-  assert.equal(r.ok, false)
-  assert.match(r.error!, /authorization-denied/)
-  const denied = audits.find(a => a.kind === 'ptc-denied')
-  assert.ok(denied, '拒绝落审计')
-  assert.equal(denied!.authorizationId, 'ptc-tc-42', '幂等键 = ptc-+toolCallId')
-})
-
-test('PTC 授权门: 放行正常执行（authorize 回调看到 description 人审凭据）', async () => {
-  let seenDescription = ''
-  const r = await runCode(
-    { code: 'return 7', description: '求和放行', toolCallId: 'tc-43', budget: { maxWallMs: 5000 } },
-    { tools: new Map(), authorize: async req => { seenDescription = req.description; return true } },
-  )
-  assert.equal(r.ok, true)
-  assert.equal(r.result, 7)
-  assert.equal(seenDescription, '求和放行')
-})
-
-// ==================== secrets 出站覆盖（F12 × worker 输出） ====================
-
-test('F12 × PTC: worker 输出含 API Key → 回填上下文前强制脱敏', async () => {
-  const audits: Array<{ kind: string; hits?: number }> = []
-  const r = await runCode(
-    { code: 'return { note: "key is sk-proj-abcdefghij0123456789abcd keep it safe" }', description: '出站脱敏验证', toolCallId: 'tc-44', budget: { maxWallMs: 5000 } },
-    { tools: new Map(), audit: d => audits.push(d as never) },
-  )
-  assert.equal(r.ok, true)
-  assert.equal(r.secretsRedacted, 1)
-  assert.ok(!JSON.stringify(r.result).includes('sk-proj-abcdefghij0123456789abcd'), '明文不可见于返回结果')
-  assert.ok(JSON.stringify(r.result).includes('****'), '遮蔽格式生效')
-  assert.ok(audits.some(a => a.kind === 'ptc-secrets-redacted'), '脱敏事件落审计')
-})
-
-// ==================== registry × HostGateway tool 面（S12 留白接线） ====================
-
-test('registry × facade: tool_list/tool_call 接线（S12 留白补齐）', async () => {
-  // 直接验证 registry 判定与 facade tool 语义的分界已由 s13 覆盖；此处验证 makePtcToolDefinition 的
-  // audit 流与 registry decisionId 一样具备可落链结构（均为 {kind, ...payload} 纯数据）
-  const audits: Array<Record<string, unknown>> = []
-  const ptc = makePtcToolDefinition({ tools: new Map([['add', { run: async (a: unknown) => (a as { x: number }).x + 1 }]]), audit: d => audits.push(d) })
-  await ptc.run({ code: 'return await tools.add({ x: 41 })', description: '注册表快照执行' })
-  assert.ok(audits.every(a => typeof a.kind === 'string'), '审计事件结构化（可落哈希链）')
-  assert.equal(audits[0].kind, 'ptc-start')
-})

package/test/s16.spec.ts

@@ -1,133 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { jsonSchemaToTs } from '../src/ptc/schemaRender.ts'
-import { renderSdkFromRegistry } from '../src/ptc/sdk.ts'
-import { McpGateway, type ClientTransport, type JsonRpcRequest, type JsonRpcResponse } from '../src/mcp/gateway.ts'
-import type { ToolBridge } from '../src/ptc/runCode.ts'
-
-// ==================== jsonSchemaToTs：深度转换矩阵 ====================
-
-test('schema→TS: 基础标量 + integer 归一 + 可空联合', () => {
-  assert.equal(jsonSchemaToTs({ type: 'string' }), 'string')
-  assert.equal(jsonSchemaToTs({ type: 'integer' }), 'number')
-  assert.equal(jsonSchemaToTs({ type: ['string', 'null'] }), 'string | null')
-  assert.equal(jsonSchemaToTs({ type: 'boolean' }), 'boolean')
-})
-
-test('schema→TS: const/enum 字面量联合', () => {
-  assert.equal(jsonSchemaToTs({ const: 'fixed' }), '"fixed"')
-  assert.equal(jsonSchemaToTs({ enum: ['a', 'b', 3, true] }), '"a" | "b" | 3 | true')
-})
-
-test('schema→TS: 嵌套 object（required 必填 / 缺省可选 ?）', () => {
-  const ts = jsonSchemaToTs({
-    type: 'object',
-    properties: {
-      path: { type: 'string' },
-      encoding: { type: 'string', enum: ['utf8', 'gbk'] },
-      depth: { type: 'integer' },
-    },
-    required: ['path'],
-  })
-  assert.equal(ts, '{ path: string; encoding?: "utf8" | "gbk"; depth?: number }')
-})
-
-test('schema→TS: 数组 / 元组(prefixItems) / Record(additionalProperties)', () => {
-  assert.equal(jsonSchemaToTs({ type: 'array', items: { type: 'number' } }), 'number[]')
-  assert.equal(jsonSchemaToTs({ type: 'array', prefixItems: [{ type: 'string' }, { type: 'number' }] }), '[string, number]')
-  assert.equal(jsonSchemaToTs({ type: 'object', additionalProperties: { type: 'string' } }), '{ [k: string]: string }')
-  assert.equal(jsonSchemaToTs({ type: 'object' }), 'Record<string, unknown>')
-})
-
-test('schema→TS: 深层嵌套对象递归', () => {
-  const ts = jsonSchemaToTs({
-    type: 'object',
-    properties: {
-      filter: {
-        type: 'object',
-        properties: { tags: { type: 'array', items: { type: 'string' } } },
-        required: ['tags'],
-      },
-    },
-    required: ['filter'],
-  })
-  assert.equal(ts, '{ filter: { tags: string[] } }')
-})
-
-test('schema→TS: 组合器 anyOf 联合 / allOf 交叉', () => {
-  assert.equal(jsonSchemaToTs({ anyOf: [{ type: 'string' }, { type: 'number' }] }), 'string | number')
-  assert.equal(jsonSchemaToTs({ allOf: [{ type: 'object', properties: { a: { type: 'string' } } }, { type: 'object', properties: { b: { type: 'number' } } }] }),
-    '{ a?: string } & { b?: number }')
-})
-
-test('schema→TS: fail-visible——$ref/not/畸形/超深落 unknown 且带原因标记（零静默）', () => {
-  assert.equal(jsonSchemaToTs({ $ref: '#/$defs/x' }), 'unknown /* unsupported:$ref */')
-  assert.equal(jsonSchemaToTs({ not: { type: 'string' } }), 'unknown /* unsupported:not */')
-  assert.equal(jsonSchemaToTs(null), 'unknown /* malformed */')
-  assert.equal(jsonSchemaToTs('garbage'), 'unknown /* malformed */')
-  // 超深递归：MAX_DEPTH=6，第 8 层触发标记
-  let deep: Record<string, unknown> = { type: 'string' }
-  for (let i = 0; i < 8; i++) deep = { type: 'object', properties: { nest: deep }, required: ['nest'] }
-  const ts = jsonSchemaToTs(deep)
-  assert.ok(ts.includes('unknown /* depth>6 */'), '超深节点带标记: ' + ts.slice(-60))
-})
-
-// ==================== SDK 渲染集成（优先级 + 一致性红线不回退） ====================
-
-test('SDK 渲染: inputSchema 深度转换生效；paramHint 手写声明优先；无声明落 unknown', () => {
-  const reg = new Map<string, ToolBridge & { description?: string; paramHint?: string; inputSchema?: unknown }>([
-    ['fs_read', { run: async () => {}, inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] } }],
-    ['fs_write', { run: async () => {}, paramHint: 'args: { data: string }', inputSchema: { type: 'object' } }],
-    ['legacy', { run: async () => {} }],
-  ])
-  const sdk = renderSdkFromRegistry(reg)
-  assert.ok(sdk.includes('"fs_read": ({ path: string }) => Promise<unknown>'), 'inputSchema 深渲生效')
-  assert.ok(sdk.includes('"fs_write": (args: { data: string }) => Promise<unknown>'), 'paramHint 优先于 inputSchema')
-  assert.ok(sdk.includes('"legacy": (args: unknown) => Promise<unknown>'), '无声明落 unknown（fail-visible 默认不变）')
-})
-
-test('SDK 渲染: inputSchema 深渲中 fail-visible 标记直接进声明面（模型可见）', () => {
-  const reg = new Map<string, ToolBridge & { inputSchema?: unknown }>([
-    ['ref_tool', { run: async () => {}, inputSchema: { type: 'object', properties: { cfg: { $ref: '#/$defs/Config' } } } }],
-  ])
-  const sdk = renderSdkFromRegistry(reg)
-  assert.ok(sdk.includes('cfg?: unknown /* unsupported:$ref */'), '不可判定路径模型可见（不静默截断）')
-})
-
-// ==================== McpGateway inputSchema 捕获（DEC-4 消费源接线） ====================
-
-function schemaTransport(): ClientTransport {
-  return {
-    async send(req: JsonRpcRequest): Promise<JsonRpcResponse> {
-      if (req.method === 'tools/list') {
-        return {
-          jsonrpc: '2.0', id: req.id,
-          result: { tools: [
-            {
-              name: 'ts_query', description: 'deep schema tool', sideEffect: 'readonly',
-              inputSchema: {
-                type: 'object',
-                properties: { q: { type: 'string' }, limit: { type: 'integer' }, tags: { type: 'array', items: { type: 'string' } } },
-                required: ['q'],
-              },
-            },
-            { name: 'ts_plain' },
-          ] },
-        }
-      }
-      throw new Error('unknown method ' + req.method)
-    },
-    alive() { return true },
-    close() {},
-  }
-}
-
-test('McpGateway: tools/list inputSchema 原样捕获进能力矩阵（不丢弃）', async () => {
-  const gw = new McpGateway()
-  await gw.register({ serverId: 'ts1', transport: schemaTransport() })
-  const matrix = gw.listTools()
-  const q = matrix.find(t => t.name === 'ts_query')!
-  assert.ok(q.inputSchema && typeof q.inputSchema === 'object', 'inputSchema 已捕获')
-  const plain = matrix.find(t => t.name === 'ts_plain')!
-  assert.equal(plain.inputSchema, undefined, '未声明 inputSchema 保持 undefined（渲染层落 unknown）')
-})

package/test/s17.spec.ts

@@ -1,102 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { resolvePackage, resolveCandidateChain, type RegistryConfig, type ExcludedSource } from '../src/load/registry.ts'
-import { enforceSignature } from '../src/load/verifier.ts'
-import { createCounters, assertZeroContent } from '../src/telemetry/metrics.ts'
-
-const corp: RegistryConfig = {
-  registries: [
-    { url: 'https://a.corp.local', priority: 1, signed: true },
-    { url: 'https://b.corp.local', priority: 2, signed: false },
-    { url: 'https://c.corp.local', priority: 3, signed: false },
-  ],
-  allowNpmFallback: true,
-  offline: false,
-}
-
-// ==================== T-5 定稿②：exclude 通道（类型上禁校验失败换源） ====================
-
-test('registry exclude: 网络失败源被跳过，按 priority 继续下一源', () => {
-  const exclude: ExcludedSource[] = [{ url: 'https://a.corp.local', reason: 'network' }]
-  const r = resolvePackage({ name: 'pkg', version: '1.0.0' }, corp, undefined, { exclude })
-  assert.equal(r.source, 'registry')
-  assert.equal(r.url, 'https://b.corp.local')
-  assert.match(r.detail, /excluded=1/)
-})
-
-test('registry exclude: 候选耗尽 → 兜底（T-5 定稿②修正语义：非「白名单为空」）', () => {
-  const exclude: ExcludedSource[] = corp.registries.map(r => ({ url: r.url, reason: 'network' as const }))
-  const r = resolvePackage({ name: 'pkg', version: '1.0.0' }, corp, undefined, { exclude })
-  assert.equal(r.source, 'npm-fallback')
-  assert.match(r.detail, /candidates exhausted/)
-  // 兜底关闭 → 候选耗尽 = fail-closed 拒绝
-  const closed = resolvePackage({ name: 'pkg', version: '1.0.0' }, { ...corp, allowNpmFallback: false }, undefined, { exclude })
-  assert.equal(closed.source, 'rejected')
-  assert.match(closed.detail, /候选耗尽且兜底关闭/)
-})
-
-test('registry exclude: 显式绑定源网络失败 → 落审计后按 priority 继续（T-5 ②网络路径）', () => {
-  const audits: string[] = []
-  const r = resolvePackage(
-    { name: 'pkg', version: '1.0.0', pinnedRegistry: 'https://a.corp.local' }, corp,
-    d => audits.push(String((d as { detail: string }).detail)),
-    { exclude: [{ url: 'https://a.corp.local', reason: 'network' }] },
-  )
-  assert.equal(r.source, 'registry')
-  assert.equal(r.url, 'https://b.corp.local', 'pinned 网络失败 ≠ 信任否定，继续剩余白名单')
-  assert.equal(audits.length, 1)
-})
-
-test('registry exclude: 显式绑定不在白名单 = 硬失败不换源（既有语义保持）', () => {
-  const r = resolvePackage({ name: 'pkg', version: '1.0.0', pinnedRegistry: 'https://evil.example.com' }, corp)
-  assert.equal(r.source, 'rejected')
-})
-
-test('registry: resolveCandidateChain 只读预览（零审计副作用）', () => {
-  const audits: unknown[] = []
-  const c = resolveCandidateChain(corp)
-  assert.deepEqual(c.chain, ['https://a.corp.local', 'https://b.corp.local', 'https://c.corp.local'])
-  assert.equal(c.fallback, true)
-  assert.equal(audits.length, 0)
-})
-
-// ==================== S17 采集面（零内容计数器） ====================
-
-test('telemetry: 3 Counter 零内容——snapshot 仅枚举 labels，无内容字段', () => {
-  const c = createCounters()
-  c.onCount('car_load_total', { result: 'ok' })
-  c.onCount('car_load_total', { result: 'ok' })
-  c.onCount('car_load_total', { result: 'failed' })
-  c.onCount('car_unsigned_confirmed', { confirmed: 'no' })
-  c.onCount('car_registry_decision', { source: 'registry' })
-  const snap = c.snapshot()
-  assert.deepEqual(snap, {
-    'car_load_total|result=ok': 2,
-    'car_load_total|result=failed': 1,
-    'car_unsigned_confirmed|confirmed=no': 1,
-    'car_registry_decision|source=registry': 1,
-  })
-  assert.equal(assertZeroContent(snap), true, '零内容红线（无 sk-/路径/长串）')
-})
-
-test('telemetry: Q-08 兼容——未接遥测时仅进程内累计（无出站面）', () => {
-  const c = createCounters()
-  c.onCount('car_registry_decision', { source: 'npm-fallback' })
-  // snapshot 即登记表人工填报兜底通道数据源；本层无任何出站调用面
-  assert.ok(Object.keys(c.snapshot()).length === 1)
-})
-
-// ==================== verifier × 采集面（unsigned warn 计数） ====================
-
-test('verifier onCount: unsigned warn 路径计数（confirmed=no）；enforce 路径不产生 unsigned 计数', () => {
-  const c = createCounters()
-  const deps = { mode: 'warn' as const, trustRootPublicKey: 'x' }
-  const r = enforceSignature('hash-abc', undefined, deps, (n, l) => c.onCount(n, l))
-  assert.equal(r.allowed, true)
-  assert.ok(r.warning)
-  assert.equal(c.snapshot()['car_unsigned_confirmed|confirmed=no'], 1)
-  // enforce 模式：缺失 = 拒绝（无 unsigned 计数——不是放行路径）
-  const r2 = enforceSignature('hash-abc', undefined, { ...deps, mode: 'enforce' }, (n, l) => c.onCount(n, l))
-  assert.equal(r2.allowed, false)
-  assert.equal(c.snapshot()['car_unsigned_confirmed|confirmed=no'], 1, '计数不增（拒绝路径非放行路径）')
-})

package/test/s18.spec.ts

@@ -1,81 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawn } from 'node:child_process'
-import { join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const CLI = join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'cli.ts')
-
-/** 真实子进程 stdio 对话（E-6 预演：非 PassThrough 模拟，是 spawn 进程级验证） */
-function talk(host: string, requests: string[]): Promise<{ outs: any[]; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, ['--experimental-transform-types', CLI, 'mcp-serve', '--host', host], { stdio: ['pipe', 'pipe', 'pipe'] })
-    let out = ''
-    let err = ''
-    child.stdout.on('data', d => { out += d })
-    child.stderr.on('data', d => { err += d })
-    child.on('error', reject)
-    child.on('exit', () => {
-      try { resolve({ outs: out.split('\n').filter(Boolean).map(l => JSON.parse(l)), stderr: err }) } catch (e) { reject(e) }
-    })
-    for (const r of requests) child.stdin.write(r + '\n')
-    child.stdin.end()
-  })
-}
-
-test('S18: mcp-serve 真实进程——tools/list + session_start + turn + verify 全链路', async () => {
-  const { outs } = await talk('claude-code', [
-    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' }),
-    JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 'cc-e2e' } } }),
-  ])
-  assert.equal(outs[0].result.tools.length, 10)
-  const sid = JSON.parse(outs[1].result.content[0].text).sessionId
-  assert.match(sid, /^SH-[0-9a-f]{24}$/)
-
-  // 同一进程第二轮（另起进程验证幂等派生一致性）
-  const { outs: outs2 } = await talk('claude-code', [
-    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 'cc-e2e' } } }),
-  ])
-  assert.equal(JSON.parse(outs2[0].result.content[0].text).sessionId, sid, '跨进程确定性派生（幂等）')
-})
-
-test('S18: 采集窗口——会话结束 stderr 输出零内容快照（登记表兜底通道实化）', async () => {
-  const { stderr } = await talk('claude-code', [
-    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 's' } } }),
-    JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'session_turn', arguments: { sessionId: 'SH-nonexistent', input: { events: [] } } } }),
-  ])
-  assert.match(stderr, /\[car mcp-serve\].*snapshot=/)
-  assert.match(stderr, /zeroContent=true/, '零内容红线自检通过')
-  const snap = JSON.parse(/snapshot=(\{.*?\}) zeroContent/.exec(stderr)![1])
-  assert.ok('car_registry_decision|source=registry' in snap)
-})
-
-test('S18+: 1.1-S4 边界——未指定 --plugin 时装载计数不出现（装载接线不改变缺省协议面与快照键集）', async () => {
-  const { stderr } = await talk('claude-code', [
-    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 's' } } }),
-  ])
-  const snap = JSON.parse(/snapshot=(\{.*?\}) zeroContent/.exec(stderr)![1])
-  assert.ok(!('car_load_total|result=ok' in snap), '无 --plugin = 无装载计数（1.1 装载接线为显式 opt-in）')
-  assert.ok(!('car_unsigned_confirmed|confirmed=no' in snap))
-})
-
-test('S18: codex 宿主接入（同一入口不同 hostId）', async () => {
-  const { outs } = await talk('codex', [
-    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 'cx-e2e' } } }),
-  ])
-  const sid = JSON.parse(outs[0].result.content[0].text).sessionId
-  assert.match(sid, /^SH-[0-9a-f]{24}$/)
-  const cc = await talk('claude-code', [
-    JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 'cx-e2e' } } }),
-  ])
-  assert.notEqual(JSON.parse(cc.outs[0].result.content[0].text).sessionId, sid, '跨宿主隔离经真实进程验证')
-})
-
-test('S18: 未知 hostId 显式拒绝（exit 2）', async () => {
-  const code = await new Promise<number>(resolve => {
-    const child = spawn(process.execPath, ['--experimental-transform-types', CLI, 'mcp-serve', '--host', 'unknown-host'])
-    child.on('exit', c => resolve(c ?? -1))
-    child.stdin.end()
-  })
-  assert.equal(code, 2)
-})