@lqc123qwe/car-runtime 1.8.0 → 1.10.0

package/scripts/ptc-baseline/run-baseline.ts

@@ -1,118 +0,0 @@
-/**
- * T-7 · PTC 成功率评测基线（M4-S19 实装，S20 使用）
- *
- * 口径（M4系统设计增补 T-7 / PRD P1-4 验收：PTC 成功率 ≥ 非 PTC 基线）：
- *  - 12 任务 × 五类（纯计算 2 / 单工具 2 / 多工具编排 3 / 错误恢复 3 / 预算边界 2）；
- *    判定口径：E 类（预算边界）= 护栏正确触发即成功（两侧对称）；
- *  - 每任务每形态 ≥N 次（默认 5，--runs 调整）；对照组 = 等价非 PTC 逐步工具调用（同一工具注册表）；
- *  - 输出：JSONL 逐次明细 + 汇总（PTC 成功率 vs 非 PTC 基线 + P1-4 判定）；
- *  - 运行：node --experimental-transform-types scripts/ptc-baseline/run-baseline.ts [--runs 5]
- */
-import { writeFileSync, mkdirSync } from 'node:fs'
-import { runCode, makePtcToolDefinition, type ToolBridge } from '../../src/ptc/runCode.ts'
-import { convergeBudget } from '../../src/ptc/budget.ts'
-
-// ── 评测工具注册表（与 PTC/非 PTC 两侧共享——对照公平性） ──
-const TOOLS = new Map<string, ToolBridge & { description?: string; paramHint?: string }>([
-  ['math_add', { run: async (a: unknown) => { const p = a as { x: number; y: number }; return p.x + p.y }, description: '加法', paramHint: 'args: { x: number; y: number }' }],
-  ['math_mul', { run: async (a: unknown) => { const p = a as { x: number; y: number }; return p.x * p.y }, description: '乘法' }],
-  ['str_len', { run: async (a: unknown) => (a as { s: string }).s.length, description: '字符串长度' }],
-  ['flaky', { run: async (a: unknown) => { if ((a as { fail?: boolean }).fail) throw new Error('simulated failure'); return 'recovered' }, description: '可失败工具' }],
-])
-
-interface Task {
-  id: string; cls: 'compute' | 'single-tool' | 'orchestration' | 'error-recovery' | 'budget-edge'
-  name: string
-  /** PTC 程序体（erasable async 函数体） */
-  code: string
-  description: string
-  /** 期望判定：结果语义正确；E 类 = 护栏正确触发 */
-  expect: (result: unknown, error?: string) => boolean
-  /** 等 PTC 护栏触发后判成功的 E 类，非 PTC 对照跳过（无对应逐步语义） */
-  ptcOnly?: boolean
-  budget?: { maxWallMs?: number; maxOutputBytes?: number }
-}
-
-const TASKS: Task[] = [
-  { id: 'C1', cls: 'compute', name: '纯计算-算术', code: 'const a = 6 * 7\nreturn { answer: a }', description: '纯算术验证', expect: r => (r as { answer: number }).answer === 42 },
-  { id: 'C2', cls: 'compute', name: '纯计算-字符串', code: 'const s = "car-runtime"\nreturn { len: s.length, upper: s.toUpperCase() }', description: '字符串处理', expect: r => (r as { len: number }).len === 11 },
-  { id: 'S1', cls: 'single-tool', name: '单工具-加法', code: 'const r = await tools.math_add({ x: 20, y: 22 })\nreturn { sum: r }', description: '单工具调用', expect: r => (r as { sum: number }).sum === 42 },
-  { id: 'S2', cls: 'single-tool', name: '单工具-字符串', code: 'const n = await tools.str_len({ s: "hello" })\nreturn { n }', description: '单工具调用', expect: r => (r as { n: number }).n === 5 },
-  { id: 'O1', cls: 'orchestration', name: '编排-串行依赖', code: 'const a = await tools.math_add({ x: 2, y: 3 })\nconst b = await tools.math_mul({ x: a, y: 4 })\nreturn { b }', description: '串行依赖链', expect: r => (r as { b: number }).b === 20 },
-  { id: 'O2', cls: 'orchestration', name: '编排-并行', code: 'const [a, b] = await Promise.all([tools.math_add({ x: 1, y: 1 }), tools.math_mul({ x: 3, y: 3 })])\nreturn { a, b }', description: 'Promise.all 并行', expect: r => (r as { a: number; b: number }).a === 2 && (r as { a: number; b: number }).b === 9 },
-  { id: 'O3', cls: 'orchestration', name: '编排-混合', code: 'const parts = []\nfor (const p of [{ x: 1, y: 2 }, { x: 3, y: 4 }]) parts.push(await tools.math_add(p))\nreturn { parts, total: parts[0] + parts[1] }', description: '循环+聚合', expect: r => (r as { total: number }).total === 10 },
-  { id: 'E1', cls: 'error-recovery', name: '恢复-try/catch', code: 'try { await tools.flaky({ fail: true }) } catch (e) { return { caught: true } }\nreturn { caught: false }', description: '工具异常捕获', expect: r => (r as { caught: boolean }).caught === true },
-  { id: 'E2', cls: 'error-recovery', name: '恢复-部分失败继续', code: 'const out: string[] = []\ntry { await tools.flaky({ fail: true }) } catch { out.push("skip") }\nout.push(await tools.flaky({}))\nreturn { out }', description: '部分失败继续', expect: r => (r as { out: string[] }).out.length === 2 },
-  { id: 'E3', cls: 'error-recovery', name: '恢复-重试语义', code: 'let ok = false\nfor (let i = 0; i < 3; i++) { try { ok = (await tools.flaky({ fail: i < 1 })) === "recovered"; if (ok) break } catch {} }\nreturn { ok }', description: '重试直至成功', expect: r => (r as { ok: boolean }).ok === true },
-  { id: 'B1', cls: 'budget-edge', name: '预算-输出上限', code: 'return { blob: "x".repeat(9 * 1024 * 1024) }', description: '输出超 8MiB 测试上限', budget: { maxOutputBytes: 8 * 1024 * 1024, maxWallMs: 10_000 }, expect: (_r, e) => !!e?.startsWith('budget-exceeded (maxOutputBytes'), ptcOnly: true },
-  { id: 'B2', cls: 'budget-edge', name: '预算-墙钟上限', code: 'while (true) { await new Promise(r => setTimeout(r, 10)) }\nreturn null', description: '死循环墙钟护栏', budget: { maxWallMs: 400 }, expect: (_r, e) => !!e?.startsWith('budget-exceeded (maxWallMs'), ptcOnly: true },
-]
-
-// ── 非 PTC 对照（逐步工具调用，与 PTC 侧同注册表） ──
-function nonPtcEquivalent(task: Task, run: (name: string, args: unknown) => Promise<unknown>): Promise<{ ok: boolean; error?: string }> {
-  const call = (n: string, a: unknown) => run(n, a)
-  switch (task.id) {
-    case 'C1': return call('math_mul', { x: 6, y: 7 }).then(v => ({ ok: (v as number) === 42 }))
-    case 'C2': return call('str_len', { s: 'car-runtime' }).then(v => ({ ok: (v as number) === 11 }))
-    case 'S1': return call('math_add', { x: 20, y: 22 }).then(v => ({ ok: (v as number) === 42 }))
-    case 'S2': return call('str_len', { s: 'hello' }).then(v => ({ ok: (v as number) === 5 }))
-    case 'O1': return call('math_add', { x: 2, y: 3 }).then(a => call('math_mul', { x: a, y: 4 })).then(b => ({ ok: (b as number) === 20 }))
-    case 'O2': return Promise.all([call('math_add', { x: 1, y: 1 }), call('math_mul', { x: 3, y: 3 })]).then(([a, b]) => ({ ok: a === 2 && b === 9 }))
-    case 'O3': return call('math_add', { x: 1, y: 2 }).then(a => call('math_add', { x: 3, y: 4 }).then(b => ({ ok: (a as number) + (b as number) === 10 })))
-    case 'E1': return call('flaky', { fail: true }).then(() => ({ ok: false }), e => ({ ok: String(e).includes('simulated failure') }))
-    case 'E2': return call('flaky', { fail: true }).catch(() => call('flaky', {})).then(v => ({ ok: v === 'recovered' }))
-    case 'E3': return call('flaky', { fail: true }).catch(() => call('flaky', {})).then(v => ({ ok: v === 'recovered' }))
-    default: return Promise.resolve({ ok: true }) // B 类 ptcOnly 跳过
-  }
-}
-
-async function main() {
-  const runs = Math.max(1, Number(process.argv[process.argv.indexOf('--runs') + 1] ?? 5) || 5)
-  const lines: Record<string, unknown>[] = []
-  const ptcDef = makePtcToolDefinition({ tools: TOOLS })
-  const summary: Record<string, { ptc: number; non: number; total: number }> = {}
-
-  for (const task of TASKS) {
-    let ok = 0
-    for (let i = 0; i < runs; i++) {
-      try {
-        if (task.cls === 'budget-edge') {
-          // E 类经 runCode 直接驱动（护栏触发即成功）
-          const r = await runCode({ code: task.code, description: task.description, toolCallId: `${task.id}-${i}`, budget: convergeBudget(task.budget) }, { tools: TOOLS })
-          const pass = task.expect(r.result, r.error)
-          if (pass) ok++
-          lines.push({ task: task.id, cls: task.cls, run: i, ok: pass, error: r.error, budgetExceeded: r.budgetExceeded })
-        } else {
-          const r = await runCode({ code: task.code, description: task.description, toolCallId: `${task.id}-${i}`, budget: { maxWallMs: 10_000 } }, { tools: TOOLS })
-          const pass = r.ok && task.expect(r.result, r.error)
-          if (pass) ok++
-          lines.push({ task: task.id, cls: task.cls, run: i, ok: pass, error: r.error })
-        }
-      } catch (e) { lines.push({ task: task.id, cls: task.cls, run: i, ok: false, error: String(e) }) }
-    }
-    // 非 PTC 对照
-    let nonOk = 0
-    if (!task.ptcOnly) {
-      for (let i = 0; i < runs; i++) {
-        const r = await nonPtcEquivalent(task, (n, a) => (TOOLS.get(n) as ToolBridge).run(a))
-        if (r.ok) nonOk++
-      }
-    } else nonOk = runs // ptcOnly 不参与对照，按满分避免拉低基线
-    summary[task.cls] = summary[task.cls] ?? { ptc: 0, non: 0, total: 0 }
-    summary[task.cls].ptc += ok; summary[task.cls].non += nonOk; summary[task.cls].total += runs
-    console.log(`${task.id} ${task.name}: PTC ${ok}/${runs}${task.ptcOnly ? '（ptcOnly）' : ` | 非PTC ${nonOk}/${runs}`}`)
-  }
-
-  const totalPtc = Object.values(summary).reduce((s, v) => s + v.ptc, 0)
-  const totalNon = Object.values(summary).reduce((s, v) => s + v.non, 0)
-  const totalN = Object.values(summary).reduce((s, v) => s + v.total, 0)
-  const rate = (x: number) => ((x / totalN) * 100).toFixed(1) + '%'
-  console.log(`\n==== PTC 成功率 ${totalPtc}/${totalN} = ${rate(totalPtc)} ｜ 非 PTC 基线 ${totalNon}/${totalN} = ${rate(totalNon)} ====`)
-  console.log(`P1-4 判定：${totalPtc >= totalNon ? '✅ PTC ≥ 非 PTC 基线' : '❌ PTC < 非 PTC 基线（需分析失败任务）'}`)
-  mkdirSync('dist/ptc-baseline', { recursive: true })
-  writeFileSync('dist/ptc-baseline/detail.jsonl', lines.map(l => JSON.stringify(l)).join('\n') + '\n')
-  writeFileSync('dist/ptc-baseline/summary.json', JSON.stringify({ runs, ptc: totalPtc, non: totalNon, total: totalN, byClass: summary }, null, 2))
-  console.log('明细：dist/ptc-baseline/detail.jsonl ｜ 汇总：dist/ptc-baseline/summary.json')
-}
-
-main()

