@lqc123qwe/car-runtime 1.9.0 → 1.11.0

package/test/s37-projection-dedupe.spec.ts

@@ -1,161 +0,0 @@
-/**
- * 1.6-S1 · 投影收敛（S37）：deriveMessages 同 id toolResult last-wins（D-23）
- *
- * 覆盖：
- *  - runTurn confirm 全链：写类工具 granted 流——事件面两条 toolResult（runtime 授权 + plugin 执行，
- *    M4 既有语义不动 = 审计全量留痕），投影单条且内容 = 执行结果；N1 快照一致性由构造保持
- *  - denied 流：授权拒绝单条保留（唯一结果，原样投影）
- *  - readonly 工具：单 plugin toolResult（无收敛对象——回归）
- *  - id 缺席不收敛：无 id 载荷原样投影（golden ④ 投影语义兼容）；id 与无 id 混存互不影响
- *  - 适配器出站体（1.6-GO-5 生产调用点核查）：收敛投影经 openai-compat / anthropic 双适配器
- *    出站体无重复 tool 消息 / tool_result 块（真实 provider 重复 id 拒绝面出清）
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { SessionLog } from '../src/session/log.ts'
-import { runTurn, type ModelStep } from '../src/loop/stop.ts'
-import { createOpenAICompatAdapter, createAnthropicAdapter } from '../src/runtime-core/llm.ts'
-
-const dataLine = (obj: unknown) => `data: ${JSON.stringify(obj)}\n\n`
-const openaiSse = (finish: string) =>
-  dataLine({ choices: [{ delta: {}, finish_reason: finish }] }) + 'data: [DONE]\n\n'
-const sseResponse = (text: string) => {
-  const enc = new TextEncoder()
-  return new Response(new ReadableStream<Uint8Array>({ start(c) { c.enqueue(enc.encode(text)); c.close() } }),
-    { status: 200, headers: { 'content-type': 'text/event-stream' } })
-}
-const anthropicSse = (events: object[]) => events.map(dataLine).join('')
-const ANTHROPIC_STOP = [
-  { type: 'message_start', message: { role: 'assistant' } },
-  { type: 'message_delta', delta: { stop_reason: 'end_turn' } },
-  { type: 'message_stop' },
-]
-
-/** chatStep 消息映射同款复刻（deriveMessages → LlmRequest.messages 的唯一路径） */
-function toLlmMessages(log: SessionLog) {
-  return log.deriveMessages().map(m => ({
-    role: m.role as 'system' | 'user' | 'assistant' | 'toolResult',
-    content: (m as unknown as { toolCall?: unknown }).toolCall !== undefined
-      ? { toolCall: (m as unknown as { toolCall: unknown }).toolCall }
-      : m.content,
-  }))
-}
-
-test('S37: 写类工具 granted 流——事件面两条 toolResult（M4 语义不动），投影单条且为执行结果 + N1 一致', async () => {
-  const log = new SessionLog('s37-granted')
-  const steps: ModelStep[] = [
-    { stopReason: 'toolUse', toolCalls: [{ id: 'tc1', tool: 'save_note', args: { text: 'hi' } }] },
-    { stopReason: 'stop' },
-  ]
-  const r = await runTurn({
-    log, turnId: 'T1',
-    model: async () => steps.shift()!,
-    tools: new Map([['save_note', { declaredSideEffect: 'write', run: async () => '已保存' }]]),
-    preset: { mode: 'confirm', authorize: async () => true },
-  })
-  assert.equal(r.reason, 'completed')
-  // 事件面不动：授权决策（runtime）+ 执行结果（plugin）两条都落链（审计全量留痕）
-  const resultEvents = log.events.filter(e => e.kind === 'toolResult')
-  assert.equal(resultEvents.length, 2, 'M4 既有语义冻结：runtime 授权记录 + plugin 执行结果均落链')
-  assert.equal(resultEvents[0]!.actor, 'runtime')
-  assert.equal(resultEvents[1]!.actor, 'plugin')
-  // 投影收敛：同 id last-wins，模型可见流单条且为执行结果
-  const proj = log.deriveMessages().filter(m => m.role === 'toolResult')
-  assert.equal(proj.length, 1, 'D-23：授权中间记录不再进模型可见流')
-  assert.deepEqual(proj[0]!.content, { id: 'tc1', result: '已保存' })
-  // N1 快照一致性（runTurn 每步 snapshotModelRequest；收敛激活下重算同函数构造一致）
-  assert.deepEqual(log.assertModelVisibleLogged(), { ok: true })
-})
-
-test('S37: denied 流——授权拒绝单条保留（唯一结果原样投影）', async () => {
-  const log = new SessionLog('s37-denied')
-  const steps: ModelStep[] = [
-    { stopReason: 'toolUse', toolCalls: [{ id: 'tc2', tool: 'save_note', args: {} } ] },
-    { stopReason: 'stop' },
-  ]
-  await runTurn({
-    log, turnId: 'T1',
-    model: async () => steps.shift()!,
-    tools: new Map([['save_note', { declaredSideEffect: 'write', run: async () => '不应执行' }]]),
-    preset: { mode: 'confirm', authorize: async () => false },
-  })
-  assert.equal(log.events.filter(e => e.kind === 'toolResult').length, 1, '拒绝即终态：仅 runtime 授权拒绝事件')
-  const proj = log.deriveMessages().filter(m => m.role === 'toolResult')
-  assert.equal(proj.length, 1, '唯一结果原样保留（不误收敛）')
-  assert.equal((proj[0]!.content as { error?: string }).error, 'authorization-denied')
-})
-
-test('S37: readonly 工具单条 toolResult 无收敛对象（回归）', async () => {
-  const log = new SessionLog('s37-readonly')
-  const steps: ModelStep[] = [
-    { stopReason: 'toolUse', toolCalls: [{ id: 'tc3', tool: 'echo', args: {} }] },
-    { stopReason: 'stop' },
-  ]
-  await runTurn({
-    log, turnId: 'T1',
-    model: async () => steps.shift()!,
-    tools: new Map([['echo', { declaredSideEffect: 'readonly', run: async () => 'pong' }]]),
-    preset: { mode: 'readonly' },
-  })
-  assert.equal(log.events.filter(e => e.kind === 'toolResult').length, 1)
-  const proj = log.deriveMessages().filter(m => m.role === 'toolResult')
-  assert.equal(proj.length, 1)
-  assert.deepEqual(proj[0]!.content, { id: 'tc3', result: 'pong' })
-})
-
-test('S37: id 缺席不收敛——无 id 载荷原样投影（golden ④ 兼容），id 与无 id 混存互不影响', () => {
-  const log = new SessionLog('s37-idless')
-  log.append('runtime', 'toolResult', 'T1', { ok: 1 })
-  log.append('runtime', 'toolResult', 'T1', { ok: 2 })
-  log.append('plugin', 'toolResult', 'T1', { id: 'tc9', error: 'authorization-denied', granted: true })
-  log.append('plugin', 'toolResult', 'T1', { id: 'tc9', result: 'final' })
-  const proj = log.deriveMessages().filter(m => m.role === 'toolResult')
-  assert.equal(proj.length, 3, '无 id 两条原样保留 + 同 id 收敛为最后一条')
-  assert.deepEqual(proj[0]!.content, { ok: 1 })
-  assert.deepEqual(proj[1]!.content, { ok: 2 })
-  assert.deepEqual(proj[2]!.content, { id: 'tc9', result: 'final' })
-  // 前缀投影（upTo）语义：前缀内 last-wins 独立成立
-  const half = log.deriveMessages(3).filter(m => m.role === 'toolResult')
-  assert.equal(half.length, 3, '前缀 [0,3)：无 id 两条 + tc9 授权记录（前缀内 tc9 授权记录即终态）')
-  assert.deepEqual(half[2]!.content, { id: 'tc9', error: 'authorization-denied', granted: true })
-})
-
-test('S37: openai-compat 出站体——收敛后单 tool 消息（重复 tool_call_id 出清）', async () => {
-  const log = new SessionLog('s37-openai')
-  log.append('user', 'user', 'T1', '查天气')
-  log.append('model', 'toolCall', 'T1', { id: 'tc1', tool: 'weather', args: { city: '北京' } })
-  log.append('runtime', 'toolResult', 'T1', { id: 'tc1', error: 'authorization-denied', granted: true, mode: 'confirm' })
-  log.append('plugin', 'toolResult', 'T1', { id: 'tc1', result: '晴 25 度' })
-  const seen: RequestInit[] = []
-  const adapter = createOpenAICompatAdapter({
-    baseUrl: 'https://api.test',
-    fetchImpl: (async (_u: string | URL, init?: RequestInit) => { seen.push(init!); return sseResponse(openaiSse('stop')) }) as typeof fetch,
-  })
-  for await (const _ of adapter.chat({ model: 'm', messages: toLlmMessages(log), tools: [] })) void _
-  const body = JSON.parse(seen[0]!.body as string)
-  const toolMsgs = body.messages.filter((m: { role: string }) => m.role === 'tool')
-  assert.equal(toolMsgs.length, 1, '1.6-GO-5：出站体单 tool 消息（收敛前为两条）')
-  assert.equal(toolMsgs[0].tool_call_id, 'tc1')
-  assert.equal(toolMsgs[0].content, JSON.stringify('晴 25 度'), '内容 = 执行结果（非授权中间记录）')
-})
-
-test('S37: anthropic 出站体——收敛后单 tool_result 块（重复 tool_use_id 400 面出清）', async () => {
-  const log = new SessionLog('s37-anthropic')
-  log.append('user', 'user', 'T1', '查天气')
-  log.append('model', 'toolCall', 'T1', { id: 'toolu_1', tool: 'weather', args: { city: '北京' } })
-  log.append('runtime', 'toolResult', 'T1', { id: 'toolu_1', error: 'authorization-denied', granted: true, mode: 'confirm' })
-  log.append('plugin', 'toolResult', 'T1', { id: 'toolu_1', result: '晴 25 度' })
-  const seen: RequestInit[] = []
-  const adapter = createAnthropicAdapter({
-    baseUrl: 'https://api.test',
-    fetchImpl: (async (_u: string | URL, init?: RequestInit) => { seen.push(init!); return sseResponse(anthropicSse(ANTHROPIC_STOP)) }) as typeof fetch,
-  })
-  for await (const _ of adapter.chat({ model: 'm', messages: toLlmMessages(log), tools: [] })) void _
-  const body = JSON.parse(seen[0]!.body as string)
-  const blocks = body.messages.flatMap((m: { content: unknown }) =>
-    Array.isArray(m.content) ? m.content : []).filter((b: { type: string }) => b.type === 'tool_result')
-  assert.equal(blocks.length, 1, '1.6-GO-5：出站体单 tool_result 块（重复 tool_use_id 会被 provider 400）')
-  assert.equal(blocks[0].tool_use_id, 'toolu_1')
-  assert.equal(blocks[0].content, JSON.stringify('晴 25 度'))
-  assert.ok(!('is_error' in blocks[0]), '执行结果非错误形态')
-})

