@lqc123qwe/car-runtime 1.9.0 → 1.11.0

package/test/s19.spec.ts

@@ -1,138 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { SessionLog } from '../src/session/log.ts'
-import { forkCrossHost, loadForkedLog } from '../src/session/fork.ts'
-import { deriveSessionId, HOST_MAPPINGS } from '../src/host/mappings.ts'
-import { createRuntimeFacade } from '../src/host/facade.ts'
-import { HostGateway } from '../src/host/hostGateway.ts'
-
-// ==================== forkCrossHost 核心原语 ====================
-
-function sourceLog(): SessionLog {
-  const log = new SessionLog(deriveSessionId('claude-code', 'sess-A'))
-  log.append('user', 'user', 'T1', { text: '帮我校对这段话' })
-  log.append('model', 'assistant', 'T1', { text: '好的，请贴出原文' })
-  log.append('model', 'toolCall', 'T2', { tool: 'fs_read', id: 'c1' })
-  return log
-}
-
-test('fork 跨宿主: 链逐字节迁移 + fork 标记落链 + 目标会话 id 确定性派生', () => {
-  const src = sourceLog()
-  const fork = forkCrossHost(src, { hostId: 'codex', hostSessionId: 'cx-9' })
-  assert.equal(fork.sessionId, deriveSessionId('codex', 'cx-9'))
-  assert.equal(fork.migrated, 3)
-  assert.equal(fork.log.events.length, 4, '3 迁移 + 1 fork 标记')
-  assert.equal(fork.log.verifyChain(), null, '迁移后链完整')
-  const marker = fork.log.events[3]!
-  assert.equal(marker.kind, 'fork')
-  assert.deepEqual(marker.payload, {
-    fromSessionId: src.sessionId, targetHostId: 'codex', targetHostSessionId: 'cx-9',
-    upToSeq: 3, fromTailHash: src.events[2]!.hash,
-  })
-})
-
-test('fork 跨宿主: 源链断链拒绝 fork（fail-visible，破损链不扩散）', () => {
-  const src = sourceLog()
-  ;(src.events as unknown as Array<{ payload: unknown }>)[1]!.payload = { text: '被篡改' }
-  assert.throws(() => forkCrossHost(src, { hostId: 'codex', hostSessionId: 'cx-9' }), /chain broken at seq 1/)
-})
-
-test('fork 跨宿主: upToSeq 部分迁移（前缀 fork）+ 越界显式报错', () => {
-  const fork = forkCrossHost(sourceLog(), { hostId: 'codex', hostSessionId: 'cx-1' }, { upToSeq: 2 })
-  assert.equal(fork.migrated, 2)
-  assert.equal(fork.log.events.length, 3)
-  assert.equal((fork.log.events[2]!.payload as { upToSeq: number }).upToSeq, 2)
-  assert.throws(() => forkCrossHost(sourceLog(), { hostId: 'codex', hostSessionId: 'cx-2' }, { upToSeq: 99 }), /out of range/)
-  assert.throws(() => forkCrossHost(sourceLog(), { hostId: 'codex', hostSessionId: 'cx-3' }, { upToSeq: -1 }), /out of range/)
-})
-
-// ==================== loadForkedLog resume 侧装载 ====================
-
-test('resume 装载: 工件 → 链校验 → 归属校验 → 续跑 append 不断链', () => {
-  const src = sourceLog()
-  const fork = forkCrossHost(src, { hostId: 'codex', hostSessionId: 'cx-9' })
-  const loaded = loadForkedLog(fork.jsonl, { hostId: 'codex', hostSessionId: 'cx-9' })
-  assert.equal(loaded.sessionId, fork.sessionId)
-  assert.equal(loaded.log.verifyChain(), null)
-  // 续跑：装载后 append 正常接链（#tail 已恢复）
-  loaded.log.append('user', 'user', 'T2', { text: '继续' })
-  assert.equal(loaded.log.verifyChain(), null, '续跑后链仍完整')
-  assert.equal(loaded.log.events.length, 5)
-  // 投影：源会话消息在宿主 B 可见（续跑上下文完整）
-  const msgs = loaded.log.deriveMessages()
-  assert.equal((msgs[0] as { content: { text: string } }).content.text, '帮我校对这段话')
-})
-
-test('resume 装载: 断链工件 / 非 fork 工件 / 归属不匹配 全部拒绝（零静默）', () => {
-  const fork = forkCrossHost(sourceLog(), { hostId: 'codex', hostSessionId: 'cx-9' })
-  // ① 篡改中间事件 → 断链
-  const tampered = fork.jsonl.split('\n').filter(Boolean).map((l, i) => i === 1 ? l.replace('好的', '已篡改') : l).join('\n')
-  assert.throws(() => loadForkedLog(tampered), /chain broken/)
-  // ② 普通 SessionLog 导出（无 fork 标记）拒绝
-  const plain = new SessionLog('S-plain')
-  plain.append('user', 'user', 'T1', { text: 'hi' })
-  assert.throws(() => loadForkedLog(plain.exportJSONL()), /no fork marker/)
-  // ③ 工件归属 codex/cx-9，却被 claude-code/cc-1 装载 → 拒绝
-  assert.throws(() => loadForkedLog(fork.jsonl, { hostId: 'claude-code', hostSessionId: 'cc-1' }), /target mismatch/)
-  // ④ 归属匹配 → 通过
-  assert.doesNotThrow(() => loadForkedLog(fork.jsonl, { hostId: 'codex', hostSessionId: 'cx-9' }))
-})
-
-// ==================== 工具面 E2E：宿主 A fork → 工件 → 宿主 B 导入续跑 ====================
-
-function facadeGateway() {
-  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 { facade, gw }
-}
-
-test('E2E 跨宿主: 宿主 A 会话 → session_fork → 工件 → 宿主 B session_start 导入 → session_turn 续跑', async () => {
-  const { gw } = facadeGateway()
-  // 宿主 A（claude-code）：start + 一个 turn（产生消息与 toolCall 事件）
-  const a = await gw.handle('claude-code', 'session_start', { hostSessionId: 'sess-A' })
-  const aId = (a.result as { sessionId: string }).sessionId
-  await gw.handle('claude-code', 'session_turn', { sessionId: aId, input: { events: [
-    { hostEvent: 'user_message', payload: { content: '帮我查库存' } },
-    { hostEvent: 'tool_use', payload: { tool_name: 'erp_query', tool_call_id: 'c1' } },
-    { hostEvent: 'turn_complete', payload: {} },
-  ] } })
-  // fork 到宿主 B（codex）
-  const fk = await gw.handle('claude-code', 'session_fork', { sessionId: aId, targetHostId: 'codex', targetHostSessionId: 'cx-77' })
-  const { sessionId: bId, jsonl } = fk.result as { sessionId: string; jsonl: string }
-  assert.equal(bId, deriveSessionId('codex', 'cx-77'))
-  // 宿主 B：导入工件 start（归属校验内建）→ replay 可见源会话消息
-  const b = await gw.handle('codex', 'session_start', { hostSessionId: 'cx-77', importJsonl: jsonl })
-  assert.equal((b.result as { sessionId: string }).sessionId, bId)
-  const replay = await gw.handle('codex', 'session_replay', { sessionId: bId })
-  const messages = (replay.result as { messages: Array<{ content: unknown }> }).messages
-  assert.equal((messages[0]!.content as { text: string }).text, '帮我查库存')
-  // 宿主 B 续跑：turnId 不与迁移段冲突（迁移段最大 T1 → 续跑 T2）
-  const t2 = await gw.handle('codex', 'session_turn', { sessionId: bId, input: { events: [
-    { hostEvent: 'input_item', payload: { text: '继续查' } },
-    { hostEvent: 'task_complete', payload: {} },
-  ] } })
-  assert.equal((t2.result as { reason: string }).reason, 'completed')
-  // 链完整性：导入 + 续跑后 verify 通过
-  const vf = await gw.handle('codex', 'session_verify', { sessionId: bId })
-  assert.equal((vf.result as { ok: boolean }).ok, true)
-})
-
-test('E2E 跨宿主负例: 工件被第三方宿主导入 → 归属校验拒绝（不静默降级为普通会话）', async () => {
-  const { gw } = facadeGateway()
-  const a = await gw.handle('claude-code', 'session_start', { hostSessionId: 'sess-A' })
-  const aId = (a.result as { sessionId: string }).sessionId
-  const fk = await gw.handle('claude-code', 'session_fork', { sessionId: aId, targetHostId: 'codex', targetHostSessionId: 'cx-77' })
-  const { jsonl } = fk.result as { jsonl: string }
-  // 第三方宿主（未登记 profile 或归属不匹配）导入 → 显式报错
-  await assert.rejects(
-    () => gw.handle('codex', 'session_start', { hostSessionId: 'other-id', importJsonl: jsonl }).then(r => { if (r.error) throw new Error(r.error) }),
-    /target mismatch|CAR-E-FORK/,
-  )
-  // fork 到未登记目标宿主 → 显式报错
-  await assert.rejects(
-    () => gw.handle('claude-code', 'session_fork', { sessionId: aId, targetHostId: 'ghost-host', targetHostSessionId: 'x' }).then(r => { if (r.error) throw new Error(r.error) }),
-    /not registered/,
-  )
-})

