@lqc123qwe/car-runtime 1.1.0 → 1.2.0

package/README.md

@@ -165,12 +165,24 @@ node --experimental-transform-types --test test/*.spec.ts
 
 - **1.1 工程收口（2026-09-27）**：S30 §8 工程侧清单签名收尾五子项全部兑现（plugin-sign CLI / doctor 签名行 / 配置文件通道 / mcp-serve 装载接线+采集全链 / keychain 专测）。全量 **249（246 PASS + 3 能力门控 skip / 0 fail）** + tsc strict 0 错 + secrets-scan 97 文件 0 命中（密钥/签名夹具仅运行期临时目录——R-1）。QA 两轮制执行。**CI 收官（run 36304931085）：16/16 全绿**。
 - **1.1 发布编排（S6，D-11b ①直发）**：13 门禁本地预演 **11 PASS / 2 DRY-RUN / 0 FAIL**（G-07 逃逸矩阵本机 WSL 实跑 20/20；G-09/G-10 远端口径 DRY-RUN）；version 1.1.0（`3d8658e`）已推送 main；dist 六资产就绪（tgz/bundle/SHA256SUMS/SBOM/审计/公钥）。**Release v1.1.0 创建（用户）→ j16 自动 `npm publish --provenance --tag latest` → post-publish REMOTE_CHECK=1 复跑**。
+- **1.1.0 正式发布（2026-09-27，S6 收官）**：npm `@lqc123qwe/car-runtime@1.1.0` 在架——**dist-tag latest → 1.1.0，rc 保留指向 1.0.0-rc.1**（§1.1 口径）；SLSA provenance（slsa.dev/provenance/v1）。j16 run 36305729712 success；**post-publish 复跑 12 PASS / 1 DRY-RUN / 0 FAIL（G-09 实查 PASS）** + 外部验证者等价检查（Release 实下载件 SHA256 MATCH + cosign Verified OK）+ Release 六资产公开 API 实查齐备。发布工程事件：tag 实挂 `1.1.0`（无 v 前缀）→ G-10 双形态兼容修复（`3fdedf5`，4c84b17 同类）。收口报告：`car-docs/10-内核v1/1.1-签名收口终验报告.md`。
 - **边界口径（防外推）**：mcp-serve 装载接线 = 「装载 + 采集全链」——插件 factory 执行 + bindCore 冲刷注册项真实发生；**宿主会话执行插件工具的执行接线属 W1 登记后续**（sessionTurn 仍为事件批归一化），「已实装」口径不外推。sigstore keyless 主轨 / anthropic 适配器 / W1 runTurn→chatStep 接线均为延后登记项（用户裁决 2026-09-27）。
 - **翻转排期**：**2026-12-25 到期 enforce 缺省值翻转**落 12-25 后续发版（一行缺省值变更 + 决策记录归档，部署设计 §4.5.5 既有承诺）；数据前提 T-1 阈值随本迭代宿主采集链落成可观测。规划：`car-docs/10-内核v1/1.1-迭代规划.md`；收口报告：`car-docs/10-内核v1/1.1-签名收口终验报告.md`。
 
+## 1.2 状态（会话/遥测小项 W3）
+
+| `src/session/indexStore.ts` +2 | 1.2-S1/S2：`lookupSession`（--session id → 文件；db 缺文件 CAR-E-INDEX 显式报错无建文件副作用；SQLite 惰性校验错误统一收口；未收录 = null「可索引 = 可验证」）+ `upsertSessionRow`（自举建库建表）+ `IndexUpdater`（**按行增量**——sink 先于事件入内存 fail-fast 时序下行自带 seq/hash；debounce 2s + close flush；**失败非致命**绝不阻塞 append；能力缺席显式登记一次后停用；file resolve 绝对化） | M7 §4/§5 登记后续出清 |
+| `src/cli.ts` | 1.2：session verify/replay/export 三入口 `--session <id> [--db]`（与位置路径互斥显式拒绝；缺省 db = cwd sessions-index.db）+ `car run` sink 链接 IndexUpdater + mcp-serve **OTel meter 双写桥**（S17 counters 快照面不变 + shutdown flush） | 1.2 W3-1/2/3 |
+| `src/runtime-core/telemetry.ts` | 1.2-S3 生产级策略：有界重试（429/5xx/网络 ≤2 退避 1s/2s，4xx 不重试，耗尽静默丢弃永不抛错——**D-12b 口径修订「0 重试」**，隐私三原则不变）+ 采样（always_on 缺省/always_off/{ratio} head 决策，spansSampledOut）+ 批上限（maxBatchSize 512 分批 / maxQueueSize 2048 溢出丢最旧 queueOverflows）+ `telemetryConfigFromEnv`（CAR_OTEL_ENDPOINT 唯一开关/CAR_OTEL_SAMPLING/CAR_OTEL_INTERVAL_MS；非法值保持缺省禁 fail-hard）+ **1.2-BUG-1/2 修复**（OTLP metric 名混入 labels JSON / res.ok 未判 5xx 计成功——均经生产调用点接入暴露） | M8 §4.4 登记后续出清 |
+| `test/s28-session-index-followup.spec.ts` + `test/s29-otel-producer.spec.ts` | 1.2 测试：s28 6 test（lookup 四态 / CLI 三入口真进程 / 拒绝面四情形 / updater 自举+覆盖+close / 失败非致命 / car run 索引闭环）+ s29 8 test（env 七态 / 重试四路径 / res.ok 回归钉 / 采样四态 / 分批溢出 / 默认关 / 解耦静态断言 / **mcp-serve 真进程 OTLP 出站实证**） | 1.2-GO |
+
+- **1.2 工程收口（2026-09-27）**：M7 §4/§5 + M8 §4.4 登记后续三子项全部出清。全量 **263（260 PASS + 3 能力门控 skip / 0 fail）** + tsc strict 0 错 + secrets-scan 101 文件 0 命中。QA 两轮制执行。**1.2-BUG-1（OTLP metric 名混 labels）为生产调用点核查直接产出**——meter 桥接入即暴露 M8 最小实现掩盖的缺陷。
+- **边界口径（防外推）**：OTel span 面（turn/step span）**仍无生产调用点**（随 W1 登记后续）；trace 传播（parentSpanId/共享 trace）随 W1 设计；mcp-serve 出站现仅 metrics（counter 桥）。
+- **遗留登记**：W1 = 1.3 头号候选（含 D-12a TLS loopback 豁免实装、car run 装配面重做〔demo_tool 撞名观察项出清〕）；car run demo_tool 撞名 DEPCYCLE 为预存在边缘（登记不修，W1 出清）。规划：`car-docs/10-内核v1/1.2-迭代规划.md`；收口报告：`car-docs/10-内核v1/1.2-收口终验报告.md`。
+
 ## 状态
 
-- **版本主线**：S1-S4 48/48 ｜ M2 89/89（v0.2.0）｜ M3 127/127（v0.3.0）｜ M4 139/139（**1.0.0-rc.1 已发布**）｜ M5 156/156（DEC-4 预埋项转正）｜ M6 179/179（2026-09-15 收口）｜ M7 全量 195（192 PASS + 3 能力门控 skip，2026-09-19 收口）｜ **M5-S28 装载签名门 全量 204（201 PASS + 3 skip，2026-09-26）** ｜ **M8 运行时底座 全量 231（228 PASS + 3 skip，2026-09-26 收口，§3.2 八模块全部收口）** ｜ **1.1 签名收尾最小集 全量 249（246 PASS + 3 skip，2026-09-27 工程收口，enforce 翻转准备）**
+- **版本主线**：S1-S4 48/48 ｜ M2 89/89（v0.2.0）｜ M3 127/127（v0.3.0）｜ M4 139/139（**1.0.0-rc.1 已发布**）｜ M5 156/156（DEC-4 预埋项转正）｜ M6 179/179（2026-09-15 收口）｜ M7 全量 195（192 PASS + 3 能力门控 skip，2026-09-19 收口）｜ **M5-S28 装载签名门 全量 204（201 PASS + 3 skip，2026-09-26）** ｜ **M8 运行时底座 全量 231（228 PASS + 3 skip，2026-09-26 收口，§3.2 八模块全部收口）** ｜ **1.1 签名收尾最小集 全量 249（246 PASS + 3 skip，2026-09-27 收口，1.1.0 已发布，enforce 翻转准备就绪）** ｜ **1.2 会话/遥测小项 全量 263（260 PASS + 3 skip，2026-09-27 收口，1.2.0 发布编排中）**
 - **1.0.0 正式发布（2026-09-26，S29/S30）**：npm `@lqc123qwe/car-runtime@1.0.0` 在架——**dist-tag latest → 1.0.0，rc 保留指向 1.0.0-rc.1**（§1.1 口径）；SLSA provenance（Actions OIDC，透明日志在案）；GitHub Release v1.0.0 六资产（tgz/bundle/SHA256SUMS/SBOM/审计/公钥）；**post-publish 全链 13 PASS / 0 DRY-RUN / 0 FAIL** + 外部验证者等价检查（Release 实下载件 SHA256 MATCH + cosign Verified OK）。**宽限期时钟：2026-09-26 起算，2026-12-25 到期 verifier 默认值 warn→enforce 翻转（计划内变更）**。终验报告：`car-docs/10-内核v1/M5-S30-1.0收口终验报告.md`。发布工程事件：j16 首跑 E403（npm 2FA 策略 vs granular token 无 bypass——清单预设回退路径兑现）→ bypass token re-run 绿；G-09 期望 tag 动态化（`4c84b17`）在真实发布兑现价值。
 - **1.0.0-rc.1 已发布（2026-09-09）**：npm `@lqc123qwe/car-runtime@1.0.0-rc.1`（rc + latest 双 tag，SLSA provenance 在案）+ GitHub Release 6 制品；发布预演 **13 PASS / 0 DRY-RUN / 0 FAIL**（c762b72）。S22 GO 清单已全绿收口。
 - **轨道 A 三项全部完成**：E-1 WSL2 逃逸矩阵 **20/20 PASS 零逃逸**（2026-09-07，G-07 转 PASS）｜ E-3 远端发布通道 **13/13 全门禁 PASS**（2026-09-09，G-08/09/10 转 PASS）｜ E-2 Windows koffi FFI **四判据双环境全 PASS**（S24/S25/S26，2026-09-09~10；本机非提权 + windows-latest 提权 runner 双绿，CI 门禁已接入）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lqc123qwe/car-runtime",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Composable Agent Runtime (CAR) - microkernel plugin system with sandboxed PTC, append-only hashed session log, and MCP host bridge",
   "license": "MIT",
   "type": "module",

package/scripts/release-pipeline.ts

@@ -127,8 +127,14 @@ const record = (stage: string, gate: string, ok: boolean, detail = '', dryRun =
   if (process.env.GH_TOKEN && process.env.REMOTE_CHECK === '1') {
     try {
       const ghBin = 'D:/WorkBuddy/agent/tools/bin/gh.exe'
-      const out = execFileSync(ghBin, ['api', `repos/lqc624/car-runtime/releases/tags/v${VERSION}`, '--jq', '.assets[].name'], { encoding: 'utf-8', env: process.env })
-      const assets = out.trim().split('\n').filter(Boolean)
+      // tag 形态双兼容：v 前缀（v1.0.0 惯例）与无前缀（1.1.0 实挂形态）都查，并集去重——
+      // 硬编码单形态会把真实归档误判 FAIL（4c84b17 G-09 期望 tag 动态化同类教训，2026-09-27）
+      const fetchAssets = (tag: string): string[] => {
+        try {
+          return execFileSync(ghBin, ['api', `repos/lqc624/car-runtime/releases/tags/${tag}`, '--jq', '.assets[].name'], { encoding: 'utf-8', env: process.env }).trim().split('\n').filter(Boolean)
+        } catch { return [] }
+      }
+      const assets = [...new Set([...fetchAssets(`v${VERSION}`), ...fetchAssets(VERSION)])]
       const need = [`car-runtime-${VERSION}.tgz`, `car-runtime-${VERSION}.tgz.sig.bundle`, 'SHA256SUMS', 'sbom.json', 'release-audit.jsonl', 'car-release.pub']
       const missing = need.filter(n => !assets.includes(n))
       g10Ok = missing.length === 0

package/src/cli.ts

@@ -19,6 +19,7 @@ import { SessionLog, loadSessionLog, type SessionEvent } from './session/log.ts'
 import { SessionFileStore } from './session/store.ts'
 import { compressJsonlZstd, decodeLogBuffer, zstdAvailable } from './session/format.ts'
 import { exportForensicsBundle, verifyBundle, type ExportMeta } from './session/export.ts'
+import { lookupSession, IndexUpdater, type SessionIndexRow } from './session/indexStore.ts'
 import { runTurn } from './loop/stop.ts'
 import { Context } from './kernel/context.ts'
 import { mountPlugin } from './load/loader.ts'
@@ -26,6 +27,8 @@ import { verifyPluginFile } from './load/sigGate.ts'
 import { loadCarConfig, mergeSignatureGate } from './load/config.ts'
 import { generateSigningKeypair, signPluginFile, resolveTrustRoot } from './load/sign.ts'
 import { doctorCredentials, doctorConnectivity, doctorKeychain, doctorSignature } from './dx/doctor.ts'
+import { createTelemetryFacade, telemetryConfigFromEnv } from './runtime-core/telemetry.ts'
+import type { CounterName, AllowedLabels } from './telemetry/metrics.ts'
 
 const HELP = `用法: car <command> [args]
   run <plugin.ts> [--sig-enforce] [--config <path>]
@@ -38,6 +41,8 @@ const HELP = `用法: car <command> [args]
                                     取证包导出（断链中止；落盘读回重验，离线自证）
   session rebuild-index <root> [--db <path>]
                                     从 JSONL 重建 SQLite 会话索引（幂等）
+  session verify/replay/export 均支持 --session <id> [--db <path>]
+                                    经 SQLite 索引定位会话（1.2；缺省 db = cwd sessions-index.db；索引未收录 = 显式报错）
   doctor                环境自检
   plugin-sign keygen [--out <前缀>] [--force]
                                     生成 ed25519 签名密钥对（<前缀>.priv PKCS8 DER / <前缀>.pub SPKI base64；缺省前缀 car-release）
@@ -109,7 +114,10 @@ async function main(): Promise<number> {
       const log = new SessionLog('S-' + Date.now().toString(36))
       // §3.2.M7.5「先落日志后放行」：run 流全程逐事件 fsync 落盘（append 返回 = 已过掉电窗口）
       const store = new SessionFileStore(`session-${log.sessionId}.jsonl`)
-      log.attachSink(line => store.append(line))
+      // 1.2-S2 W3-2「更新半边」：append 后按行增量入索引（sink 先于事件入内存——行自带 seq/hash；
+      // 失败非致命——索引为派生缓存，rebuild-index 兜底语义不变；SQLite 能力缺席 = 显式登记一次后停用）
+      const indexUpdater = new IndexUpdater({ dbPath: join(process.cwd(), 'sessions-index.db'), onError: e => console.error(`[index-updater] ${e.message}`) })
+      log.attachSink(line => { store.append(line); indexUpdater.record(log.sessionId, line, store.path) })
       const hostTools: any[] = []
       ctx.plugin({ name: plugin.manifest.name, apply: (c) => {
         plugin.bindCore({
@@ -133,8 +141,9 @@ async function main(): Promise<number> {
         model: async () => ({ stopReason: 'toolUse' as const, toolCalls: [{ id: 'c1', tool: 'demo_tool', args: {} }] }),
       })
       console.log(`[3/5 收口] turnEnd=${r.reason}（steps=${r.steps}）`)
-      // 环节 4：落盘收口（全程逐事件 fsync 已发生，此处仅关句柄核对）
+      // 环节 4：落盘收口（全程逐事件 fsync 已发生，此处仅关句柄核对 + 索引 pending 落盘）
       store.close()
+      await indexUpdater.close()
       console.log(`[4/5 落盘] ${store.path}（${log.events.length} 事件逐事件 fsync，哈希链 ${log.verifyChain() === null ? '完整' : '断链!'}）`)
       // 环节 5：审计回放
       const replay = log.deriveMessages()
@@ -182,7 +191,7 @@ async function main(): Promise<number> {
       for (let i = 0; i < args.length; i++) {
         const a = args[i]!
         if (a === '--zstd') flags.zstd = true
-        else if (a === '--out' || a === '--db') flags[a.slice(2)] = args[++i] ?? ''
+        else if (a === '--out' || a === '--db' || a === '--session') flags[a.slice(2)] = args[++i] ?? ''
         else positional.push(a)
       }
       // C-02 索引重建（§3.2.M7.5 Step 3「异步可容忍，丢失可 rebuild」；幂等单事务）
@@ -200,7 +209,20 @@ async function main(): Promise<number> {
           return 0
         } catch (e) { console.error((e as Error).message); return 2 }
       }
-      const file = positional[0]
+      // 1.2-S1 W3-1：--session <id> 经索引定位会话文件（与位置路径互斥，显式拒绝歧义）。
+      // db 缺省取 cwd sessions-index.db（缺文件 = CAR-E-INDEX 显式报错提示 rebuild-index）；
+      // 索引未收录 = 显式报错（「可索引 = 可验证」：断链/坏格式会话不入索引）。
+      const sessionFlag = flags.session as string | undefined
+      let file = positional[0]
+      if (sessionFlag) {
+        if (file) { console.error('文件路径与 --session 互斥——请二选一'); return 2 }
+        const dbPath = (flags.db as string) || join(process.cwd(), 'sessions-index.db')
+        let row: SessionIndexRow | null
+        try { row = await lookupSession(dbPath, sessionFlag) } catch (e) { console.error((e as Error).message); return 2 }
+        if (!row) { console.error(`会话 "${sessionFlag}" 未收录索引（可索引 = 可验证；断链/坏格式会话不入索引）——可先 car session rebuild-index`); return 2 }
+        file = row.file
+        console.log(`[index] ${sessionFlag} → ${file}（events=${row.eventCount} encoding=${row.encoding}）`)
+      }
       if (!file) { console.error('缺少文件参数'); return 2 }
       if (sub === 'export' && !flags.out) { console.error('缺少 --out 目录参数'); return 2 }
       let loaded: ReturnType<typeof loadSessionLog>
@@ -293,14 +315,22 @@ async function main(): Promise<number> {
       const pluginsArg = collectPluginSources(rest)
       if (pluginsArg.error) { console.error(pluginsArg.error); return 2 }
       const { createCounters, assertZeroContent } = await import('./telemetry/metrics.ts')
+      // 1.2-S3 W3-3：OTel 门面经 env 通道（CAR_OTEL_ENDPOINT 唯一开关；缺省关 = noop 零出站）+
+      // S17 counters **双写桥**——快照面（登记表兜底通道）不变，meter 出站为加法通道；
+      // labels 为零内容枚举（metrics.ts AllowedLabels），出站同口径
+      const otel = createTelemetryFacade(telemetryConfigFromEnv())
       const counters = createCounters()
+      const onCount = (name: CounterName, labels?: AllowedLabels): void => {
+        counters.onCount(name, labels)
+        if (otel.enabled) otel.getMeter().createCounter(name).add(1, labels as Record<string, string> | undefined)
+      }
       if (pluginsArg.sources.length) {
         const { loadPlugins, formatLoadReport } = await import('./load/report.ts')
         const { Context } = await import('./kernel/context.ts')
         const ctx = new Context()
         const hostTools: any[] = []
         for (const src of pluginsArg.sources) {
-          const result = await loadPlugins({ source: src, signature: { ...sig.options, onCount: (n, l) => counters.onCount(n, l) } })
+          const result = await loadPlugins({ source: src, signature: { ...sig.options, onCount: (n, l) => onCount(n, l) } })
           if (result.report.stages.some(s => s.status === 'FAIL')) {
             // 加载期显式失败红线（两模式一致）：FAIL = 插件未装上，服务不得静默缺插件启动。
             // DEC-1 warn/enforce 之分仅在签名门缺签路径（warn=横幅放行，enforce=verify FAIL 走此分支）
@@ -326,13 +356,18 @@ async function main(): Promise<number> {
       const { createStdioServer } = await import('./host/stdio.ts')
       const profiles = new Map(HOST_MAPPINGS.map(h => [h.hostId, h]))
       const facade = createRuntimeFacade({ profiles })
-      const gw = new HostGateway({ facade, audit: e => counters.onCount('car_registry_decision', { source: 'registry' }) })
+      const gw = new HostGateway({ facade, audit: e => onCount('car_registry_decision', { source: 'registry' }) })
       for (const h of HOST_MAPPINGS) gw.registerHost({ hostId: h.hostId, profile: h, transport: {} as never })
       const server = createStdioServer((tool, args) => gw.handle(hostId, tool, args))
       const n = await server.serve(process.stdin, process.stdout)
       // 采集窗口收口（登记表兜底通道）：快照写 stderr（stdout 为协议通道不可污染）
       const snap = counters.snapshot()
       console.error(`[car mcp-serve] host=${hostId} requests=${n} snapshot=${JSON.stringify(snap)} zeroContent=${assertZeroContent(snap)}`)
+      // 1.2-S3：OTel 显式开路径收口 flush（shutdown = flush + 停 interval；缺省关为空转）
+      if (otel.enabled) {
+        await otel.shutdown()
+        console.error(`[car mcp-serve] otel=enabled stats=${JSON.stringify(otel.stats())}`)
+      }
       return 0
     }
     case 'plugin-sign': {

package/src/runtime-core/telemetry.ts

@@ -4,8 +4,17 @@
  * 口径（§3.2.M8.5 关键约束，逐条落地）：
  *  - 默认关：无端点配置时不初始化任何 exporter——无配置 = noop 句柄 + 零出站（可机器断言）；
  *  - 显式开：用户配置端点即视为开启（CAR_OTEL_ENDPOINT 或显式 config 传入）；
- *  - 端点归用户：数据只发往用户自配 E-05；OTLP/HTTP JSON（fetch），导出超时 5s、0 重试、
- *    端点不可达静默丢弃（BD-05——不抛错、不重试、不落审计）；
+ *  - 端点归用户：数据只发往用户自配 E-05；OTLP/HTTP JSON（fetch），导出超时 5s；
+ *    1.2-S3 生产级策略（D-12b 口径修订，2026-09-27）：**0 重试 → 有界重试 ≤2**（仅 429/5xx/
+ *    网络错误，退避 1s/2s；4xx 业务错不重试）——重试耗尽静默丢弃 + droppedExports 计数，
+ *    永不抛错（BD-05「不抛错、不落审计」收紧保持）；隐私三原则不变（数据仍只发用户自配端点）；
+ *  - 采样（1.2-S3 加法）：head 采样于 span.end() 决策——always_on（缺省，全量，1.1 行为不变）/
+ *    always_off / { ratio }（概率）；被采出计入 spansSampledOut；采样只减少出站数据（隐私正向）；
+ *  - 批处理上限（1.2-S3 加法）：maxBatchSize 单请求分批（512）+ maxQueueSize buffer 上限
+ *    （2048，溢出丢最旧 + queueOverflows 计数）——内存有界；
+ *  - env 通道（1.2-S3 加法）：telemetryConfigFromEnv——CAR_OTEL_ENDPOINT（唯一开关）/
+ *    CAR_OTEL_SAMPLING（always_on|always_off|0..1，非法值保持缺省——遥测面禁 fail-hard）/
+ *    CAR_OTEL_INTERVAL_MS / CAR_OTEL_SERVICE_NAME；
  *  - 严格解耦：本文件零 import 自 session/*（遥测与审计日志禁止混流）——测试做静态断言；
  *  - S17 零内容计数器（telemetry/metrics.ts）是登记表兜底通道，与本门面并存互补：
  *    本面是 OTel 形态的出站通道，不承接 S17 的零内容红线语义（内容治理属调用方）；
@@ -14,6 +23,8 @@
  */
 import { randomBytes } from 'node:crypto'
 