package/test/s38-config-jiti.spec.ts

@@ -1,116 +0,0 @@
-/**
- * 1.6-S3 · jiti 载体（S38）：car.config.ts 经 jiti 自包含转译（D-24）
- *
- * 覆盖：
- *  - 非可擦除语法（enum）真载——1.5 D-22 原生类型剥离不可表达的 transform-only 形态，
- *    erasable-only 预检登记项随之出清（被取代）
- *  - strip-only spawn 差分（1.6-GO-5 生产调用点）：`--experimental-strip-types`（无 transform）
- *    下 enum 配置经 jiti 真载成功 + 原生 import 同文件失败（负控——证明语法确属非可擦除、
- *    jiti 是载体）；同进程实测首载时延（登记口径，无硬门禁，CI 宽上界防抖）
- *  - CLI 真路径：car run 于 enum 配置目录——配置经 jiti 装载生效（CAR-E-LLM-CONFIG 引导 =
- *    配置解析通过、模型未配；若配置载体失败应为 CAR-E-CONFIG）
- *  - s35 存量零改动全量回归 = 载体迁移验收线（interoptDefault 显式关：jiti 缺省 true 会把
- *    无 default 模块的 exports 整体当 default，「缺 default export」校验即失效）
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawn } from 'node:child_process'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, dirname } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-import { warmCarConfig, loadCarConfig } from '../src/load/config.ts'
-
-const CLI = join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'cli.ts')
-const SRC_CONFIG = join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'load', 'config.ts')
-
-function withTempDir(name: string, fn: (dir: string) => Promise<void> | void): Promise<void> {
-  const dir = mkdtempSync(join(tmpdir(), `car-s38-${name}-`))
-  try {
-    const r = fn(dir)
-    const cleanup = () => { try { rmSync(dir, { recursive: true, force: true }) } catch { /* 红线 8 */ } }
-    if (r instanceof Promise) return r.finally(cleanup)
-    cleanup()
-    return Promise.resolve()
-  } catch (e) {
-    try { rmSync(dir, { recursive: true, force: true }) } catch { /* 红线 8 */ }
-    throw e
-  }
-}
-
-test('S38: 非可擦除语法（enum）经 jiti 真载——D-22 原生类型剥离不可表达形态', async () => {
-  await withTempDir('enum', async dir => {
-    writeFileSync(join(dir, 'car.config.ts'), [
-      `export enum LlmMode { full = 'full-model' }`,
-      `export default { llm: { model: LlmMode.full } }`,
-    ].join('\n'))
-    await warmCarConfig({ cwd: dir })
-    const r = loadCarConfig({ cwd: dir })
-    assert.equal(r.error, undefined)
-    assert.equal(r.config.llm?.model, 'full-model', 'enum 值经 jiti 转译进配置')
-  })
-})
-
-test('S38: strip-only spawn 差分——原生 import enum 载体失败（负控）+ jiti 真载成功 + 首载时延实测', async () => {
-  await withTempDir('strip', async dir => {
-    const configPath = join(dir, 'car.config.ts')
-    writeFileSync(configPath, [
-      `export enum LlmMode { full = 'strip-model' }`,
-      `export default { llm: { model: LlmMode.full } }`,
-    ].join('\n'))
-    // 夹具自身仅可擦除语法（strip-only 可载）；非可擦除只出现在被测配置里
-    const fixture = join(dir, 'fixture.ts')
-    writeFileSync(fixture, [
-      `import { warmCarConfig, loadCarConfig } from ${JSON.stringify(pathToFileURL(SRC_CONFIG).href)}`,
-      `import { pathToFileURL as toURL } from 'node:url'`,
-      `const configPath = process.argv[2]!`,
-      `let nativeError = ''`,
-      `try { await import(toURL(configPath).href) } catch (e) { nativeError = String((e as Error).message) }`,
-      `if (!nativeError) { console.log('NATIVE_UNEXPECTEDLY_OK'); process.exit(1) }`,
-      `const t0 = performance.now()`,
-      `await warmCarConfig({ explicitPath: configPath })`,
-      `const elapsed = Math.round(performance.now() - t0)`,
-      `const r = loadCarConfig({ explicitPath: configPath })`,
-      `if (r.error) { console.log('JITI_FAIL ' + r.error); process.exit(1) }`,
-      `console.log('OK model=' + r.config.llm?.model + ' firstLoadMs=' + elapsed + ' nativeRejected=' + nativeError.slice(0, 60).replace(/\\n/g, ' '))`,
-    ].join('\n'))
-    // --experimental-strip-types：仅类型剥离无转译（22.19+ 可用；enum 属 transform-only 形态）
-    const { code, stdout } = await new Promise<{ code: number | null; stdout: string }>(resolve => {
-      const child = spawn(process.execPath, ['--experimental-strip-types', fixture, configPath], { stdio: ['ignore', 'pipe', 'pipe'] })
-      let out = ''
-      child.stdout.on('data', d => { out += d })
-      child.on('exit', c => resolve({ code: c, stdout: out }))
-    })
-    assert.equal(code, 0, 'strip-only 环境下 jiti 真载 enum 配置')
-    const m = /OK model=(\S+) firstLoadMs=(\d+) nativeRejected=(.+)/.exec(stdout.trim())!
-    assert.equal(m[1], 'strip-model')
-    assert.ok(m[2] !== undefined, '首载时延实测出值')
-    console.log(`    [登记] car.config.ts jiti 首载时延（spawn 冷启，本机实跑）：${m[2]} ms`)
-    assert.ok(Number(m[2]) < 15_000, '首载时延宽上界（CI 防抖；真实数值进收口报告）')
-    assert.ok(m[3]!.length > 0, '负控：原生 import 对非可擦除语法显式失败——jiti 是载体而非原生剥离')
-  })
-})
-
-test('S38: CLI 真路径——car run 于 enum 配置目录：配置经 jiti 装载生效（模型未配引导而非配置报错）', async () => {
-  await withTempDir('cli', async dir => {
-    writeFileSync(join(dir, 'car.config.ts'), [
-      `export enum LlmMode { full = 'full-model' }`,
-      `export default { llm: { model: LlmMode.full } }`,
-    ].join('\n'))
-    const plugin = join(dir, 'noop.ts')
-    writeFileSync(plugin, [
-      `export const manifest = { name: "s38p", version: "1.0.0" }`,
-      `export default function apply(api) { api.registerTool({ name: "noop", declaredSideEffect: "readonly", run: async () => "ok" }) }`,
-    ].join('\n'))
-    const { code, output } = await new Promise<{ code: number | null; output: string }>(resolve => {
-      const child = spawn(process.execPath, ['--experimental-transform-types', CLI, 'run', plugin], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] })
-      let out = ''
-      child.stdout.on('data', d => { out += d })
-      child.stderr.on('data', d => { out += d })
-      child.on('exit', c => resolve({ code: c, output: out }))
-    })
-    assert.equal(code, 2, 'D-13：无凭据/端点 → exit 2 显式引导')
-    assert.match(output, /CAR-E-LLM-CONFIG/, '配置经 jiti 解析通过（enum 值进 llm.model）走到模型就绪检查')
-    assert.doesNotMatch(output, /CAR-E-CONFIG/, '配置载体本身零错误')
-  })
-})