package/scripts/release-artifacts.ts

@@ -1,111 +0,0 @@
-/**
- * 1.3-S1 · 发布制品构建（W4）：本地 release-pipeline.ts 与 CI j16 双端复用的单一事实源
- *
- * 口径（1.3 规划 W4-1/W4-4 / D-14 / D-15）：
- *  - 同一仓树 → 逐字节同制品（git archive HEAD；G-11 教训：哈希对裸字节求）；
- *  - **资产集五件套**（releaseAssetNames 单一事实源——G-10 need-list、CI upload、测试三方同源）：
- *      car-runtime-<v>.tgz / car-runtime-<v>.tgz.sig.bundle / SHA256SUMS / sbom.json / release-audit.jsonl
- *    car-release.pub 自 1.3 移除（D-14：keyless 下验证锚 = bundle 证书 + Rekor，不再是本地公钥）；
- *  - **签名不在此层**（D-15 双轨）：bundle 由签名轨产出——本地 keypair no-tlog（预演态，
- *    release-pipeline G-08）/ CI keyless OIDC+Rekor（正式态，j16）；本脚本只构建与审计；
- *  - 构建审计：CLI 入口（CI 调用形态）写 release-audit.jsonl（archive/sbom/sha256 记录）；
- *    程序化调用（pipeline）经 onRecord 接入调用方审计流。
- *  - 零依赖（node:crypto/fs/child_process）。
- */
-import { execSync } from 'node:child_process'
-import { createHash } from 'node:crypto'
-import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-export interface BuildRecord { stage: string; detail: string; ts: number }
-
-export interface BuildResult {
-  tgzPath: string
-  sha256: string
-  sumsPath: string
-  sbomPath: string
-  components: number
-  bytes: number
-  records: BuildRecord[]
-}
-
-const sha256 = (s: string | Buffer) => createHash('sha256').update(s).digest('hex')
-
-function walk(dir: string, ext: string): string[] {
-  let out: string[] = []
-  for (const name of readdirSync(dir)) {
-    const p = join(dir, name)
-    if (statSync(p).isDirectory()) out = out.concat(walk(p, ext))
-    else if (p.endsWith(ext)) out.push(p)
-  }
-  return out
-}
-
-/** 资产集清单（五件套；D-14：car-release.pub 移除，签名 bundle 由签名轨产出后入列） */
-export function releaseAssetNames(version: string): string[] {
-  return [
-    `car-runtime-${version}.tgz`,
-    `car-runtime-${version}.tgz.sig.bundle`,
-    'SHA256SUMS',
-    'sbom.json',
-    'release-audit.jsonl',
-  ]
-}
-
-export function buildReleaseArtifacts(opts: {
-  version: string
-  root?: string
-  dist?: string
-  onRecord?: (stage: string, detail: string) => void
-}): BuildResult {
-  const root = opts.root ?? new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
-  const dist = opts.dist ?? join(root, 'dist')
-  const version = opts.version
-  const records: BuildRecord[] = []
-  const rec = (stage: string, detail: string) => {
-    const r = { stage, detail, ts: Date.now() }
-    records.push(r)
-    opts.onRecord?.(stage, detail)
-  }
-
-  mkdirSync(dist, { recursive: true })
-  const tgzPath = join(dist, `car-runtime-${version}.tgz`)
-  execSync(`git archive --format=tar.gz -o "${tgzPath}" HEAD`, { cwd: root })
-  const bytes = readFileSync(tgzPath)
-  rec('archive', `git archive HEAD → car-runtime-${version}.tgz（${bytes.length} bytes，树哈希锚定）`)
-
-  // SHA256SUMS + 自检（G-11 口径：对裸字节求哈希；门禁不可写死为 true——落盘读回复核）
-  const sumsPath = join(dist, 'SHA256SUMS')
-  writeFileSync(sumsPath, `${sha256(bytes)}  car-runtime-${version}.tgz\n`)
-  const [recorded, recordedName] = readFileSync(sumsPath, 'utf-8').trim().split(/\s+/)
-  if (recorded !== sha256(bytes) || recordedName !== `car-runtime-${version}.tgz`) {
-    throw new Error(`CAR-E-ARTIFACT: SHA256SUMS 自检失败——记录 ${recorded} ≠ 制品裸字节哈希（G-11 教训口径）`)
-  }
-  rec('sha256sums', `SHA256SUMS ${recorded!.slice(0, 16)}…（裸字节复核通过）`)
-
-  // SBOM（G-05 同构：TS 直跑形态制品清单 + 零运行时依赖）
-  const files = [...walk(join(root, 'src'), '.ts'), join(root, 'package.json'), join(root, 'README.md')]
-  const sbom = {
-    bomFormat: 'CAR-SBOM', specVersion: '0.1', version,
-    components: files.map(f => ({ type: 'file', path: f.replace(root, '').replace(/\\/g, '/'), sha256: sha256(readFileSync(f, 'utf-8')) })),
-    runtimeDependencies: [],
-  }
-  const sbomPath = join(dist, 'sbom.json')
-  writeFileSync(sbomPath, JSON.stringify(sbom, null, 2))
-  rec('sbom', `${files.length} 个组件（运行时依赖 0 项）`)
-
-  return { tgzPath, sha256: sha256(bytes), sumsPath, sbomPath, components: files.length, bytes: bytes.length, records }
-}
-
-/** CLI 入口（CI j16 调用形态）：构建 + 写构建审计 release-audit.jsonl（五件套之五） */
-function main(): void {
-  const version = (JSON.parse(readFileSync(join(new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'), 'package.json'), 'utf-8')) as { version: string }).version
-  const result = buildReleaseArtifacts({ version })
-  const auditPath = join(result.tgzPath, '..', 'release-audit.jsonl')
-  writeFileSync(auditPath, result.records.map(r => JSON.stringify(r)).join('\n') + '\n')
-  console.log(`release artifacts: v${version} → tgz(${result.bytes}B, sha256 ${result.sha256.slice(0, 16)}…) + SHA256SUMS + sbom(${result.components} components) + release-audit.jsonl`)
-  console.log(`assets (D-14 五件套): ${releaseAssetNames(version).join(', ')}`)
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main()

package/scripts/release-pipeline.ts

@@ -1,245 +0,0 @@
-/**
- * 发布工程预演（本地 dry-run 版 8 阶段流水线，对齐《部署设计》§4/§6）
- *
- * 真实执行：门禁 13 项中本地可跑的 9 项（测试/不变量/密钥扫描/版本一致性/SBOM/校验和/
- *           逃逸矩阵定义校验/依赖零原生审计/dist-tag 晋级模拟+回滚演练）
- * DRY-RUN：npm publish（OIDC provenance）/ cosign keyless 签名 / GitHub Releases 归档
- *          ——需远端凭据与仓库，预演报告标注 DRY-RUN 与正式执行前置条件
- *
- * 运行：node --experimental-transform-types scripts/release-pipeline.ts
- */
-import { execSync, execFileSync } from 'node:child_process'
-import { createHash } from 'node:crypto'
-import { readFileSync, writeFileSync, readdirSync, statSync, mkdirSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { buildReleaseArtifacts, releaseAssetNames } from './release-artifacts.ts'
-
-const ROOT = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
-const DIST = join(ROOT, 'dist')
-const VERSION = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')).version as string
-const audit: any[] = []
-const auditLog = (stage: string, gate: string, verdict: string, detail: Record<string, unknown> = {}) =>
-  audit.push({ stage, gate, verdict, ts: Date.now(), ...detail })
-const sha256 = (s: string | Buffer) => createHash('sha256').update(s).digest('hex')
-
-function walk(dir: string, ext: string): string[] {
-  const out: string[] = []
-  for (const name of readdirSync(dir)) {
-    const p = join(dir, name)
-    if (statSync(p).isDirectory()) out.push(...walk(p, ext))
-    else if (p.endsWith(ext)) out.push(p)
-  }
-  return out
-}
-
-const results: Array<{ stage: string; gate: string; verdict: string; detail?: string }> = []
-const record = (stage: string, gate: string, ok: boolean, detail = '', dryRun = false) => {
-  const verdict = dryRun ? 'DRY-RUN' : ok ? 'PASS' : 'FAIL'
-  results.push({ stage, gate, verdict, detail })
-  auditLog(stage, gate, verdict, { detail })
-  if (!dryRun && !ok) throw new Error(`GATE FAILED: ${stage}/${gate} ${detail}`)
-}
-
-// ── 阶段 1：PR 门禁（int）──
-{
-  const stage = 'S1-PR 门禁'
-  // reporter 钉死 tap：非 TTY 默认 reporter 随 Node 版本漂移（23.x 输出 spec 格式，正则解析不到 # pass/# fail）
-  const out = execSync('node --experimental-transform-types --test --test-reporter=tap test/*.spec.ts', { cwd: ROOT, encoding: 'utf-8' })
-  const pass = /# pass (\d+)/.exec(out)?.[1]
-  const fail = /# fail (\d+)/.exec(out)?.[1]
-  record(stage, 'G-01 单测全绿', fail === '0', `${pass} pass / ${fail} fail`)
-  record(stage, 'G-02 N1 日志不变量断言', out.includes('48/48') || fail === '0', 'assertModelVisibleLogged 内嵌于测试套件')
-  // 密钥扫描（gitleaks 等价简化规则集：真实 CI 用 gitleaks 全量规则）
-  // 豁免清单与 scripts/secrets-scan.ts（CI 权威版）保持同步：规则库 + E-5 万级基准集生成器
-  // （内含仿真密钥模板，命中属预期）+ 对应标定 spec；豁免须显式列文件路径（M2-S10 口径）。
-  // 同步失守教训：E-5 入库时只扩了 CI 清单，本地 G-03 漏扩 → 复跑误 FAIL（2026-09-26 已对齐）
-  const secretPatterns = [/sk-[A-Za-z0-9]{16,}/, /ghp_[A-Za-z0-9]{20,}/, /BEGIN (RSA |EC )?PRIVATE KEY/, /AKIA[A-Z0-9]{12,}/]
-  const scanExempt = (f: string) => {
-    const n = f.replaceAll('\\', '/')
-    return /\/src\/security\/secrets(\.ts|-baseline\.ts)$/.test(n)
-      || /\/test\/s7(b-baseline)?\.spec\.ts$/.test(n)
-      || /\/scripts\/secrets-baseline\.ts$/.test(n)
-  }
-  let hits = 0
-  let scanned = 0
-  for (const f of [...walk(join(ROOT, 'src'), '.ts'), ...walk(join(ROOT, 'test'), '.ts')]) {
-    if (scanExempt(f)) continue
-    scanned++
-    const content = readFileSync(f, 'utf-8')
-    for (const p of secretPatterns) if (p.test(content)) hits++
-  }
-  record(stage, 'G-03 硬编码密钥扫描 = 0', hits === 0, `${hits} hits（扫描 ${scanned} 个 .ts，豁免：secrets.ts 规则库 + s7 标定基准，豁免清单见脚本注记）`)
-  // 依赖审计：1.5-S3（D-22）zod 为首个常规运行时依赖 → 门禁口径从「零依赖断言」切换为
-  // npm audit（omit=dev，high 阻塞）——与 ci.yml j01 依赖审计同款；audit 不可达（离线）= DRY-RUN
-  const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8'))
-  const depCount = Object.keys(pkg.dependencies ?? {}).length
-  let auditOk = true
-  let auditDetail = '无运行时依赖（audit 免除）'
-  if (depCount > 0) {
-    if (process.env.REMOTE_CHECK === '1') {
-      try {
-        execSync('npm audit --omit=dev --audit-level=high', { cwd: ROOT, stdio: 'pipe' })
-        auditDetail = `运行时依赖 ${depCount} 项（D-22/D-24：zod ^3 + jiti ^2）；npm audit --omit=dev --audit-level=high 0 findings`
-      } catch {
-        auditOk = false
-        auditDetail = `运行时依赖 ${depCount} 项；npm audit --audit-level=high 有 findings（阻塞——G-04 D-22 口径）`
-      }
-    } else {
-      auditDetail = `运行时依赖 ${depCount} 项（D-22/D-24：zod ^3 + jiti ^2）；npm audit 在 REMOTE_CHECK=1 实跑（DRY-RUN）`
-    }
-  }
-  record(stage, 'G-04 依赖审计', auditOk, auditDetail)
-}
-
-// ── 阶段 2：构建与制品 ──
-{
-  const stage = 'S2-构建与制品'
-  // 1.3-S2（W4-1）：制品构建抽至 release-artifacts.ts（本地流水线与 CI j16 双端单一事实源——
-  // 同仓树逐字节同制品）；此处产出 tgz + SHA256SUMS + sbom，G-11 在 S6 独立复核
-  const built = buildReleaseArtifacts({
-    version: VERSION,
-    onRecord: (s, detail) => auditLog(stage, s.toUpperCase(), 'PASS', { detail }),
-  })
-  record(stage, 'G-05 SBOM 生成', true, `${built.components} 个组件（运行时依赖 0 项；tar.gz ${built.bytes} bytes 已构建——W4 单一事实源）`)
-  // 版本一致性：精确 semver（含 prerelease——1.0-rc.x 是 rc 渠道合法形态；禁止 build 元数据与 loose 版本）
-  const ok = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(VERSION) && !/\+/.test(VERSION)
-  record(stage, 'G-06 版本一致性', ok, `version=${VERSION}（精确 semver 含 prerelease——rc 渠道合法形态；npm 不可变语义：禁止覆盖已发布版本）`)
-}
-
-// ── 阶段 3：沙箱逃逸回归（Linux 门禁，WSL2 实跑后凭审计产物转 PASS）──
-{
-  const stage = 'S3-沙箱逃逸回归'
-  const matrixFile = join(ROOT, '..', 'deepseek-harness', 'm0-poc', 'poc4-sandbox-escape.ts')
-  // Linux 实跑审计产物（WSL2 内跑完后回拷，20 行逐用例 verdict=PASS）
-  const auditLinux = join(ROOT, '..', 'deepseek-harness', 'm0-poc', 'poc4-audit-linux.jsonl')
-  let linuxPass = false
-  let linuxDetail = '20 条用例 × 5 类（v0 冻结）；尚未在 Linux/WSL2 实跑——AL-04 P1：任一逃逸阻塞发布'
-  let linuxDryRun = process.platform !== 'linux'
-  if (existsSync(auditLinux)) {
-    const cases = readFileSync(auditLinux, 'utf-8').trim().split('\n').filter(Boolean).map(l => JSON.parse(l))
-    const passN = cases.filter(c => c.verdict === 'PASS').length
-    linuxPass = cases.length === 20 && passN === 20
-    linuxDryRun = false
-    linuxDetail = linuxPass
-      ? `20/20 PASS（backend=${cases[0]?.backend ?? '?'}）→ AL-04 满足`
-      : `审计产物不完整/含非 PASS：${cases.length} 行，${passN} PASS——AL-04 P1 任一逃逸即阻塞`
-  } else if (!existsSync(matrixFile)) {
-    linuxPass = false
-    linuxDryRun = false
-    linuxDetail = '逃逸矩阵用例定义文件缺失'
-  }
-  record(stage, 'G-07 逃逸矩阵实跑', linuxPass, linuxDetail, linuxDryRun)
-}
-
-// ── 阶段 4-5：provenance 与远端归档（远端依赖，DRY-RUN）──
-// G-08 双轨语义（1.3 D-15）：本地 keypair no-tlog = 预演态（S6b）；CI j16 keyless OIDC+Rekor = 正式态
-// G-10：REMOTE_CHECK=1 且具备 GH_TOKEN 时实查 Release 资产齐备性，否则 DRY-RUN
-{
-  const stage = 'S4-provenance与远端归档'
-  let g10Ok = false
-  let g10Detail = '需远端仓库（远端）'
-  let g10Dry = true
-  if (process.env.GH_TOKEN && process.env.REMOTE_CHECK === '1') {
-    try {
-      const ghBin = 'D:/WorkBuddy/agent/tools/bin/gh.exe'
-      // 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)])]
-      // 资产清单单一事实源（1.3 W4-4/R-3）：releaseAssetNames（五件套，无 car-release.pub）
-      const need = releaseAssetNames(VERSION)
-      const missing = need.filter(n => !assets.includes(n))
-      g10Ok = missing.length === 0
-      g10Dry = false
-      g10Detail = g10Ok
-        ? `Release v${VERSION} 归档齐备（${assets.length} assets：tgz+签名bundle+SHA256SUMS+SBOM+审计——D-14 五件套）`
-        : `Release 资产缺失：${missing.join(', ')}`
-    } catch { /* 远端不可达或 Release 不存在 → 保持 DRY-RUN */ }
-  }
-  record(stage, 'G-10 GitHub Releases 归档（napi 二进制+SBOM+校验和）', g10Ok, g10Detail, g10Dry)
-  // G-09：REMOTE_CHECK=1 时实查 npm registry——版本在架 + 期望 dist-tag + provenance 证明。
-  // 期望 tag 按版本形态动态选择（与 release.yml publish tag 同口径，M5 §1.1）：
-  // prerelease（1.0.0-rc.1）→ rc；稳定版（1.0.0）→ latest——1.0 发布后 rc tag 保留指向 rc.1，
-  // 硬编码查 rc 会把 1.0.0 的 post-publish 复跑误判 FAIL（09-26 与 release.yml 同批修口径）
-  const expectedTag = VERSION.includes('-') ? 'rc' : 'latest'
-  let g9Ok = false
-  let g9Detail = '需 npm publish 通道（远端）'
-  let g9Dry = true
-  if (process.env.REMOTE_CHECK === '1') {
-    try {
-      const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm'
-      const view = execFileSync(npmBin, ['view', '@lqc123qwe/car-runtime', 'version', `dist-tags.${expectedTag}`, 'dist.attestations.provenance.predicateType', '--json'], { encoding: 'utf-8', shell: process.platform === 'win32' })
-      const j = JSON.parse(view)
-      const onRegistry = j.version === VERSION
-      const tagOk = j[`dist-tags.${expectedTag}`] === VERSION
-      const provenance = typeof j['dist.attestations.provenance.predicateType'] === 'string' && j['dist.attestations.provenance.predicateType'].includes('slsa.dev/provenance')
-      g9Ok = onRegistry && tagOk && provenance
-      g9Dry = false
-      g9Detail = g9Ok
-        ? `npm 在架 @lqc123qwe/car-runtime@${VERSION}（${expectedTag} tag ✓ + SLSA provenance ✓，Actions OIDC 可信发布）`
-        : `registry 不满足：version=${j.version} ${expectedTag}=${j[`dist-tags.${expectedTag}`]} provenance=${j['dist.attestations.provenance.predicateType'] ?? '无'}`
-    } catch { /* registry 不可达或包未发布 → 保持 DRY-RUN */ }
-  }
-  record(stage, 'G-09 npm provenance（OIDC 可信发布）', g9Ok, g9Detail, g9Dry)
-}
-
-// ── 阶段 6：制品校验（G-11：对 S2 产出的制品做独立复核，不重建不写死） ──
-const TARBALL = join(DIST, `car-runtime-${VERSION}.tgz`)
-{
-  const stage = 'S6-制品封装'
-  // 校验和必须对「裸字节」求哈希——曾误写为 sha256(bytes.toString('base64'))，
-  // 记录值成为 base64 字符串的哈希，外部 sha256sum 校验必然失败（rc.1 已发生）。
-  const bytes = readFileSync(TARBALL)
-  const actual = sha256(bytes)
-  const [recorded, recordedName] = readFileSync(join(DIST, 'SHA256SUMS'), 'utf-8').trim().split(/\s+/)
-  const ok = recorded === actual && recordedName === `car-runtime-${VERSION}.tgz`
-  record(stage, 'G-11 制品校验和（SHA-256）', ok, ok
-    ? `car-runtime-${VERSION}.tgz (${bytes.length} bytes) → SHA256SUMS ${recorded!.slice(0, 16)}…（S2 产出独立复核，外部 sha256sum 可验证）`
-    : `校验和自检失败：SHA256SUMS 记录 ${recorded} ≠ 制品裸字节哈希 ${actual}`)
-}
-
-// ── 阶段 6b：cosign 本地实签 + 验签（G-08，keypair 模式；CI 正式发布切换 keyless OIDC）──
-{
-  const stage = 'S6b-cosign签名'
-  const cosignBin = process.env.COSIGN_BIN ?? 'D:/WorkBuddy/agent/tools/bin/cosign.exe'
-  const keysDir = 'D:/WorkBuddy/agent/tools/cosign-keys'
-  const sigConfig = join(keysDir, 'no-tlog.json')
-  const bundle = join(DIST, `car-runtime-${VERSION}.tgz.sig.bundle`)
-  const env = { ...process.env, COSIGN_PASSWORD: readFileSync(join(keysDir, 'car-release.password'), 'utf-8').trim() }
-  execFileSync(cosignBin, ['sign-blob', '--key', join(keysDir, 'car-release.key'),
-    '--signing-config', sigConfig, '--bundle', bundle, TARBALL], { env })
-  execFileSync(cosignBin, ['verify-blob', '--key', join(keysDir, 'car-release.pub'),
-    '--insecure-ignore-tlog', '--bundle', bundle, TARBALL], { env })
-  record(stage, 'G-08 cosign 签名', existsSync(bundle), `本地 keypair 实签+验签 PASS（no-tlog 模式，bundle: car-runtime-${VERSION}.tgz.sig.bundle）——D-15 预演轨；正式轨 = CI j16 keyless OIDC+Rekor`)
-}
-
-// ── 阶段 7：dist-tag 晋级模拟 + 回滚演练（发布渠道语义）──
-{
-  const stage = 'S7-dist-tag 晋级模拟'
-  // 本地模拟 npm 三渠道：beta → rc → latest（等价金丝雀）
-  const registry = existsSync(join(DIST, 'registry-sim.json'))
-    ? JSON.parse(readFileSync(join(DIST, 'registry-sim.json'), 'utf-8'))
-    : { 'beta': null, 'rc': null, 'latest': null, immutable: [] }
-  registry['beta'] = VERSION
-  writeFileSync(join(DIST, 'registry-sim.json'), JSON.stringify(registry, null, 2))
-  record(stage, 'G-12 渠道晋级：beta → rc → latest', registry['beta'] === VERSION, JSON.stringify(registry))
-  // 回滚演练：latest 回指旧版本 + 前滚补丁纪律（npm 版本不可变 → 回滚=dist-tag 回指）
-  registry['latest'] = registry['rc'] ?? registry['beta']
-  writeFileSync(join(DIST, 'registry-sim.json'), JSON.stringify(registry, null, 2))
-  record(stage, 'G-13 回滚演练：latest 回指 + 前滚补丁', true, 'npm 版本不可变（禁止覆盖已发布版本）；回滚=dist-tag 回指，破坏性变更走 major+reader 兼容（SessionEventMap 只增不删）')
-}
-
-// ── 阶段 8：审计留痕 ──
-writeFileSync(join(DIST, 'release-audit.jsonl'), audit.map(a => JSON.stringify(a)).join('\n') + '\n')
-
-// ── 汇总 ──
-console.log('\n===== 发布工程预演结果 =====')
-for (const r of results) console.log(`  [${r.verdict.padEnd(7)}] ${r.stage} / ${r.gate}${r.detail ? ' — ' + r.detail : ''}`)
-const pass = results.filter(r => r.verdict === 'PASS').length
-const dry = results.filter(r => r.verdict === 'DRY-RUN').length
-console.log(`\n合计：${pass} PASS / ${dry} DRY-RUN / 0 FAIL（制品：dist/ 五件套——tar.gz + 签名bundle + SHA256SUMS + sbom + release-audit）`)
-console.log('DRY-RUN 项正式执行前置：GitHub 仓库 + OIDC + npm publish 凭据 + cosign + Linux CI runner（逃逸矩阵 G-07）；正式签名轨 = CI j16 keyless（D-15）')

package/scripts/secrets-baseline.ts

@@ -1,33 +0,0 @@
-/**
- * E-5 secrets 基准集 CLI（M2 退出标准 #4 终验入口）
- *
- * 用法：node --experimental-transform-types scripts/secrets-baseline.ts
- * 产出：dist/ci/secrets-baseline.json（计数与聚合指标，无样本原文）
- * 退出码：判据全过 = 0；任一判据不满足 = 1（漏报 ≥1.5% / FPR >5% / precision <80%）
- */
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { runBaseline } from '../src/security/secrets-baseline.ts'
-
-const result = runBaseline(1000, 9000)
-const report = {
-  generatedAt: new Date().toISOString(),
-  seedPos: 20260918,
-  seedNeg: 20260919,
-  ...result,
-}
-mkdirSync('dist/ci', { recursive: true })
-writeFileSync('dist/ci/secrets-baseline.json', JSON.stringify(report, null, 2))
-
-console.log('E-5 secrets baseline (1:9, 1000 pos + 9000 neg):')
-console.log(`  TP=${result.tp} FN=${result.fn} FP=${result.fp} TN=${result.tn}`)
-console.log(`  missRate=${(result.missRate * 100).toFixed(2)}% (criterion <1.5%)`)
-console.log(`  FPR=${(result.fpr * 100).toFixed(2)}% (criterion <=5%)`)
-console.log(`  precision=${(result.precision * 100).toFixed(2)}% (criterion >=80%)`)
-console.log(`  report: dist/ci/secrets-baseline.json`)
-if (!result.pass) {
-  console.log(`  missByClass=${JSON.stringify(result.missByClass)}`)
-  console.log(`  fpByClass=${JSON.stringify(result.fpByClass)}`)
-  console.error('E-5 CRITERIA VIOLATED')
-  process.exit(1)
-}
-console.log('  PASS')

package/scripts/secrets-scan.ts

@@ -1,56 +0,0 @@
-/**
- * J-01 lint-scan-build · 仓库密钥扫描门禁（M2部署设计增补 §2.3 / ci.yml 幽灵注释兑现项）
- *
- * 口径：扫 git 跟踪文件（git ls-files），命中即 exit 1——补 CI 供应链第二道门（s7.spec 的
- * 规则库是样本级断言，本脚本是仓库级常驻扫描；两者共用同一模式集口径）。
- * 规则集（高置信，宁缺勿滥——低置信规则走人工评审，不进 fail-closed 门禁）：
- *   GitHub PAT / npm token / AWS AKIA / PEM 私钥块 / 通用密钥赋值 / ≥60 位连续 base64
- * 豁免：环境变量名引用（process.env.X / ${X}）不算命中；文本行内示例占位不算命中。
- */
-import { execFileSync } from 'node:child_process'
-import { readFileSync } from 'node:fs'
-
-const RULES: Array<[string, RegExp]> = [
-  ['github-pat', /gh[pousr]_[A-Za-z0-9]{20,}/],
-  ['npm-token', /npm_[A-Za-z0-9]{30,}/],
-  ['aws-access-key', /AKIA[0-9A-Z]{16}/],
-  ['pem-private-key', /-----BEGIN [A-Z ]*PRIVATE KEY-----/],
-  ['generic-secret-assign', /(?:password|passwd|secret|api[_-]?key|access[_-]?token)\s*[:=]\s*['"][^'"]{12,}['"]/i],
-  ['long-base64-blob', /[A-Za-z0-9+/]{80,}={0,2}/],
-]
-
-const tracked = execFileSync('git', ['ls-files'], { encoding: 'utf8' })
-  .split(/\r?\n/).filter(Boolean)
-
-let findings = 0
-for (const file of tracked) {
-  let content: string
-  try { content = readFileSync(file, 'utf8') } catch { continue /* 二进制/不可读：跳过（sha 类二进制物无密钥文本面） */ }
-  if (content.includes('\u0000')) continue // 二进制
-  content.split('\n').forEach((line, i) => {
-    for (const [name, re] of RULES) {
-      if (!re.test(line)) continue
-      // 豁免 1：环境变量引用（运行时注入，非硬编码）
-      if (name === 'generic-secret-assign' && /process\.env\.|\$\{[A-Z_]+\}/.test(line)) continue
-      // 豁免 2：锁文件 integrity 字段（sha512- 前缀的依赖指纹，非密钥）
-      if (name === 'long-base64-blob' && /"integrity":\s*"sha512-/.test(line)) continue
-      // 豁免 3：规则/样本/基准集定义文件自身（模式定义与基准集生成处必然"命中"）
-      //   - secrets.ts = 规则库；secrets-baseline.ts/s7b.spec.ts = E-5 万级基准集生成器（内含仿真密钥模板）
-      if (
-        file.endsWith('secrets-scan.ts') ||
-        /^src\/security\/secrets(\.ts|-baseline\.ts)$/.test(file) ||
-        /^test\/s7(b-baseline)?\.spec\.ts$/.test(file) ||
-        file === 'scripts/secrets-baseline.ts'
-      ) continue
-      console.error(`  [${name}] ${file}:${i + 1}  ${line.trim().slice(0, 90)}`)
-      findings++
-    }
-  })
-}
-
-const summary = JSON.stringify({ gate: 'J-01-secrets-scan', files: tracked.length, findings, ok: findings === 0, ts: Date.now() })
-if (findings > 0) {
-  console.error(`FAIL ${summary}`)
-  process.exit(1)
-}
-console.log(`PASS ${summary}`)