package/test/s2.spec.ts

@@ -1,245 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { declareEvent, EventBus } from '../src/kernel/events.ts'
-import { runTurn, type ModelStep, type ToolDef, type ToolCall } from '../src/loop/stop.ts'
-import { SessionLog } from '../src/session/log.ts'
-import { mountPlugin, parseManifest } from '../src/load/loader.ts'
-import { writeFileSync, rmSync } from 'node:fs'
-
-// ==================== F7 事件分发契约 ====================
-
-test('F7: 未声明事件的订阅 = 启动期静态报错（US-7 AC2）', () => {
-  const bus = new EventBus()
-  assert.throws(() => bus.on('undeclared/event', () => {}), /undeclared event/)
-})
-
-test('F7: bail 模式——首断即止（短路是设计意图）', async () => {
-  declareEvent('guard/check', 'bail')
-  const bus = new EventBus()
-  const calls: string[] = []
-  bus.on('guard/check', () => { calls.push('h1'); return 'BLOCK' })
-  bus.on('guard/check', () => { calls.push('h2'); return 'BLOCK2' })
-  const r = await bus.dispatch('guard/check', {})
-  assert.equal(r, 'BLOCK')
-  assert.deepEqual(calls, ['h1'])
-})
-
-test('F7: serial 模式——有序检查点链式传值', async () => {
-  declareEvent('ctx/enrich', 'serial')
-  const bus = new EventBus()
-  bus.on('ctx/enrich', (_p: unknown, next: () => string) => next() + '!A')
-  bus.on('ctx/enrich', (_p: unknown, next: () => string) => next() + '!B')
-  assert.equal(await bus.dispatch<string>('ctx/enrich', 'x', () => 'base'), 'base!A!B')
-})
-
-test('F7: waterfall 模式——环绕中间件（next() 前后均可介入）', async () => {
-  declareEvent('tools/around', 'waterfall')
-  const bus = new EventBus()
-  const trace: string[] = []
-  bus.on('tools/around', async (_p: unknown, next: () => Promise<string>) => {
-    trace.push('before')
-    const r = await next()
-    trace.push('after')
-    return r.toUpperCase()
-  })
-  bus.on('tools/around', () => Promise.resolve('raw'))
-  const r = await bus.dispatch<string>('tools/around', {})
-  assert.equal(r, 'RAW')
-  assert.deepEqual(trace, ['before', 'after'])
-})
-
-test('F7: parallel 模式扇出聚合；emit 模式广播无返回', async () => {
-  declareEvent('audit/fanout', 'parallel')
-  declareEvent('lifecycle/notify', 'emit')
-  const bus = new EventBus()
-  bus.on('audit/fanout', (p: number) => p * 2)
-  bus.on('audit/fanout', (p: number) => p * 3)
-  assert.deepEqual(await bus.dispatch<number, number>('audit/fanout', 5), [10, 15])
-  const seen: number[] = []
-  bus.on('lifecycle/notify', () => { seen.push(1) })
-  assert.equal(await bus.dispatch('lifecycle/notify', {}), undefined)
-  assert.deepEqual(seen, [1])
-})
-
-test('F7: 契约重复声明且模式不一致 = 显式报错', () => {
-  declareEvent('dup/e', 'serial')
-  assert.throws(() => declareEvent('dup/e', 'bail'), /re-declared/)
-})
-
-// ==================== F5 停止语义（ADR-001） ====================
-
-test('F5 AC1: 工具批次 → step null 续走，无异常', async () => {
-  const log = new SessionLog()
-  let n = 0
-  const tools = new Map([['t', { declaredSideEffect: 'readonly', run: async () => 'ok' } as ToolDef]])
-  const r = await runTurn({
-    log, turnId: 'T', tools,
-    model: async (): Promise<ModelStep> => n++ === 0
-      ? { stopReason: 'toolUse', toolCalls: [{ id: 'c1', tool: 't', args: {} }] }
-      : { stopReason: 'stop', text: 'done' },
-  })
-  assert.equal(r.reason, 'completed')
-  const kinds = log.events.map(e => e.kind)
-  assert.ok(kinds.includes('toolCall') && kinds.includes('toolResult'))
-})
-
-test('F5 AC2: step1 max-tokens + steering 续跑 → turn/end 保留 max-tokens（不被冲销）', async () => {
-  const log = new SessionLog()
-  let n = 0
-  const r = await runTurn({
-    log, turnId: 'T',
-    model: async (): Promise<ModelStep> => n++ === 0 ? { stopReason: 'length' } : { stopReason: 'stop', text: 'recovered' },
-  })
-  assert.equal(r.reason, 'max-tokens')
-  const end = log.events.find(e => e.kind === 'turnEnd') as any
-  assert.equal(end.meta.reason, 'max-tokens')
-})
-
-test('F5 AC3: 截断响应含写工具 → 解析前收口（无副作用落地）', async () => {
-  const log = new SessionLog()
-  let executed = false
-  const tools = new Map([['writeFile', { declaredSideEffect: 'write', run: async () => { executed = true } } as ToolDef]])
-  const r = await runTurn({
-    log, turnId: 'T', tools,
-    model: async (): Promise<ModelStep> => ({ stopReason: 'length', truncatedTools: [{ id: 'c1', tool: 'writeFile' }] }),
-  })
-  assert.equal(r.reason, 'max-tokens')
-  assert.equal(executed, false)
-})
-
-test('F5 AC4: 只读白名单 + retryReadOnly → 补错重试（Pi 式）', async () => {
-  const log = new SessionLog()
-  let n = 0
-  const tools = new Map([['search', { declaredSideEffect: 'readonly', run: async () => 'results' } as ToolDef]])
-  const r = await runTurn({
-    log, turnId: 'T', tools,
-    preset: { maxTokensRetryReadOnly: true },
-    model: async (): Promise<ModelStep> => {
-      if (n++ === 0) return { stopReason: 'length', truncatedTools: [{ id: 'c1', tool: 'search' }] }
-      return { stopReason: 'stop', text: 'done' }
-    },
-  })
-  // I4 一致性：即便只读重试续走，turn/end 仍保留 max-tokens（与 AC2 同语义）
-  assert.equal(r.reason, 'max-tokens')
-  assert.equal(r.steps, 2, '重试后续走了一个 step')
-  const err = log.events.find(e => e.kind === 'toolResult' && JSON.stringify((e.payload as any)?.error || '').includes('truncated'))
-  assert.ok(err, '只读工具收到截断错误结果')
-})
-
-test('F5: 取消 → 未派发调用补记成对事件，reason=aborted（日志无缺口）', async () => {
-  const log = new SessionLog()
-  const signal = { aborted: false }
-  let i = 0
-  const tools = new Map([['t1', { declaredSideEffect: 'readonly', run: async () => { if (++i === 1) signal.aborted = true; return 'x' } } as ToolDef]])
-  const r = await runTurn({
-    log, turnId: 'T', tools, signal,
-    model: async (): Promise<ModelStep> => ({ stopReason: 'toolUse', toolCalls: [
-      { id: 'c1', tool: 't1', args: {} }, { id: 'c2', tool: 't1', args: {} },
-    ] }),
-  })
-  assert.equal(r.reason, 'aborted')
-  // 日志无缺口：c2 的 toolCall 与合成错误 toolResult 成对存在
-  const c2call = log.events.some(e => e.kind === 'toolCall' && (e.payload as any).id === 'c2')
-  const c2result = log.events.some(e => e.kind === 'toolResult' && (e.payload as any).id === 'c2' && (e.payload as any).error === 'aborted-before-dispatch')
-  assert.ok(c2call && c2result, '未派发调用补记成对事件')
-})
-
-test('F5: concludesTurn=OR——任一工具收口即 completed', async () => {
-  const log = new SessionLog()
-  const tools = new Map([
-    ['commit', { declaredSideEffect: 'write', concludesTurn: true, run: async () => 'committed' } as ToolDef],
-    ['probe', { declaredSideEffect: 'readonly', run: async () => 'p' } as ToolDef],
-  ])
-  const r = await runTurn({
-    log, turnId: 'T', tools, preset: { mode: 'full' },
-    model: async (): Promise<ModelStep> => ({ stopReason: 'toolUse', toolCalls: [
-      { id: 'c1', tool: 'probe', args: {} }, { id: 'c2', tool: 'commit', args: {} },
-    ] }),
-  })
-  assert.equal(r.reason, 'completed')
-})
-
-test('F5: terminate=AND——整批全部 terminate 才 aborted；权限门拒绝写操作', async () => {
-  const log = new SessionLog()
-  const tools = new Map([
-    ['danger', { declaredSideEffect: 'write', terminate: true, run: async () => 'never' } as ToolDef],
-  ])
-  let authorizeCalled = false
-  let n = 0
-  const r = await runTurn({
-    log, turnId: 'T', tools,
-    preset: { mode: 'confirm', authorize: async () => { authorizeCalled = true; return false } },
-    model: async (): Promise<ModelStep> => n++ === 0
-      ? { stopReason: 'toolUse', toolCalls: [{ id: 'c1', tool: 'danger', args: {} }] }
-      : { stopReason: 'stop', text: 'acknowledged' },
-  })
-  assert.equal(r.reason, 'completed') // 单工具被拒后无收口信号 → 模型继续 → stop
-  assert.equal(authorizeCalled, true)
-  const denied = log.events.some(e => e.kind === 'toolResult' && (e.payload as any)?.error === 'authorization-denied')
-  assert.ok(denied, '拒绝记录落日志')
-})
-
-// ==================== F6 装配层（Stub/invalidate/manifest） ====================
-
-test('F6: manifest 校验——version 非精确 semver = 冲突链报错', () => {
-  assert.throws(() => parseManifest({ name: 'p', version: '^1.0.0' }, 'plugin.ts'), /exact semver.*plugin\.ts/)
-  assert.throws(() => parseManifest({ version: '1.0.0' }, 'plugin.ts'), /"name" is required/)
-  assert.throws(() => parseManifest({ name: 'p', version: '1.0.0', peerPolicyOverride: { relaxed: true } as any }, 'm.ts'), /reason.*required/)
-  const ok = parseManifest({ name: 'p', version: '1.0.0' }, 'm.ts')
-  assert.equal(ok.name, 'p')
-})
-
-test('F6: Stub 占位——bindCore 前调用显式抛错，bind 后可用；invalidate 后再访问报错', async () => {
-  const file = new URL('./fixture-plugin.ts', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
-  writeFileSync(file, `export default function apply(api) {\n  api.registerTool({ name: 'tool-v1', run: async () => 'v1' })\n}\n`)
-  try {
-    const p = await mountPlugin({ file, manifest: { name: 'hot', version: '1.0.0' } })
-    // 注册类动作 Stub 期可用（收集待注册项）；能力查询 bind 前显式抛错
-    assert.throws(() => p.api.getRegisteredTools(), /CAR-STUB/)
-    const hostTools: Array<{ name: string }> = []
-    p.bindCore({
-      registerTool: (t) => { hostTools.push(t) },
-      getRegisteredTools: () => hostTools,
-    })
-    // bind 后冲刷 pending 注册
-    assert.deepEqual(p.api.getRegisteredTools().map((t) => t.name), ['tool-v1'])
-    assert.deepEqual(hostTools.map((t) => t.name), ['tool-v1'])
-    p.invalidate()
-    assert.throws(() => p.api.getRegisteredTools(), /CAR-INVALIDATED/)
-  } finally { try { rmSync(file, { force: true }) } catch {} }
-})
-
-test('F6: 热重载——同文件 epoch 击穿缓存，新代码生效 + 旧句柄失效', async () => {
-  const file = new URL('./fixture-reload.ts', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
-  let p1: Awaited<ReturnType<typeof mountPlugin>> | undefined
-  try {
-    writeFileSync(file, `export default function apply(api) { api.registerTool({ name: 'tool-v1', run: async () => 1 }) }\n`)
-    p1 = await mountPlugin({ file, manifest: { name: 'r', version: '1.0.0' } })
-    p1.bindCore({
-      registerTool(t: { name: string }) {},
-      getRegisteredTools: () => [{ name: 'tool-v1' }],
-    })
-    assert.deepEqual(p1.api.getRegisteredTools(), [{ name: 'tool-v1' }])
-    // 重写源文件 → epoch+1 重载
-    writeFileSync(file, `export default function apply(api) { api.registerTool({ name: 'tool-v2', run: async () => 2 }) }\n`)
-    const p2 = await mountPlugin({ file, manifest: { name: 'r', version: '1.0.1' }, reloadEpoch: 1 })
-    p2.bindCore({
-      registerTool(t: { name: string }) {},
-      getRegisteredTools: () => [{ name: 'tool-v2' }],
-    })
-    assert.deepEqual(p2.api.getRegisteredTools(), [{ name: 'tool-v2' }])
-    p1.invalidate()
-    assert.throws(() => p1!.api.getRegisteredTools(), /CAR-INVALIDATED/)
-  } finally {
-    try { rmSync(file, { force: true }) } catch {}
-    void p1
-  }
-})
-
-test('F6: 非工厂默认导出 = 冲突链报错', async () => {
-  const file = new URL('./fixture-bad.ts', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
-  writeFileSync(file, `export default 42\n`)
-  try {
-    await assert.rejects(() => mountPlugin({ file, manifest: { name: 'b', version: '1.0.0' } }), /default-export a factory/)
-  } finally { try { rmSync(file, { force: true }) } catch {} }
-})

package/test/s20.spec.ts

@@ -1,241 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { loadPlugins, renderLoadReport, ReloadManager, formatLoadReport, newInstallId } from '../src/load/report.ts'
-import { doctorCredentials, doctorConnectivity } from '../src/dx/doctor.ts'
-import type { LoadReportVO } from '../src/load/report.ts'
-
-// ==================== fixture 工具（红线 8：清理 try/catch 容错） ====================
-
-const PLUGIN_BODY = (tool: string) =>
-  `export default function apply(api) {\n  api.registerTool({ name: '${tool}', run: async () => 'ok' })\n}\n`
-
-function makePlugin(dir: string, file: string, manifest: Record<string, unknown>, tool: string): string {
-  const p = join(dir, file)
-  writeFileSync(p, `export const manifest = ${JSON.stringify(manifest)}\n${PLUGIN_BODY(tool)}\n`)
-  return p
-}
-
-function withTempDir(name: string, fn: (dir: string) => Promise<void> | void): Promise<void> {
-  const dir = mkdtempSync(join(tmpdir(), `car-s20-${name}-`))
-  return Promise.resolve()
-    .then(() => fn(dir))
-    .finally(() => { try { rmSync(dir, { recursive: true, force: true }) } catch { /* 红线 8：safe-delete 拦截容错 */ } })
-}
-
-const stageOf = (r: LoadReportVO, s: string) => r.stages.find(x => x.stage === s)!
-const stageNames = (r: LoadReportVO) => r.stages.map(s => `${s.stage}:${s.status}`)
-
-// ==================== 六阶段加载报告 ====================
-
-test('M6: 六阶段成功路径——全 PASS + LoadReportVO 结构对齐 §3.2.M6.3 + 拓扑序装配', async () => {
-  await withTempDir('ok', async (dir) => {
-    makePlugin(dir, 'dep-p.ts', { name: 'dep-p', version: '1.0.0' }, 'dep-tool')
-    makePlugin(dir, 'consumer.ts', { name: 'consumer', version: '2.0.0', peers: [{ peer: 'dep-p', range: '^1.0.0' }] }, 'con-tool')
-    const { report, plugins, order } = await loadPlugins({ source: dir })
-    // 结构逐字对齐：installId / startedTime(ISO) / durationMs / stages×6 / warnings
-    assert.match(report.installId, /^car-install-/)
-    assert.equal(Number.isNaN(Date.parse(report.startedTime)), false)
-    assert.equal(typeof report.durationMs, 'number')
-    assert.ok(report.durationMs >= 0)
-    assert.deepEqual(stageNames(report), [
-      'discover:PASS', 'verify:PASS', 'parse:PASS', 'validate:PASS', 'topo:PASS', 'register:PASS',
-    ])
-    assert.ok(Array.isArray(report.warnings))
-    // 拓扑序：provider（dep-p）先于 consumer
-    assert.deepEqual(order.map(m => m.name), ['dep-p', 'consumer'])
-    assert.equal(plugins.length, 2)
-    // FAIL 阶段不存在 conflicts/error；PASS 报告无 error 定位
-    for (const s of report.stages) { assert.equal(s.conflicts, undefined); assert.equal(s.error, undefined) }
-  })
-})
-
-test('M6: manifest 失败短路——parse FAIL + 文件定位 + 后续阶段 SKIPPED', async () => {
-  await withTempDir('bad-manifest', async (dir) => {
-    makePlugin(dir, 'good.ts', { name: 'good', version: '1.0.0' }, 't1')
-    makePlugin(dir, 'broken.ts', { name: 'broken', version: '^1.0.0' }, 't2') // 非精确 semver
-    const { report } = await loadPlugins({ source: dir })
-    assert.deepEqual(stageNames(report), [
-      'discover:PASS', 'verify:PASS', 'parse:FAIL', 'validate:SKIPPED', 'topo:SKIPPED', 'register:SKIPPED',
-    ])
-    const parse = stageOf(report, 'parse')
-    assert.match(parse.error!.file, /broken\.ts$/)
-    assert.match(parse.error!.reason, /CAR-E-MANIFEST.*exact semver/)
-  })
-})
-
-test('M6: peer 冲突链定位——validate FAIL 附 conflicts（文件/区间/实际版本/依赖路径）', async () => {
-  await withTempDir('peer-conflict', async (dir) => {
-    makePlugin(dir, 'dep-p.ts', { name: 'dep-p', version: '1.0.0' }, 't1')
-    makePlugin(dir, 'consumer.ts', { name: 'consumer', version: '2.0.0', peers: [{ peer: 'dep-p', range: '^2.0.0' }] }, 't2')
-    const { report } = await loadPlugins({ source: dir })
-    assert.deepEqual(stageNames(report), [
-      'discover:PASS', 'verify:PASS', 'parse:PASS', 'validate:FAIL', 'topo:SKIPPED', 'register:SKIPPED',
-    ])
-    const conflicts = stageOf(report, 'validate').conflicts!
-    assert.equal(conflicts.length, 1)
-    const c = conflicts[0]!
-    assert.match(c.file, /consumer\.ts$/)
-    assert.equal(c.peer, 'dep-p')
-    assert.equal(c.range, '^2.0.0')
-    assert.equal(c.installed, '1.0.0')
-    assert.equal(c.path, 'manifest.peers')
-  })
-})
-
-test('M6: 警告——git 直载来源 CAR-W-GIT-DIRECT（E-03）+ peer 豁免 CAR-W-PEER-EXEMPT', async () => {
-  await withTempDir('warnings', async (dir) => {
-    // git 工作树直载：目录内含 .git 即产生告警（不失败）
-    mkdirSync(join(dir, '.git'))
-    makePlugin(dir, 'p.ts', { name: 'p', version: '1.0.0' }, 't')
-    const { report: r1 } = await loadPlugins({ source: dir })
-    assert.equal(stageOf(r1, 'discover').status, 'PASS')
-    assert.ok(r1.warnings.some(w => w.startsWith('CAR-W-GIT-DIRECT')), 'git 直载告警')
-    // git URL 来源同样告警
-    const { report: r2 } = await loadPlugins({ source: dir, gitDirect: false })
-    void r2
-    const urlRes = await loadPlugins({ source: 'git+https://example.com/repo.git' })
-    assert.ok(urlRes.report.warnings.some(w => w.startsWith('CAR-W-GIT-DIRECT')))
-    // peer 豁免：relaxed + reason → 放行 + 告警留痕
-    const dir2 = mkdtempSync(join(tmpdir(), 'car-s20-exempt-'))
-    try {
-      makePlugin(dir2, 'dep-p.ts', { name: 'dep-p', version: '1.0.0' }, 't1')
-      makePlugin(dir2, 'consumer.ts', {
-        name: 'consumer', version: '2.0.0',
-        peers: [{ peer: 'dep-p', range: '^2.0.0' }],
-        peerPolicyOverride: { relaxed: true, reason: '临时对齐中，下版本收紧' },
-      })
-      const { report } = await loadPlugins({ source: dir2 })
-      assert.equal(stageOf(report, 'validate').status, 'PASS')
-      assert.ok(report.warnings.some(w => w.startsWith('CAR-W-PEER-EXEMPT')))
-    } finally { try { rmSync(dir2, { recursive: true, force: true }) } catch {} }
-  })
-})
-
-test('M6: renderLoadReport 纯函数口径——plan + 阶段结果 → VO（规格签名）', () => {
-  const startedAtMs = Date.now() - 5
-  const plan = {
-    installId: newInstallId(), source: '/x', startedTime: new Date(startedAtMs).toISOString(),
-    startedAtMs, files: [], warnings: ['w1'],
-  }
-  const vo = renderLoadReport(plan, [{ stage: 'discover', status: 'PASS' }, { stage: 'parse', status: 'SKIPPED' }])
-  assert.deepEqual(vo.warnings, ['w1'])
-  assert.equal(vo.stages.length, 2)
-  assert.ok(vo.durationMs >= 5)
-  // 计划不可变：传入数组后续修改不泄漏进 VO（冻结语义）
-  plan.warnings.push('w2')
-  assert.deepEqual(vo.warnings, ['w1'])
-})
-
-// ==================== 热重载（SQ-05） ====================
-
-test('M6: 热重载——epoch 递增、旧句柄 invalidate 后报 CAR-INVALIDATED、新实例可用', async () => {
-  await withTempDir('reload', async (dir) => {
-    const file = join(dir, 'hot.ts')
-    writeFileSync(file, `export const manifest = { name: 'hot', version: '1.0.0' }\n${PLUGIN_BODY('tool-v1')}`)
-    const mgr = new ReloadManager()
-    assert.equal(mgr.epoch, 0)
-    const r1 = await mgr.reload(file)
-    assert.equal(mgr.epoch, 1)
-    assert.deepEqual(stageNames(r1.report), ['discover:PASS', 'verify:PASS', 'parse:PASS', 'validate:PASS', 'topo:PASS', 'register:PASS'])
-    assert.equal(r1.plugins[0]!.manifest.version, '1.0.0')
-    const host1: Array<{ name: string }> = []
-    r1.plugins[0]!.bindCore({ registerTool: t => { host1.push(t) }, getRegisteredTools: () => host1 })
-    assert.deepEqual(r1.plugins[0]!.api.getRegisteredTools().map(t => t.name), ['tool-v1'])
-    // 重写源文件 → reload → epoch+1 击穿缓存，新代码生效
-    writeFileSync(file, `export const manifest = { name: 'hot', version: '1.1.0' }\n${PLUGIN_BODY('tool-v2')}`)
-    const r2 = await mgr.reload(file)
-    assert.equal(mgr.epoch, 2)
-    assert.equal(r2.plugins[0]!.manifest.version, '1.1.0')
-    const host2: Array<{ name: string }> = []
-    r2.plugins[0]!.bindCore({ registerTool: t => { host2.push(t) }, getRegisteredTools: () => host2 })
-    assert.deepEqual(r2.plugins[0]!.api.getRegisteredTools().map(t => t.name), ['tool-v2'])
-    // 旧句柄 invalidate 后访问显式报错（Stub 语义，防 stale context 误用）
-    assert.throws(() => r1.plugins[0]!.api.getRegisteredTools(), /CAR-INVALIDATED/)
-    // reload 报告留痕
-    assert.equal(mgr.history.length, 2)
-  })
-})
-
-test('M6: reload 失败路径——FAIL 报告含定位，管理器不静默回退', async () => {
-  await withTempDir('reload-fail', async (dir) => {
-    const file = join(dir, 'hot.ts')
-    writeFileSync(file, `export const manifest = { name: 'hot', version: '1.0.0' }\n${PLUGIN_BODY('t')}`)
-    const mgr = new ReloadManager()
-    await mgr.reload(file)
-    writeFileSync(file, `export const manifest = { name: 'hot', version: 'not-semver' }\n${PLUGIN_BODY('t')}`)
-    const { report, plugins } = await mgr.reload(file)
-    assert.equal(stageOf(report, 'parse').status, 'FAIL')
-    assert.match(stageOf(report, 'parse').error!.reason, /exact semver/)
-    assert.equal(plugins.length, 0, '失败重载不残留新实例')
-  })
-})
-
-// ==================== car doctor（离线可过） ====================
-
-test('M6: doctor 凭据检查——只报存在性、不打印值；离线连通性 SKIPPED 不失败', async () => {
-  const creds = doctorCredentials({ CAR_TOKEN: 'secret-value-should-never-appear' } as NodeJS.ProcessEnv)
-  assert.equal(creds.length, 2)
-  const carTok = creds.find(c => c.envVar === 'CAR_TOKEN')!
-  assert.equal(carTok.present, true)
-  const npmTok = creds.find(c => c.envVar === 'NPM_TOKEN')!
-  assert.equal(npmTok.present, false)
-  // 红线：凭据检查输出永不包含值
-  const rendered = JSON.stringify(creds)
-  assert.equal(rendered.includes('secret-value-should-never-appear'), false)
-  // 显式跳过 = SKIPPED
-  const skipped = await doctorConnectivity({ skip: true })
-  assert.equal(skipped.status, 'SKIPPED')
-  // 不可达 = SKIPPED 而非 FAIL（离线环境 doctor 整体 PASS 口径）
-  const unreachable = await doctorConnectivity({ registryUrl: 'http://127.0.0.1:1/-/ping', timeoutMs: 800 })
-  assert.equal(unreachable.status, 'SKIPPED')
-  assert.match(unreachable.detail, /显式跳过|不可达/)
-})
-
-// ==================== QS-05 加载基线（P95 ≤ 800ms，纯本地 mock 插件） ====================
-
-test('QS-05: 加载耗时基线——P95 ≤ 800ms（20 轮热重载五插件，缓存击穿口径）', async () => {
-  await withTempDir('p95', async (dir) => {
-    const N = 5
-    for (let i = 1; i <= N; i++) makePlugin(dir, `p${i}.ts`, { name: `p${i}`, version: '1.0.0' }, `tool-${i}`)
-    const mgr = new ReloadManager()
-    const runs = 20
-    const durations: number[] = []
-    for (let i = 0; i < runs; i++) {
-      const { report } = await mgr.reload(dir)
-      assert.deepEqual(stageNames(report), ['discover:PASS', 'verify:PASS', 'parse:PASS', 'validate:PASS', 'topo:PASS', 'register:PASS'])
-      durations.push(report.durationMs)
-    }
-    durations.sort((a, b) => a - b)
-    // 最近邻秩 P95（n=20 → 第 19 位，1-based）
-    const p95 = durations[Math.ceil(0.95 * runs) - 1]!
-    assert.ok(p95 <= 800, `P95=${p95}ms 应 ≤ 800ms（QS-05）；全量=${JSON.stringify(durations)}`)
-  })
-})
-
-// ==================== CLI 报告渲染（formatLoadReport 纯文本出口） ====================
-
-test('M6: formatLoadReport——PASS 摘要 + FAIL 定位 + 耗时/告警行', () => {
-  const vo: LoadReportVO = {
-    installId: 'car-install-x',
-    startedTime: new Date(0).toISOString(),
-    durationMs: 42,
-    stages: [
-      { stage: 'discover', status: 'PASS' },
-      { stage: 'parse', status: 'FAIL', error: { file: '/a/b.ts', reason: 'CAR-E-MANIFEST: boom' } },
-      { stage: 'validate', status: 'SKIPPED' },
-      { stage: 'topo', status: 'SKIPPED' },
-      { stage: 'register', status: 'SKIPPED' },
-    ],
-    warnings: ['CAR-W-GIT-DIRECT: demo'],
-  }
-  const lines = formatLoadReport(vo)
-  const all = lines.join('\n')
-  assert.match(all, /installId=car-install-x/)
-  assert.match(all, /\[parse\s*\] FAIL — CAR-E-MANIFEST: boom \(file: \/a\/b\.ts\)/)
-  assert.match(all, /\[validate\] SKIPPED/)
-  assert.match(all, /durationMs=42 warnings=1/)
-  assert.match(all, /CAR-W-GIT-DIRECT: demo/)
-})