package/test/s39-otlp-span-semantics.spec.ts

@@ -1,100 +0,0 @@
-/**
- * 1.7-S1 · OTLP span 语义标准化（D-26）：exception 标准事件 + status / addEvent 标准 events 编码
- *
- * 覆盖（1.7-迭代规划 TELE-1；1.4 遗留「遥测 OTLP 增强」出清主体）：
- *  - recordException → OTel 规范形态：span event（name='exception'，exception.type/exception.message
- *    事件属性 + timeUnixNano）+ span status → STATUS_CODE_ERROR——替换 1.1 起「仅 exception.message
- *    属性 + 恒 UNSET」非标准形态；stacktrace 缺省不出站（D-26 口径：防路径/源码面外泄）
- *  - addEvent → 标准 events 数组编码（name + 原形态属性 + 时刻）——替换 `event.<name>` JSON 属性串
- *  - 出站体加法字段：无事件 span 不出 events 键（空形态合法）；正常 span 恒 STATUS_CODE_UNSET（行为不变面）
- *  - noop 门面零出站不变（默认关三原则；s29/s32 回归由全量保证）
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createTelemetryFacade } from '../src/runtime-core/telemetry.ts'
-
-const okRes = () => ({ ok: true, status: 200 }) as unknown as Response
-
-function capture() {
-  const bodies: any[] = []
-  const f = createTelemetryFacade({ endpoint: 'https://otel' }, {
-    fetchImpl: (async (_u: string | URL, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); return okRes() }) as typeof fetch,
-  })
-  return { f, bodies }
-}
-
-const spansOf = (bodies: any[]) => bodies.filter(b => b.scopeSpans).flatMap(b => b.scopeSpans[0].spans)
-
-test('S39: recordException → 标准 exception 事件 + STATUS_CODE_ERROR（stacktrace 不出站）', async () => {
-  const { f, bodies } = capture()
-  const s = f.getTracer().startSpan('car.step', { attributes: { 'car.step': 1 } })
-  s.recordException(new TypeError('boom'))
-  s.end('error')
-  await f.flush()
-  const span = spansOf(bodies)[0]
-  assert.equal(span.status.code, 'STATUS_CODE_ERROR', 'recordException → status ERROR（1.7 前恒 UNSET）')
-  assert.ok(Array.isArray(span.events) && span.events.length === 1, 'exception 为 span event')
-  const ev = span.events[0]
-  assert.equal(ev.name, 'exception')
-  assert.ok(ev.timeUnixNano, '事件时刻出站')
-  const attrs = Object.fromEntries(ev.attributes.map((a: any) => [a.key, a.value.stringValue]))
-  assert.equal(attrs['exception.type'], 'TypeError', 'err.name → exception.type')
-  assert.equal(attrs['exception.message'], 'boom', 'err.message → exception.message')
-  const allKeys = [...span.attributes, ...span.events.flatMap((e: any) => e.attributes)].map((a: any) => a.key)
-  assert.equal(allKeys.some((k: string) => /stack/i.test(k)), false, 'stacktrace 缺省不出站（D-26）')
-  assert.equal(allKeys.includes('exception.message') && span.attributes.some((a: any) => a.key === 'exception.message'), false,
-    'exception.message 不再落于 span attributes（1.1 非标准形态退役）')
-})
-
-test('S39: recordException 非 Error 值兜底——type=Error / message=String(err)', async () => {
-  const { f, bodies } = capture()
-  const s = f.getTracer().startSpan('car.step')
-  s.recordException('plain failure')
-  s.end('error')
-  await f.flush()
-  const ev = spansOf(bodies)[0].events[0]
-  const attrs = Object.fromEntries(ev.attributes.map((a: any) => [a.key, a.value.stringValue]))
-  assert.deepEqual(attrs, { 'exception.type': 'Error', 'exception.message': 'plain failure' })
-})
-
-test('S39: addEvent → 标准 events 编码（原形态属性 + 时刻；attributes 不再承载事件）', async () => {
-  const { f, bodies } = capture()
-  const s = f.getTracer().startSpan('car.turn')
-  s.addEvent('cache-hit', { key: 'x', n: 1, flag: true })
-  s.end('completed')
-  await f.flush()
-  const span = spansOf(bodies)[0]
-  assert.equal(span.status.code, 'STATUS_CODE_UNSET', '正常 span 恒 UNSET（行为不变面）')
-  assert.equal(span.events.length, 1)
-  const ev = span.events[0]
-  assert.equal(ev.name, 'cache-hit')
-  assert.ok(ev.timeUnixNano)
-  const map = Object.fromEntries(ev.attributes.map((a: any) => [a.key, a.value]))
-  assert.deepEqual(map, { key: { stringValue: 'x' }, n: { doubleValue: 1 }, flag: { boolValue: true } },
-    '原形态属性出站（1.7 前为 event.<name>=JSON 串）')
-  const attrKeys = span.attributes.map((a: any) => a.key)
-  assert.equal(attrKeys.includes('event.cache-hit'), false, 'attributes 不再承载事件（非标准形态退役）')
-})
-
-test('S39: 无事件 span 不出 events 键（出站体加法字段——空形态合法）', async () => {
-  const { f, bodies } = capture()
-  f.getTracer().startSpan('plain').end()
-  await f.flush()
-  const span = spansOf(bodies)[0]
-  assert.equal('events' in span, false, '无事件不出 events 键')
-  assert.equal(span.status.code, 'STATUS_CODE_UNSET')
-})
-
-test('S39: 多事件按序出站（exception 与 addEvent 混排——事件数组保序）', async () => {
-  const { f, bodies } = capture()
-  const s = f.getTracer().startSpan('car.step')
-  s.addEvent('retry')
-  s.recordException(new Error('net'))
-  s.addEvent('fallback')
-  s.end('completed')
-  await f.flush()
-  const names = spansOf(bodies)[0].events.map((e: any) => e.name)
-  assert.deepEqual(names, ['retry', 'exception', 'fallback'])
-  // exception 事件混排下 status 仍 ERROR
-  assert.equal(spansOf(bodies)[0].status.code, 'STATUS_CODE_ERROR')
-})

package/test/s4.spec.ts

@@ -1,169 +0,0 @@
-/**
- * S4 · 端到端串联（E2E）+ N2 基线实测 + Q-06 性能定标
- *
- * E2E 链路（对齐高层架构 §5.3 业务闭环五环节）：
- *   触发 → 装配加载（F9+F6）→ 沙箱内事件运行（F7+F4+F3 降级约束）→ 停止收口（F5/ADR-001）
- *   → 日志落盘（F2 哈希链）→ 审计回放（deriveMessages + verifyChain + 基础导出）
- * Q-06 定标：装配时延 / 分发时延 / 日志 1 万事件追加+回放+校验耗时
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { writeFileSync, mkdtempSync, rmSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { Context } from '../src/kernel/context.ts'
-import { declareEvent, EventBus } from '../src/kernel/events.ts'
-import { SessionLog, loadSessionLog } from '../src/session/log.ts'
-import { runTurn } from '../src/loop/stop.ts'
-import { mountPlugin } from '../src/load/loader.ts'
-import { probeCapabilities, SandboxExecutor } from '../src/sandbox/sandbox.ts'
-import { McpGateway, type McpTransport, type JsonRpcRequest, type JsonRpcResponse } from '../src/mcp/gateway.ts'
-import { AuthzService } from '../src/authz/authz.ts'
-
-const cleanup = (p: string) => { try { rmSync(p, { force: true, recursive: true }) } catch {} }
-
-test('E2E：五环节全链路（装配→运行→收口→落盘→回放+MCP 桥接+授权留痕）', async () => {
-  const dir = mkdtempSync(join(tmpdir(), 'car-e2e-'))
-  try {
-    // —— 触发：插件文件（免编译 TS）——
-    const pluginFile = join(dir, 'demo-plugin.ts')
-    writeFileSync(pluginFile, `export default function apply(api) {\n  api.registerTool({ name: 'e2e_tool', run: async (args) => 'e2e-' + args.tag })\n}\n`)
-    const manifest = { name: 'demo', version: '1.0.0' }
-
-    // —— 环节 1：装配加载（F9 两阶段 + F6 免编译 + F1 依赖推导）——
-    const t0 = Date.now()
-    const plugin = await mountPlugin({ file: pluginFile, manifest })
-    const ctx = new Context()
-    const log = new SessionLog('S-E2E')
-    const authz = new AuthzService({ log, timeoutMs: 100 })
-    declareEvent('tools/around', 'waterfall')
-    const bus = new EventBus()
-    let auditTrail = ''
-    bus.on('tools/around', async (_p, next) => { const r = await next(); auditTrail = 'wrapped:' + r; return r })
-  bus.on('tools/around', () => Promise.resolve('e2e-ok')) // 下游结果提供者
-    const hostTools: any[] = []
-    ctx.plugin({
-      name: 'demo',
-      apply: (c) => {
-        // 插件文件工厂已在 mount 时经 Stub 收集注册；bindCore 冲刷进宿主（勿重复注册）
-        plugin.bindCore({ registerTool: (t) => { hostTools.push(t); c.provide('tool:e2e_tool', t) } })
-      },
-    })
-    const mountMs = Date.now() - t0
-    assert.ok(hostTools.some(t => t.name === 'e2e_tool'), '装配：插件工具注册进能力矩阵')
-
-    // —— 环节 2：事件运行（MCP 桥接同审批门 + waterfall 环绕 + 权限门）——
-    const gw = new McpGateway()
-    const rpc: McpTransport = {
-      async send(req: JsonRpcRequest): Promise<JsonRpcResponse> {
-        if (req.method === 'tools/list') return { jsonrpc: '2.0', id: req.id, result: { tools: [{ name: 'py_tool', sideEffect: 'readonly' }] } }
-        if (req.method === 'tools/call') return { jsonrpc: '2.0', id: req.id, result: { content: 'py-ok' } }
-        throw new Error('unreachable')
-      },
-      alive: () => true, close() {},
-    }
-    await gw.register({ serverId: 'py1', transport: rpc })
-    const mcpResult = await gw.callTool('py1', 'py_tool', {})
-    assert.equal(mcpResult.ok, true)
-    log.append('user', 'user', 'T0', 'run e2e')
-    log.snapshotModelRequest()
-    log.append('model', 'toolCall', 'T0', { id: 'm1', tool: 'py_tool', args: {} })
-    log.append('plugin', 'toolResult', 'T0', { id: 'm1', result: mcpResult.result })
-    // 权限门：write 类走 confirm（授权留痕）
-    const decision = await authz.decideByUser(
-      { authorizationId: 'A-E2E-1', actor: 'demo', capability: 'fs-write', resource: join(dir, 'out.txt') },
-      async () => true,
-    )
-    assert.equal(decision.decision, 'APPROVED')
-
-    // —— 环节 3：停止收口（F5/ADR-001）——
-    const probe = await probeCapabilities()
-    const sandbox = new SandboxExecutor({ probe, audit: () => {}, workspace: dir })
-    assert.equal(sandbox.degraded, probe.degraded) // 执行器必须忠实反映探测结论：Windows/裸 CI 必降级，Linux+landlock-run 全执法
-    const exec = await sandbox.exec({ argv: ['node', '-e', 'console.log("s")'], capabilities: ['exec'], mode: 'workspace-write', permissionMode: 'confirm', authorize: async () => true })
-    assert.equal(exec.ok, true)
-    const tools = new Map([['e2e_tool', { declaredSideEffect: 'write', run: hostTools.find(t => t.name === 'e2e_tool')!.run } as any]])
-    let n = 0
-    const turn = await runTurn({
-      log, turnId: 'T0', tools, preset: { mode: 'full' },
-      model: async (): Promise<any> => n++ === 0
-        ? { stopReason: 'toolUse', toolCalls: [{ id: 'c1', tool: 'e2e_tool', args: { tag: 'ok' } }] }
-        : { stopReason: 'stop', text: 'final' },
-    })
-    assert.equal(turn.reason, 'completed')
-    // waterfall 环绕实证：分发 → before → next() → after → 结果可改写
-    const wrapped = await bus.dispatch<string>('tools/around', {}, () => 'e2e-ok')
-    assert.equal(wrapped, 'e2e-ok') // 下游结果透传；环绕 trail 已记录
-    assert.deepEqual(auditTrail, 'wrapped:e2e-ok') // handler 侧记录 before/after 顺序
-
-    // —— 环节 4：日志落盘（F2 哈希链 + N1 断言）——
-    const jsonl = join(dir, 'session.jsonl')
-    writeFileSync(jsonl, log.exportJSONL())
-    assert.equal(log.assertModelVisibleLogged().ok, true)
-
-    // —— 环节 5：审计回放（只读加载 + 断链校验 + 投影）——
-    const { log: reloaded, brokenAt } = loadSessionLog(jsonl)
-    assert.equal(brokenAt, null)
-    const replayed = reloaded.deriveMessages()
-    assert.ok(replayed.length >= 4)
-    assert.deepEqual(replayed[0], { role: 'user', content: 'run e2e' })
-    // 授权凭据链可回放（US6：谁在何时调用了什么、凭什么）
-    assert.ok(reloaded.events.some(e => e.turnId === 'authz:A-E2E-1'))
-    void mountMs
-  } finally { cleanup(dir) }
-})
-
-test('N2: 首插件跑通耗时实测（目标 ≤300s，实际秒级）', async () => {
-  const dir = mkdtempSync(join(tmpdir(), 'car-n2-'))
-  try {
-    const t0 = Date.now()
-    const f = join(dir, 'first.ts')
-    writeFileSync(f, `export default function apply(api) { api.registerTool({ name: 'first', run: async () => 42 }) }\n`)
-    const p = await mountPlugin({ file: f, manifest: { name: 'first', version: '1.0.0' } })
-    let got: unknown
-    p.bindCore({ registerTool: async (t) => { got = await t.run({}) } })
-    p.api.getRegisteredTools // 能力查询（bind 后可用）
-    const ctx = new Context()
-    ctx.plugin({ name: 'first', apply: (c) => c.effect(() => async () => {}, 'noop') })
-    await ctx.disposeRuntime()
-    const wall = Date.now() - t0
-    assert.equal(got, 42)
-    assert.ok(wall < 300_000, `实测 ${wall}ms`)
-    console.log(`  [N2 实测] 首插件跑通 = ${wall}ms（含免编译加载+装配+执行+卸载）`)
-  } finally { cleanup(dir) }
-})
-
-test('Q-06: 性能定标——装配 / 分发 / 日志 1 万事件', async () => {
-  // 装配时延：20 插件依赖图
-  const ctx = new Context()
-  const t0 = Date.now()
-  for (let i = 0; i < 20; i++) {
-    ctx.plugin({ name: 'p' + i, apply: (c) => c.provide('svc' + i, { i }) })
-  }
-  for (let i = 0; i < 20; i++) {
-    ctx.plugin({ name: 'c' + i, inject: ['svc' + i], apply: () => {} })
-  }
-  const mountMs = Date.now() - t0
-  // 分发时延：serial 1000 次
-  declareEvent('bench/e', 'serial')
-  const bus = new EventBus()
-  bus.on('bench/e', (_p: unknown, next: () => number) => next() + 1)
-  const t1 = Date.now()
-  for (let i = 0; i < 1000; i++) await bus.dispatch<number>('bench/e', i, () => i)
-  const dispatchMs = Date.now() - t1
-  // 日志：1 万事件 追加+哈希链+回放+校验
-  const log = new SessionLog('S-BENCH')
-  const t2 = Date.now()
-  for (let i = 0; i < 10_000; i++) log.append('model', 'assistant', 'TB', 'x' + i)
-  const appendMs = Date.now() - t2
-  const t3 = Date.now()
-  const replayed = log.deriveMessages()
-  const chainOk = log.verifyChain() === null
-  const replayMs = Date.now() - t3
-  assert.equal(replayed.length, 10_000)
-  assert.equal(chainOk, true)
-  const row = { mountMs20Plugins: mountMs, dispatch1000SerialMs: dispatchMs, append10kMs: appendMs, replayAndVerify10kMs: replayMs }
-  console.log('  [Q-06 定标]', JSON.stringify(row))
-  // 保守上限断言（CI 波动容差）：装配 <2s、千次分发 <5s、万事件追加 <10s、回放校验 <10s
-  assert.ok(mountMs < 2000 && dispatchMs < 5000 && appendMs < 10_000 && replayMs < 10_000)
-})

package/test/s40-metrics-cumulative.spec.ts

@@ -1,67 +0,0 @@
-/**
- * 1.7-S2 · metrics CUMULATIVE 时序语义修正（D-27）：累计基数保持
- *
- * 覆盖（1.7-迭代规划 TELE-2；1.2-S3 起 clear() 与 AGGREGATION_TEMPORALITY_CUMULATIVE 标注矛盾出清）：
- *  - 同计数器双 flush：第二次导出仍为全量累计（5 → 7），非增量（5 → 2）——真 CUMULATIVE；
- *    intervalMs>0 自动导出场景下下游（Prometheus 转换器等）不再解读为总量回落；
- *  - labels 形态与 temporality 标注不变；DELTA 备选不采纳（D-27：生态主流 + S17 计数语义即累计）；
- *  - 内存有界由 label 基数保证（零内容枚举红线——AllowedLabels 3 计数器）。
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createTelemetryFacade } from '../src/runtime-core/telemetry.ts'
-
-const okRes = () => ({ ok: true, status: 200 }) as unknown as Response
-
-test('S40: 累计基数保持——同计数器双 flush 导出全量累计快照（真 CUMULATIVE，非增量）', async () => {
-  const bodies: any[] = []
-  const f = createTelemetryFacade({ endpoint: 'https://otel' }, {
-    fetchImpl: (async (_u: string | URL, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); return okRes() }) as typeof fetch,
-  })
-  const c = f.getMeter().createCounter('car_test_total')
-  c.add(5, { result: 'ok' })
-  await f.flush()
-  c.add(2, { result: 'ok' })
-  await f.flush()
-  assert.equal(bodies.length, 2, '两次 flush 各一次 metrics 出站')
-  const values = bodies.map(b => b.scopeMetrics[0].metrics[0].sum.dataPoints[0].asInt)
-  assert.deepEqual(values, [5, 7], '第二次导出 = 累计 7（1.7 前为增量 2——CUMULATIVE 语义错误）')
-  for (const b of bodies) {
-    const m = b.scopeMetrics[0].metrics[0]
-    assert.equal(m.name, 'car_test_total')
-    assert.equal(m.sum.aggregationTemporality, 'AGGREGATION_TEMPORALITY_CUMULATIVE')
-    const dp = m.sum.dataPoints[0]
-    assert.equal(dp.attributes[0].key, 'result', 'labels 形态不变')
-    assert.equal(dp.attributes[0].value.stringValue, 'ok')
-  }
-  assert.equal(f.stats().metricsExported, 2)
-})
-
-test('S40: 无新增计数 interval 下重复 flush——全量快照幂等重出（CUMULATIVE 口径正确形态）', async () => {
-  const bodies: any[] = []
-  const f = createTelemetryFacade({ endpoint: 'https://otel' }, {
-    fetchImpl: (async (_u: string | URL, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); return okRes() }) as typeof fetch,
-  })
-  f.getMeter().createCounter('car_load_total').add(3, { result: 'ok' })
-  await f.flush()
-  await f.flush()
-  const values = bodies.map(b => b.scopeMetrics[0].metrics[0].sum.dataPoints[0].asInt)
-  assert.deepEqual(values, [3, 3], '无新增 = 同值重出（累计快照，非清零/缺席）')
-})
-
-test('S40: 多计数器并存——各自独立累计（互不串值）', async () => {
-  const bodies: any[] = []
-  const f = createTelemetryFacade({ endpoint: 'https://otel' }, {
-    fetchImpl: (async (_u: string | URL, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); return okRes() }) as typeof fetch,
-  })
-  const c1 = f.getMeter().createCounter('car_load_total')
-  const c2 = f.getMeter().createCounter('car_registry_decision')
-  c1.add(1, { result: 'ok' })
-  c2.add(2, { source: 'registry' })
-  c1.add(1, { result: 'ok' })
-  await f.flush()
-  const metrics = bodies[0].scopeMetrics[0].metrics
-  assert.equal(metrics.length, 2)
-  const byName = Object.fromEntries(metrics.map((m: any) => [m.name, m.sum.dataPoints[0].asInt]))
-  assert.deepEqual(byName, { car_load_total: 2, car_registry_decision: 2 })
-})