+export type SamplingSpec = 'always_on' | 'always_off' | { ratio: number }
+
 export interface TelemetryConfig {
   /** 用户自配 OTLP/HTTP 端点（如 https://otel.example.internal）——无值 = 默认关 */
   endpoint?: string
@@ -23,6 +34,19 @@ export interface TelemetryConfig {
   exportTimeoutMs?: number
   /** 自动导出间隔 ms；0（缺省）= 仅手动 flush（测试/收口时点调用） */
   intervalMs?: number
+  // —— 1.2-S3 生产级策略（加法；缺省值保持 1.1 行为）——
+  /** 有界重试上限（仅 429/5xx/网络错误；§3.5.4 基线 ≤2；D-12b 口径修订） */
+  retryLimit?: number
+  /** 重试退避序列 ms（缺省 [1000, 2000]；测试可注入） */
+  retryBackoffMs?: number[]
+  /** 采样（缺省 always_on = 全量）；head 决策于 span.end() */
+  sampling?: SamplingSpec
+  /** 单请求 spans 上限（超限分批；缺省 512） */
+  maxBatchSize?: number
+  /** span buffer 上限（溢出丢最旧 + queueOverflows 计数；缺省 2048） */
+  maxQueueSize?: number
+  /** 测试注入睡眠（退避可观测；缺省真实定时器） */
+  sleep?: (ms: number) => Promise<void>
 }
 
 export interface TelemetrySpan {
@@ -47,9 +71,14 @@ export interface TelemetryMeter {
 
 export interface TelemetryStats {
   spansEnded: number
+  /** 1.2-S3 加法：head 采样被采出的 span 数（缺省 always_on 下恒 0） */
+  spansSampledOut: number
+  /** 成功出站的 OTLP 请求计数（traces/metrics 分批后按请求计） */
   tracesExported: number
   metricsExported: number
   droppedExports: number
+  /** 1.2-S3 加法：buffer 溢出丢最旧计数（maxQueueSize 上限） */
+  queueOverflows: number
 }
 
 export interface TelemetryFacade {
@@ -76,6 +105,33 @@ const noopSpan = (): TelemetrySpan => ({
 })
 const NOOP_TRACER: TelemetryTracer = { startSpan: () => noopSpan() }
 const NOOP_METER: TelemetryMeter = { createCounter: () => ({ add() {} }) }
+const NOOP_STATS: TelemetryStats = { spansEnded: 0, spansSampledOut: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0, queueOverflows: 0 }
+
+/**
+ * 1.2-S3 env 配置通道：CAR_OTEL_ENDPOINT（唯一开关）/ CAR_OTEL_SAMPLING（always_on|always_off|0..1，
+ * 非法值保持缺省 always_on——遥测面禁 fail-hard）/ CAR_OTEL_INTERVAL_MS / CAR_OTEL_SERVICE_NAME。
+ * 无 endpoint = null（默认关，noop 门面）。
+ */
+export function telemetryConfigFromEnv(env: NodeJS.ProcessEnv = process.env): TelemetryConfig | null {
+  const endpoint = env.CAR_OTEL_ENDPOINT
+  if (!endpoint) return null
+  const cfg: TelemetryConfig = { endpoint }
+  if (env.CAR_OTEL_SERVICE_NAME) cfg.serviceName = env.CAR_OTEL_SERVICE_NAME
+  if (env.CAR_OTEL_INTERVAL_MS) {
+    const n = Number(env.CAR_OTEL_INTERVAL_MS)
+    if (Number.isFinite(n) && n >= 0) cfg.intervalMs = n
+  }
+  if (env.CAR_OTEL_SAMPLING) {
+    const s = env.CAR_OTEL_SAMPLING
+    if (s === 'always_on' || s === 'always_off') cfg.sampling = s
+    else {
+      const r = Number(s)
+      if (Number.isFinite(r) && r >= 0 && r <= 1) cfg.sampling = { ratio: r }
+      // 非法采样值：保持缺省 always_on（登记口径，禁 fail-hard）
+    }
+  }
+  return cfg
+}
 
 // ==================== 活动门面（显式开路径） ====================
 
@@ -104,36 +160,61 @@ export function createTelemetryFacade(
       getMeter: () => NOOP_METER,
       flush: async () => {},
       shutdown: async () => {},
-      stats: () => ({ spansEnded: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0 }),
+      stats: () => ({ ...NOOP_STATS }),
     }
   }
 
   const fetchImpl = opts.fetchImpl ?? fetch
   const now = opts.now ?? Date.now
+  const sleep = config?.sleep ?? (ms => new Promise<void>(r => setTimeout(r, ms)))
   const timeoutMs = config?.exportTimeoutMs ?? 5_000
+  const retryLimit = config?.retryLimit ?? 2
+  const backoff = config?.retryBackoffMs ?? [1_000, 2_000]
+  const sampling = config?.sampling ?? 'always_on'
+  const maxBatchSize = config?.maxBatchSize ?? 512
+  const maxQueueSize = config?.maxQueueSize ?? 2_048
   const baseHeaders = { 'content-type': 'application/json', ...(config?.headers ?? {}) }
   const serviceName = config?.serviceName ?? 'car-runtime'
 
   const spans: SpanRecord[] = []
-  const counters = new Map<string, { labels: Record<string, string>; value: number }>()
-  const stats: TelemetryStats = { spansEnded: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0 }
+  // 计数器键 = name+labels JSON（聚合去重）；记录体分离保存 name/labels——
+  // OTLP metric 名必须是纯 name（1.2-BUG-3：键直当名会把 labels JSON 拼进 metric 名，
+  // M8 最小实现即存在，meter 零生产调用点掩盖至今，1.2-S3 meter 桥接入时暴露）
+  const counters = new Map<string, { name: string; labels: Record<string, string>; value: number }>()
+  const stats: TelemetryStats = { spansEnded: 0, spansSampledOut: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0, queueOverflows: 0 }
   let tracer: TelemetryTracer | null = null
   let meter: TelemetryMeter | null = null
   let timer: ReturnType<typeof setInterval> | null = null
   let flushing = false
 
+  /**
+   * OTLP 出站（D-12b 口径：有界重试）——ok / 429/5xx/网络错误退避重试 ≤retryLimit /
+   * 4xx 业务错不重试（端点配置类问题，重试无益）；重试耗尽返回 false 由调用方计入
+   * droppedExports（静默丢弃，永不抛错——BD-05「不抛错」收紧保持）。
+   */
   const exportOtlp = async (path: string, body: unknown): Promise<boolean> => {
-    try {
-      // 单次尝试 + 有界超时（§3.5.4：OTel 导出 5s / 0 重试）；失败静默丢弃（BD-05）
-      await fetchImpl(endpoint + path, {
-        method: 'POST',
-        headers: baseHeaders,
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(timeoutMs),
-      })
-      return true
-    } catch {
-      return false
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const res = await fetchImpl(endpoint + path, {
+          method: 'POST',
+          headers: baseHeaders,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs),
+        })
+        if (res.ok) return true
+        if ((res.status === 429 || res.status >= 500) && attempt < retryLimit) {
+          await sleep(backoff[Math.min(attempt, backoff.length - 1)]!)
+          continue
+        }
+        return false
+      } catch {
+        // 网络错误/超时：可重试类
+        if (attempt < retryLimit) {
+          await sleep(backoff[Math.min(attempt, backoff.length - 1)]!)
+          continue
+        }
+        return false
+      }
     }
   }
 
@@ -141,13 +222,15 @@ export function createTelemetryFacade(
     if (flushing) return
     flushing = true
     try {
-      const spanBatch = spans.splice(0, spans.length)
-      if (spanBatch.length) {
+      const spanQueue = spans.splice(0, spans.length)
+      // maxBatchSize 分批（1.2-S3）：tracesExported 按成功出站请求计数
+      for (let i = 0; i < spanQueue.length; i += maxBatchSize) {
+        const batch = spanQueue.slice(i, i + maxBatchSize)
         const body = {
           resource: { attributes: [{ key: 'service.name', value: { stringValue: serviceName } }] },
           scopeSpans: [{
             scope: { name: 'car-runtime' },
-            spans: spanBatch.map(s => ({
+            spans: batch.map(s => ({
               traceId: s.traceId,
               spanId: s.spanId,
               ...(s.parentSpanId ? { parentSpanId: s.parentSpanId } : {}),
@@ -170,8 +253,8 @@ export function createTelemetryFacade(
           resource: { attributes: [{ key: 'service.name', value: { stringValue: serviceName } }] },
           scopeMetrics: [{
             scope: { name: 'car-runtime' },
-            metrics: batch.map(([name, c]) => ({
-              name,
+            metrics: batch.map(([, c]) => ({
+              name: c.name,
               sum: {
                 aggregationTemporality: 'AGGREGATION_TEMPORALITY_CUMULATIVE',
                 dataPoints: Object.entries(c.labels).length
@@ -209,8 +292,15 @@ export function createTelemetryFacade(
         recordException(err) { record.attributes['exception.message'] = String((err as Error)?.message ?? err); return this },
         end() {
           record.endMs = now()
-          spans.push(record)
           stats.spansEnded++
+          // head 采样于 end() 决策（1.2-S3）：缺省 always_on 全量（1.1 行为不变）；采样只减少出站
+          const keep = sampling === 'always_on' ? true
+            : sampling === 'always_off' ? false
+            : Math.random() < sampling.ratio
+          if (!keep) { stats.spansSampledOut++; return }
+          // buffer 上限：溢出丢最旧 + 计数（内存有界）
+          if (spans.length >= maxQueueSize) { spans.shift(); stats.queueOverflows++ }
+          spans.push(record)
         },
       }
     },
@@ -221,7 +311,7 @@ export function createTelemetryFacade(
       return {
         add(value, labels = {}) {
           const key = name + JSON.stringify(labels)
-          const cur = counters.get(key) ?? { labels, value: 0 }
+          const cur = counters.get(key) ?? { name, labels, value: 0 }
           cur.value += value
           counters.set(key, cur)
         },

package/src/session/indexStore.ts

@@ -8,8 +8,8 @@
  *    索引只收录链完整会话（审计面口径：可索引 = 可验证）；
  *  - 物理编码 layout-blind：plain / zstd 统一经 format.ts 装载，索引记录 encoding 供检索。
  */
-import { readdirSync } from 'node:fs'
-import { join } from 'node:path'
+import { readdirSync, existsSync, realpathSync } from 'node:fs'
+import { join, resolve } from 'node:path'
 import { loadSessionLog, type SessionEvent } from './log.ts'
 
 export interface SessionIndexRow {
@@ -31,14 +31,189 @@ export interface RebuildResult {
 }
 
 type SqliteValue = string | number | null
-interface SqliteStmt { run(...v: SqliteValue[]): unknown }
+interface SqliteStmt { run(...v: SqliteValue[]): unknown; get(...v: SqliteValue[]): unknown }
 interface SqliteDb { exec(sql: string): void; prepare(sql: string): SqliteStmt; close(): void }
 
+const CAR_E_SQLITE = 'CAR-E-SQLITE: 当前 Node 无 node:sqlite 能力（22.5+ 需 --experimental-sqlite，23.4+ 原生）——显式拒绝，不静默降级'
+
 /** node:sqlite 能力探测（模块存在性；静态 import 在无能力 Node 上会崩模块加载，故动态） */
 export async function sqliteAvailable(): Promise<boolean> {
   try { await import('node:sqlite'); return true } catch { return false }
 }
 
+/** 打开索引库（db 文件必须已存在——lookup 不产生建文件副作用；open 失败 = 索引文件无效显式报错） */
+async function openExistingDb(dbPath: string): Promise<SqliteDb> {
+  if (!existsSync(dbPath)) {
+    throw new Error(`CAR-E-INDEX: 会话索引不存在：${dbPath}——先执行 car session rebuild-index 建立索引`)
+  }
+  const mod = await import('node:sqlite').catch(() => null)
+  if (!mod) throw new Error(CAR_E_SQLITE)
+  const DatabaseSync = (mod as unknown as { DatabaseSync: new (path: string) => SqliteDb }).DatabaseSync
+  try {
+    return new DatabaseSync(dbPath)
+  } catch (e) {
+    throw new Error(`CAR-E-INDEX: 索引文件无效（打开失败：${(e as Error).message}）：${dbPath}`)
+  }
+}
+
+/** 单会话检索（1.2-S1 W3-1）：--session <id> 经索引解析 sessionId → 文件；未收录 = null（「可索引 = 可验证」口径——断链会话不入索引） */
+export async function lookupSession(dbPath: string, sessionId: string): Promise<SessionIndexRow | null> {
+  const db = await openExistingDb(dbPath)
+  try {
+    const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'").get()
+    if (!table) throw new Error(`CAR-E-INDEX: 索引文件无效（无 sessions 表）：${dbPath}`)
+    const row = db.prepare('SELECT * FROM sessions WHERE sessionId = ?').get(sessionId) as Record<string, SqliteValue> | undefined
+    if (!row) return null
+    return {
+      sessionId: String(row.sessionId),
+      file: String(row.file),
+      eventCount: Number(row.eventCount),
+      chainHead: row.chainHead == null ? null : String(row.chainHead),
+      chainTail: row.chainTail == null ? null : String(row.chainTail),
+      firstTs: row.firstTs == null ? null : Number(row.firstTs),
+      lastTs: row.lastTs == null ? null : Number(row.lastTs),
+      tornTail: Number(row.tornTail) === 1,
+      encoding: row.encoding === 'zstd' ? 'zstd' : 'plain',
+    }
+  } catch (e) {
+    const msg = (e as Error).message
+    if (msg.startsWith('CAR-E-')) throw e // 本层显式错误原样透传
+    // SQLite 惰性校验：非索引文件 open 不报错、query 才报（file is not a database）——统一收口为显式口径
+    throw new Error(`CAR-E-INDEX: 索引文件无效（${msg}）：${dbPath}`)
+  } finally {
+    db.close()
+  }
+}
+
+const CREATE_SESSIONS_SQL = `CREATE TABLE IF NOT EXISTS sessions (
+  sessionId TEXT PRIMARY KEY,
+  file TEXT NOT NULL,
+  eventCount INTEGER NOT NULL,
+  chainHead TEXT,
+  chainTail TEXT,
+  firstTs INTEGER,
+  lastTs INTEGER,
+  tornTail INTEGER NOT NULL DEFAULT 0,
+  encoding TEXT NOT NULL DEFAULT 'plain',
+  rebuiltAt TEXT NOT NULL
+)`
+
+/** 单行增量 upsert（1.2-S2 W3-2「更新半边」）：库/表不存在则自举创建（活会话无需先 rebuild 即可入索引） */
+export async function upsertSessionRow(dbPath: string, row: SessionIndexRow): Promise<void> {
+  const mod = await import('node:sqlite').catch(() => null)
+  if (!mod) throw new Error(CAR_E_SQLITE)
+  const DatabaseSync = (mod as unknown as { DatabaseSync: new (path: string) => SqliteDb }).DatabaseSync
+  try {
+    const db = new DatabaseSync(dbPath)
+    try {
+      db.exec(CREATE_SESSIONS_SQL)
+      db.prepare(
+        'INSERT OR REPLACE INTO sessions (sessionId, file, eventCount, chainHead, chainTail, firstTs, lastTs, tornTail, encoding, rebuiltAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+      ).run(row.sessionId, row.file, row.eventCount, row.chainHead, row.chainTail, row.firstTs, row.lastTs, row.tornTail ? 1 : 0, row.encoding, new Date().toISOString())
+    } finally {
+      db.close()
+    }
+  } catch (e) {
+    const msg = (e as Error).message
+    if (msg.startsWith('CAR-E-')) throw e
+    throw new Error(`CAR-E-INDEX: 索引更新失败（${msg}）：${dbPath}`)
+  }
+}
+
+/**
+ * 运行时索引更新器（1.2-S2 W3-2）：file-backed 会话 append 后的异步增量通道。
+ *
+ * 口径（M7 §4.2 登记 + 1.2 规划 R-2）：
+ *  - 按行增量：SessionLog.append 的 sink 先于事件入内存调用（fail-fast 语义），故 record
+ *    直接收行 JSON——seq/ts/hash 取自行数据（seq 权威：eventCount = seq+1），不读内存快照；
+ *  - debounce 合并：窗口内多次 append 只落一次 upsert（行状态由最新 append 覆盖）；
+ *  - 失败非致命：upsert 任何错误经 onError 留痕并计数，绝不向 append 路径传播——
+ *    索引是派生缓存，丢失由 rebuild-index 兜底（语义自洽，M7 已登记）；
+ *  - SQLite 能力缺席：首次 flush 显式登记一次后停用（非静默，后续 record 不再调度）；
+ *  - 活会话行口径：tornTail=false（按构造完整）、encoding='plain'（zstd 定位归档/导出，M7 W3）。
+ */
+interface PendingState {
+  sessionId: string
+  file: string
+  eventCount: number
+  chainHead: string
+  chainTail: string
+  firstTs: number
+  lastTs: number
+}
+
+export class IndexUpdater {
+  readonly #dbPath: string
+  readonly #debounceMs: number
+  readonly #onError: (e: Error) => void
+  #state: PendingState | null = null
+  #timer: ReturnType<typeof setTimeout> | null = null
+  #capabilityMissing = false
+  #updates = 0
+  #failures = 0
+
+  constructor(opts: { dbPath: string; debounceMs?: number; onError?: (e: Error) => void }) {
+    this.#dbPath = opts.dbPath
+    this.#debounceMs = opts.debounceMs ?? 2_000
+    this.#onError = opts.onError ?? (e => { try { console.error(`[index-updater] ${e.message}`) } catch { /* 收口期 stderr 不可用 */ } })
+  }
+
+  get stats(): { updates: number; failures: number } {
+    return { updates: this.#updates, failures: this.#failures }
+  }
+
+  /** append sink 链上调用（行 JSON）：seq 权威增量；非预期行防御性忽略 */
+  record(sessionId: string, line: string, file: string): void {
+    if (this.#capabilityMissing) return
+    let e: { seq?: unknown; ts?: unknown; hash?: unknown }
+    try { e = JSON.parse(line) as { seq?: unknown; ts?: unknown; hash?: unknown } } catch { return }
+    const seq = Number(e.seq)
+    const ts = Number(e.ts)
+    const hash = typeof e.hash === 'string' ? e.hash : ''
+    if (!Number.isFinite(seq) || !Number.isFinite(ts) || !hash) return
+    // realpath 规范化（1.2-BUG-4）：macOS tmpdir 为 symlink（/var → /private/var），子进程 cwd 由
+    // OS 返回物理路径——resolve() 不解析符号链接，父子进程会产出同一文件的两个别名形态；
+    // 入库统一为 realpath（文件刚被 append 过必存在；异常回退 resolve）
+    const canonical = (() => {
+      try { return realpathSync(file) } catch { return resolve(file) }
+    })()
+    const s = this.#state
+    if (!s || s.sessionId !== sessionId || s.file !== canonical) {
+      this.#state = { sessionId, file: canonical, eventCount: seq + 1, chainHead: hash, chainTail: hash, firstTs: ts, lastTs: ts }
+    } else {
+      s.eventCount = Math.max(s.eventCount, seq + 1)
+      s.chainTail = hash
+      s.lastTs = ts
+    }
+    this.#timer ??= setTimeout(() => { void this.flush() }, this.#debounceMs)
+  }
+
+  /** 立即落 pending（close/exit 时点调用；幂等——无 pending 即空转） */
+  async flush(): Promise<void> {
+    if (this.#timer) { clearTimeout(this.#timer); this.#timer = null }
+    if (!this.#state) return
+    const s = this.#state
+    const row: SessionIndexRow = { ...s, tornTail: false, encoding: 'plain' }
+    try {
+      await upsertSessionRow(this.#dbPath, row)
+      this.#updates++
+    } catch (e) {
+      this.#failures++
+      const msg = (e as Error).message
+      if (msg.startsWith('CAR-E-SQLITE')) {
+        // 能力缺席：登记一次后停用（后续 record 不再调度——禁每窗口重复刷屏）
+        this.#capabilityMissing = true
+      }
+      this.#onError(e as Error)
+    }
+  }
+
+  /** 收口：取消未决 timer + 落 pending（car run 关句柄前调用） */
+  async close(): Promise<void> {
+    await this.flush()
+  }
+}
+
 function scanLogFiles(root: string): string[] {
   const rels = readdirSync(root, { recursive: true }) as string[]
   return rels

package/test/s25-m8-runtime-core.spec.ts

@@ -198,7 +198,8 @@ test('M8: 遥测默认关——noop 句柄 + 零出站 + 零积累（可机器
   t.getMeter().createCounter('c').add(1)
   await t.flush()
   await t.shutdown()
-  assert.deepEqual(t.stats(), { spansEnded: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0 })
+  // 1.2-S3 stats 加法字段（spansSampledOut/queueOverflows）——noop 全零意图不变
+  assert.deepEqual(t.stats(), { spansEnded: 0, spansSampledOut: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0, queueOverflows: 0 })
 })
 
 test('M8: 遥测显式开——OTLP/HTTP 形状出站 + stats + 端点不可达静默丢弃（BD-05）', async () => {

package/test/s28-session-index-followup.spec.ts

@@ -0,0 +1,236 @@
+/**
+ * 1.2 · 会话索引后续项（S28）：--session id 经索引定位（W3-1）+ 运行时异步索引更新（W3-2）
+ *
+ * 覆盖（1.2-迭代规划 W3-1/W3-2；M7 §4/§5 登记后续出清）：
+ *  - lookupSession：命中全字段还原 / 未收录 null / 索引不存在 / 索引文件无效显式报错
+ *  - CLI 三入口 --session 全链：verify / replay / export 经索引定位；互斥、缺 db、未收录显式报错
+ *  - IndexUpdater：append → flush → 索引可见（自举建库建表）；快照覆盖；close flush；失败非致命
+ *  - 生产调用点：car run 真进程 append → sessions-index.db 自动可见（「更新半边」闭环）
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { SessionLog } from '../src/session/log.ts'
+import { SessionFileStore } from '../src/session/store.ts'
+import { rebuildIndex, lookupSession, IndexUpdater } from '../src/session/indexStore.ts'
+
+const CLI = join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'cli.ts')
+
+function withTempDir(name: string, fn: (dir: string) => Promise<void> | void): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), `car-s28-${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
+  }
+}
+
+/** 写一个链完整会话文件（car run 同构：log + attachSink(fs store)），返回 sessionId */
+function makeSession(dir: string, file: string, sessionId: string, turns = 2): string {
+  const log = new SessionLog(sessionId)
+  const store = new SessionFileStore(join(dir, file))
+  log.attachSink(line => store.append(line))
+  for (let i = 0; i < turns; i++) {
+    log.append('user', 'user', `T${i}`, `question ${i}`)
+    log.append('model', 'assistant', `T${i}`, `answer ${i}`)
+  }
+  store.close()
+  return sessionId
+}
+
+function car(args: string[], opts: { cwd?: string } = {}): Promise<{ code: number; stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, ['--experimental-transform-types', CLI, ...args], { cwd: opts.cwd, stdio: ['ignore', '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', code => resolve({ code: code ?? -1, stdout: out, stderr: err }))
+  })
+}
+
+// ==================== lookupSession（W3-1） ====================
+
+test('S28: lookupSession——命中全字段还原 / 未收录 null / 索引不存在 / 索引文件无效显式报错', async () => {
+  await withTempDir('lookup', async dir => {
+    makeSession(dir, 'session-S-lookup-a.jsonl', 'S-lookup-a')
+    makeSession(dir, 'session-S-lookup-b.jsonl', 'S-lookup-b')
+    const dbPath = join(dir, 'sessions-index.db')
+    const r = await rebuildIndex(dir, dbPath)
+    assert.equal(r.errors.length, 0)
+
+    const hit = await lookupSession(dbPath, 'S-lookup-a')
+    assert.ok(hit)
+    assert.equal(hit.sessionId, 'S-lookup-a')
+    assert.equal(hit.file, join(dir, 'session-S-lookup-a.jsonl'))
+    assert.equal(hit.eventCount, 4)
+    assert.equal(hit.tornTail, false)
+    assert.equal(hit.encoding, 'plain')
+
+    assert.equal(await lookupSession(dbPath, 'S-missing'), null, '未收录 = null（可索引 = 可验证）')
+
+    await assert.rejects(
+      () => lookupSession(join(dir, 'nope.db'), 'S-lookup-a'),
+      /CAR-E-INDEX: 会话索引不存在/,
+      'db 缺文件显式报错（lookup 不产生建文件副作用）',
+    )
+
+    const bad = join(dir, 'bad.db')
+    writeFileSync(bad, 'this is not a sqlite database')
+    await assert.rejects(() => lookupSession(bad, 'S-lookup-a'), /CAR-E-INDEX: 索引文件无效/)
+  })
+})
+
+test('S28: CLI --session 三入口——verify/replay/export 经索引定位全链（真进程）', async () => {
+  await withTempDir('cli-session-flag', async dir => {
+    const sid = makeSession(dir, 'session-S-cli-s1.jsonl', 'S-cli-s1')
+    await rebuildIndex(dir, join(dir, 'sessions-index.db'))
+
+    const v = await car(['session', 'verify', '--session', sid, '--db', 'sessions-index.db'], { cwd: dir })
+    assert.equal(v.code, 0, v.stderr)
+    assert.match(v.stdout, /哈希链完整：4 事件/)
+
+    const rp = await car(['session', 'replay', '--session', sid, '--db', 'sessions-index.db'], { cwd: dir })
+    assert.equal(rp.code, 0, rp.stderr)
+    assert.match(rp.stdout, /"role":"user"/)
+    assert.match(rp.stdout, /answer 1/)
+
+    const ex = await car(['session', 'export', '--session', sid, '--out', 'out-bundle', '--db', 'sessions-index.db'], { cwd: dir })
+    assert.equal(ex.code, 0, ex.stderr)
+    assert.match(ex.stdout, /取证包导出：4 事件/)
+    assert.ok(existsSync(join(dir, 'out-bundle', 'manifest.json')))
+  })
+})
+
+test('S28: CLI --session 显式拒绝面——与位置路径互斥 / 缺 db / 未收录 / 坏格式会话不入索引（真进程）', async () => {
+  await withTempDir('cli-session-flag-reject', async dir => {
+    const sid = makeSession(dir, 'session-S-cli-r1.jsonl', 'S-cli-r1')
+    // 与位置路径互斥
+    const both = await car(['session', 'verify', 's1.jsonl', '--session', sid, '--db', 'sessions-index.db'], { cwd: dir })
+    assert.equal(both.code, 2)
+    assert.match(both.stderr, /互斥/)
+    // 未建索引 + cwd 无 sessions-index.db → 显式报错提示 rebuild
+    const nodb = await car(['session', 'verify', '--session', sid], { cwd: dir })
+    assert.equal(nodb.code, 2)
+    assert.match(nodb.stderr, /CAR-E-INDEX: 会话索引不存在/)
+    // 建索引后查不存在的 id → 未收录显式报错
+    await rebuildIndex(dir, join(dir, 'sessions-index.db'))
+    const miss = await car(['session', 'verify', '--session', 'S-absent', '--db', 'sessions-index.db'], { cwd: dir })
+    assert.equal(miss.code, 2)
+    assert.match(miss.stderr, /未收录索引/)
+    // 坏格式会话（完整非法行）不入索引（「可索引 = 可验证」）→ --session 定位失败
+    const bf = join(dir, 'session-S-broken.jsonl')
+    makeSession(dir, 'session-S-broken.jsonl', 'S-broken')
+    writeFileSync(bf, readFileSync(bf, 'utf-8') + 'not-a-json-line\n')
+    const rb = await rebuildIndex(dir, join(dir, 'broken.db'))
+    assert.equal(rb.rows.some(r => r.sessionId === 'S-broken'), false, '坏格式文件不入索引（errors 通道）')
+    assert.equal(rb.errors.length, 1)
+    const broken = await car(['session', 'verify', '--session', 'S-broken', '--db', 'broken.db'], { cwd: dir })
+    assert.equal(broken.code, 2)
+    assert.match(broken.stderr, /未收录索引/)
+  })
+})
+
+// ==================== IndexUpdater（W3-2） ====================
+
+test('S28: IndexUpdater——append 后 flush 索引可见（自举建库建表）/ 快照覆盖 / close flush（真 sqlite）', async () => {
+  await withTempDir('updater', async dir => {
+    const dbPath = join(dir, 'sessions-index.db')
+    const log = new SessionLog('S-updater-1')
+    const store = new SessionFileStore(join(dir, 'session-S-updater-1.jsonl'))
+    const file = join(dir, 'session-S-updater-1.jsonl')
+    const updater = new IndexUpdater({ dbPath, debounceMs: 30 })
+    // 单 sink 语义（SessionLog.attachSink 覆盖式）——更新器经链式包装接入，不改日志层；
+    // sink 先于事件入内存（fail-fast），故 record 按行增量（seq/hash 自行数据）
+    log.attachSink(line => { store.append(line); updater.record('S-updater-1', line, file) })
+
+    log.append('user', 'user', 'T0', 'q0')
+    await updater.flush()
+    assert.equal(updater.stats.updates, 1)
+    let row = await lookupSession(dbPath, 'S-updater-1')
+    assert.ok(row, 'flush 后索引可见（无 rebuild 自举）')
+    assert.equal(row!.eventCount, 1)
+
+    // debounce 窗口内多次 record 合并为一次 upsert，行快照 = 最新 append 时点全量
+    log.append('model', 'assistant', 'T0', 'a0')
+    log.append('user', 'user', 'T1', 'q1')
+    await updater.flush()
+    row = await lookupSession(dbPath, 'S-updater-1')
+    assert.equal(row!.eventCount, 3)
+
+    // close flush（car run 关句柄前收口）
+    log.append('user', 'user', 'T2', 'q2')
+    await updater.close()
+    assert.equal(updater.stats.updates, 3)
+    row = await lookupSession(dbPath, 'S-updater-1')
+    assert.equal(row!.eventCount, 4)
+    assert.equal(row!.tornTail, false, '活会话按构造完整（tornTail=false 口径）')
+    assert.equal(row!.encoding, 'plain')
+    store.close()
+  })
+})
+
+test('S28: IndexUpdater 失败非致命——db 路径不可用持续留痕不抛出（append 路径零影响）', async () => {
+  await withTempDir('updater-fail', async dir => {
+    // dbPath 指向目录 → open 必败
+    const badPath = join(dir, 'a-directory')
+    mkdirSync(badPath)
+    const errors: string[] = []
+    const updater = new IndexUpdater({ dbPath: badPath, onError: e => errors.push(e.message) })
+    const log = new SessionLog('S-fail-1')
+    const store = new SessionFileStore(join(dir, 'x.jsonl'))
+    log.attachSink(line => { store.append(line); updater.record('S-fail-1', line, join(dir, 'x.jsonl')) })
+
+    // 事件照常落盘（updater 错误绝不传播到 append 路径——R-2 钉死）
+    log.append('user', 'user', 'T0', 'q')
+    await updater.flush()
+    assert.equal(updater.stats.failures, 1)
+    assert.ok(errors[0], '错误经 onError 留痕（不向调用方抛出）')
+    assert.match(errors[0]!, /CAR-E-INDEX|CAR-E-SQLITE/)
+
+    // 继续使用不抛出
+    log.append('user', 'user', 'T1', 'q')
+    await updater.close()
+    assert.equal(updater.stats.failures, 2)
+    // 落盘本体未受影响：文件行数 = 事件数
+    assert.equal(readFileSync(join(dir, 'x.jsonl'), 'utf-8').trim().split('\n').length, 2)
+    store.close()
+  })
+})
+
+test('S28: 生产调用点——car run 真进程 append → cwd sessions-index.db 自动可见（「更新半边」闭环）', async () => {
+  await withTempDir('car-run-index', async dir => {
+    // 工具名避开 demo_tool：CLI 演示脚手架硬编码注册 demo_tool，同名插件工具触发预存在的 provide
+    // 撞名边缘（登记不修——W1 重做 car run 装配面时出清）
+    writeFileSync(join(dir, 'p.ts'), `export const manifest = { name: 'p', version: '1.0.0' }\nexport default function apply(api) {\n  api.registerTool({ name: 't', run: async () => 'ok' })\n}\n`)
+    const r = await car(['run', 'p.ts'], { cwd: dir })
+    assert.equal(r.code, 0, r.stderr)
+    const dbPath = join(dir, 'sessions-index.db')
+    assert.ok(existsSync(dbPath), 'car run 运行后 cwd 索引自举在位')
+    // 经 sqlite 直查（run 会话 id 为 S-<time36> 运行期生成，全表核对）
+    const mod = await import('node:sqlite')
+    const DatabaseSync = (mod as unknown as { DatabaseSync: new (path: string) => { prepare(s: string): { all(...v: unknown[]): Record<string, unknown>[] }; close(): void } }).DatabaseSync
+    const db = new DatabaseSync(dbPath)
+    try {
+      const all = db.prepare('SELECT sessionId, eventCount, file FROM sessions').all()
+      assert.ok(all.length >= 1, 'run 会话入索引')
+      const hit = all.find(x => String(x.sessionId).startsWith('S-'))
+      assert.ok(hit, 'run 会话 id 在索引')
+      // realpath 比较（1.2-BUG-4）：macOS 子进程 cwd 为物理路径 /private/var…，父进程持逻辑路径 /var…
+      assert.equal(realpathSync(String(hit!.file)), realpathSync(join(dir, `session-${hit!.sessionId}.jsonl`)))
+      assert.ok(Number(hit!.eventCount) >= 3, '事件计数 = run 全程 append 量（装配+对话+收口）')
+    } finally {
+      db.close()
+    }
+  })
+})

package/test/s29-otel-producer.spec.ts

@@ -0,0 +1,252 @@
+/**
+ * 1.2 · OTLP exporter 生产级策略（S29）：有界重试 / 采样 / 批上限 / env 通道 / mcp-serve meter 桥
+ *
+ * 覆盖（1.2-迭代规划 W3-3；M8 §4.4 登记后续出清；D-12b 口径修订 0 重试 → 有界 ≤2）：
+ *  - 重试：429/5xx/网络错误退避重试（序列 1s/2s 可注入）→ 成功计数；耗尽 droppedExports 静默丢弃；
+ *    4xx 业务错不重试；res.ok 语义（旧实现 5xx 也计成功——本代修正为显式状态判定）
+ *  - 采样：always_on 缺省行为不变 / always_off 全采出 / ratio 概率边界；spansSampledOut 计数
+ *  - 批上限：maxBatchSize 分批（tracesExported 按请求计）/ maxQueueSize 溢出丢最旧 queueOverflows
+ *  - env 通道：telemetryConfigFromEnv（endpoint 唯一开关 / sampling 三形态 / 非法值保持缺省）
+ *  - 生产调用点：mcp-serve 真进程 CAR_OTEL_ENDPOINT → 本地 http 捕获端点断言 OTLP metrics 出站
+ *    （S17 counters 双写桥；快照面不变）；零依赖静态断言保持（telemetry 零 session import）
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { createServer, type Server } from 'node:http'
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createTelemetryFacade, telemetryConfigFromEnv, type TelemetryConfig } from '../src/runtime-core/telemetry.ts'
+
+const CLI = join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'cli.ts')
+
+const sleepsOf = (log: number[]) => async (ms: number) => { log.push(ms) }
+const okRes = () => ({ ok: true, status: 200 }) as unknown as Response
+const statusRes = (status: number) => ({ ok: false, status }) as unknown as Response
+
+function withTempDir(name: string, fn: (dir: string) => Promise<void> | void): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), `car-s29-${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
+  }
+}
+
+// ==================== env 通道 ====================
+
+test('S29: telemetryConfigFromEnv——endpoint 唯一开关 / sampling 三形态 / 非法值保持缺省 / interval 解析', () => {
+  assert.equal(telemetryConfigFromEnv({}), null, '无 endpoint = null（默认关）')
+  const c1 = telemetryConfigFromEnv({ CAR_OTEL_ENDPOINT: 'https://otel.internal' })!
+  assert.equal(c1.endpoint, 'https://otel.internal')
+  assert.equal(c1.sampling, undefined, '缺省采样不写入（= always_on 行为）')
+  assert.equal(telemetryConfigFromEnv({ CAR_OTEL_ENDPOINT: 'https://x', CAR_OTEL_SAMPLING: 'always_off' })!.sampling, 'always_off')
+  assert.deepEqual(telemetryConfigFromEnv({ CAR_OTEL_ENDPOINT: 'https://x', CAR_OTEL_SAMPLING: '0.25' })!.sampling, { ratio: 0.25 })
+  assert.equal(telemetryConfigFromEnv({ CAR_OTEL_ENDPOINT: 'https://x', CAR_OTEL_SAMPLING: 'bogus' })!.sampling, undefined, '非法值保持缺省（禁 fail-hard）')
+  assert.equal(telemetryConfigFromEnv({ CAR_OTEL_ENDPOINT: 'https://x', CAR_OTEL_SAMPLING: '1.5' })!.sampling, undefined, '超界 ratio = 非法')
+  const c2 = telemetryConfigFromEnv({ CAR_OTEL_ENDPOINT: 'https://x', CAR_OTEL_INTERVAL_MS: '5000', CAR_OTEL_SERVICE_NAME: 'svc' })!
+  assert.equal(c2.intervalMs, 5000)
+  assert.equal(c2.serviceName, 'svc')
+})
+
+// ==================== 有界重试（D-12b 口径） ====================
+
+test('S29: 重试——5xx 退避后成功计数；耗尽 droppedExports 静默丢弃；4xx 不重试直接丢', async () => {
+  await withTempDir('retry', async () => {
+    const sleeps: number[] = []
+    // 500 → 500 → 200：两次退避后成功
+    let calls = 0
+    const f1 = createTelemetryFacade({ endpoint: 'https://otel', retryBackoffMs: [10, 20], sleep: sleepsOf(sleeps) }, {
+      fetchImpl: (async () => (calls++ === 2 ? okRes() : statusRes(500))) as typeof fetch,
+    })
+    f1.getTracer().startSpan('s').end()
+    await f1.flush()
+    assert.deepEqual(sleeps, [10, 20], '退避序列可注入且按序生效')
+    assert.deepEqual(f1.stats(), { spansEnded: 1, spansSampledOut: 0, tracesExported: 1, metricsExported: 0, droppedExports: 0, queueOverflows: 0 })
+
+    // 恒 429：耗尽 2 次重试（3 次尝试）→ 静默丢弃，flush 不抛错
+    let tries = 0
+    const f2 = createTelemetryFacade({ endpoint: 'https://otel', retryLimit: 2, retryBackoffMs: [1, 1], sleep: sleepsOf([]) }, {
+      fetchImpl: (async () => (tries++, statusRes(429))) as typeof fetch,
+    })
+    f2.getTracer().startSpan('s').end()
+    await f2.flush()
+    assert.equal(tries, 3, '1 原始 + 2 重试')
+    assert.equal(f2.stats().droppedExports, 1)
+    assert.equal(f2.stats().tracesExported, 0)
+
+    // 400 业务错：不重试，立即丢弃
+    let tries4xx = 0
+    const f3 = createTelemetryFacade({ endpoint: 'https://otel', sleep: sleepsOf([]) }, {
+      fetchImpl: (async () => (tries4xx++, statusRes(400))) as typeof fetch,
+    })
+    f3.getTracer().startSpan('s').end()
+    await f3.flush()
+    assert.equal(tries4xx, 1, '4xx 不重试')
+    assert.equal(f3.stats().droppedExports, 1)
+
+    // 网络错误（fetch throw）：可重试，耗尽后静默
+    let netTries = 0
+    const f4 = createTelemetryFacade({ endpoint: 'https://otel', retryLimit: 1, retryBackoffMs: [1], sleep: sleepsOf([]) }, {
+      fetchImpl: (async () => (netTries++, Promise.reject(new Error('ECONNREFUSED')))) as unknown as typeof fetch,
+    })
+    f4.getTracer().startSpan('s').end()
+    await f4.flush()
+    assert.equal(netTries, 2)
+    assert.equal(f4.stats().droppedExports, 1)
+  })
+})
+
+test('S29: res.ok 显式语义——5xx 不再被计为成功（旧实现口径修正的回归钉）', async () => {
+  await withTempDir('ok-semantics', async () => {
+    const f = createTelemetryFacade({ endpoint: 'https://otel', retryLimit: 0, sleep: sleepsOf([]) }, {
+      fetchImpl: (async () => statusRes(503)) as typeof fetch,
+    })
+    f.getTracer().startSpan('s').end()
+    await f.flush()
+    assert.equal(f.stats().tracesExported, 0, '非 2xx 不计成功')
+    assert.equal(f.stats().droppedExports, 1)
+  })
+})
+
+// ==================== 采样 ====================
+
+test('S29: 采样——always_on 缺省全量（1.1 行为不变）/ always_off 全采出 / ratio=0 与 1 边界', async () => {
+  await withTempDir('sampling', async () => {
+    const posts: unknown[] = []
+    const mk = (cfg: TelemetryConfig) => createTelemetryFacade({ endpoint: 'https://otel', ...cfg }, {
+      fetchImpl: (async (_url: string | URL, init?: RequestInit) => { posts.push(init?.body); return okRes() }) as typeof fetch,
+    })
+    // always_on（缺省不写 sampling）：全量出站
+    const f1 = mk({})
+    for (let i = 0; i < 3; i++) f1.getTracer().startSpan(`s${i}`).end()
+    await f1.flush()
+    assert.equal(f1.stats().spansSampledOut, 0)
+    assert.equal(f1.stats().tracesExported, 1)
+    // always_off：全采出，零出站
+    const f2 = mk({ sampling: 'always_off' })
+    for (let i = 0; i < 3; i++) f2.getTracer().startSpan(`s${i}`).end()
+    await f2.flush()
+    assert.equal(f2.stats().spansSampledOut, 3)
+    assert.equal(f2.stats().tracesExported, 0)
+    // ratio 0 / 1 边界
+    const f3 = mk({ sampling: { ratio: 0 } })
+    f3.getTracer().startSpan('s').end()
+    assert.equal(f3.stats().spansSampledOut, 1)
+    const f4 = mk({ sampling: { ratio: 1 } })
+    f4.getTracer().startSpan('s').end()
+    assert.equal(f4.stats().spansSampledOut, 0)
+  })
+})
+
+// ==================== 批上限 ====================
+
+test('S29: 批上限——maxBatchSize 分批（tracesExported 按请求计）/ maxQueueSize 溢出丢最旧', async () => {
+  await withTempDir('batch', async () => {
+    const bodies: any[] = []
+    const f = createTelemetryFacade({ endpoint: 'https://otel', maxBatchSize: 2, maxQueueSize: 5 }, {
+      fetchImpl: (async (_u: string | URL, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); return okRes() }) as typeof fetch,
+    })
+    for (let i = 0; i < 5; i++) f.getTracer().startSpan(`s${i}`).end()
+    await f.flush()
+    assert.equal(bodies.length, 3, '5 spans / batch=2 → 3 请求')
+    assert.deepEqual(bodies.map(b => b.scopeSpans[0].spans.length), [2, 2, 1])
+    assert.equal(f.stats().tracesExported, 3, 'tracesExported 按成功出站请求计数')
+
+    // 溢出丢最旧：queue=3，end 5 个 → 丢最旧 2 个，flush 导出最新 3 个
+    const f2 = createTelemetryFacade({ endpoint: 'https://otel', maxQueueSize: 3 }, {
+      fetchImpl: (async (_u: string | URL, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); return okRes() }) as typeof fetch,
+    })
+    for (let i = 0; i < 5; i++) f2.getTracer().startSpan(`s${i}`).end()
+    assert.equal(f2.stats().queueOverflows, 2)
+    await f2.flush()
+    const names = bodies[bodies.length - 1]!.scopeSpans[0].spans.map((s: { name: string }) => s.name)
+    assert.deepEqual(names, ['s2', 's3', 's4'], '溢出丢最旧（保留最新）')
+  })
+})
+
+// ==================== 默认关（noop）不变 ====================
+
+test('S29: 默认关三原则——无 endpoint = noop 零出站（fetch 不被调用）+ stats 全零', async () => {
+  await withTempDir('default-off', async () => {
+    let called = 0
+    const f = createTelemetryFacade(null, { fetchImpl: (async () => (called++, okRes())) as typeof fetch })
+    assert.equal(f.enabled, false)
+    f.getTracer().startSpan('s').end()
+    f.getMeter().createCounter('c').add(1)
+    await f.flush()
+    await f.shutdown()
+    assert.equal(called, 0, '零出站')
+    assert.deepEqual(f.stats(), { spansEnded: 0, spansSampledOut: 0, tracesExported: 0, metricsExported: 0, droppedExports: 0, queueOverflows: 0 })
+  })
+})
+
+// ==================== 零依赖解耦红线（静态断言保持） ====================
+
+test('S29: 严格解耦——telemetry.ts 零 import 自 session/*（静态断言）', () => {
+  const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'runtime-core', 'telemetry.ts'), 'utf-8')
+  assert.equal(/from\s+'\.\.\/session\//.test(src), false)
+  assert.equal(/from\s+'\.\/\.\.\/session\//.test(src), false)
+})
+
+// ==================== 生产调用点：mcp-serve meter 桥（真进程 + 本地捕获端点） ====================
+
+test('S29: mcp-serve 生产接线——CAR_OTEL_ENDPOINT 显式开 → S17 counters 双写出站 OTLP metrics（快照面不变）', async () => {
+  await withTempDir('mcp-otel', async dir => {
+    const bodies: any[] = []
+    let done: (v: void) => void = () => {}
+    const closed = new Promise<void>(r => { done = r })
+    const server: Server = createServer((req, res) => {
+      let body = ''
+      req.on('data', c => { body += c })
+      req.on('end', () => {
+        if (req.url === '/v1/metrics') bodies.push(JSON.parse(body))
+        res.writeHead(200).end()
+      })
+    })
+    await new Promise<void>(r => server.listen(0, '127.0.0.1', r))
+    const port = (server.address() as { port: number }).port
+    try {
+      const child = spawn(process.execPath, ['--experimental-transform-types', CLI, 'mcp-serve'], {
+        cwd: dir,
+        env: { ...process.env, CAR_OTEL_ENDPOINT: `http://127.0.0.1:${port}`, CAR_OTEL_INTERVAL_MS: '0' },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+      let err = ''
+      child.stderr.on('data', d => { err += d })
+      child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'session_start', arguments: { hostSessionId: 's29' } } }) + '\n')
+      child.stdin.end()
+      child.on('exit', () => done())
+      // macOS runner 慢启动容差（60s）；落选的 race timer 必须 clear——未清时它把事件循环
+      // 挂满整个超时窗（本文件曾因此空转 20s，慢 runner 上叠加成 j03 假失败形态）
+      let raceTimer: ReturnType<typeof setTimeout> | undefined
+      try {
+        await Promise.race([
+          closed,
+          new Promise<never>((_, rej) => { raceTimer = setTimeout(() => rej(new Error(`mcp-serve 超时\n${err}`)), 60_000) }),
+        ])
+      } finally {
+        if (raceTimer) clearTimeout(raceTimer)
+      }
+      // S17 快照面不变（双写非迁移）
+      assert.match(err, /snapshot=/)
+      assert.match(err, /zeroContent=true/)
+      assert.match(err, /otel=enabled/)
+      // OTLP metrics 出站：counter 名 + 零内容 labels 到达用户端点
+      assert.ok(bodies.length >= 1, 'metrics POST 到达捕获端点')
+      const names = bodies.flatMap(b => b.scopeMetrics[0].metrics.map((m: { name: string }) => m.name))
+      assert.ok(names.includes('car_registry_decision'), 'S17 counter 名出站')
+      assert.equal(/sk-|ghp_/.test(JSON.stringify(bodies)), false, '出站体无凭据形态（零内容口径）')
+    } finally {
+      server.closeAllConnections()
+      server.close()
+    }
+  })
+})