@lqc123qwe/car-runtime 1.0.0 → 1.1.0

package/README.md

@@ -124,11 +124,15 @@ node --experimental-transform-types --test test/*.spec.ts
 | `src/load/sigGate.ts` + `src/load/report.ts` verify 阶段 | M5-S28 装载签名门接线：manifestHash = 插件入口文件裸字节 sha256 hex（`<file>.minisig` sidecar，被签消息 = hex 串 UTF-8 字节）+ 流水线五阶段→**六阶段**（discover→**verify**→parse→…，先于 import() 模块执行前拦截）+ `car run` 直载门 + `car reload` 透传 + `car_load_total`/`car_unsigned_confirmed` 生产计数 + `CAR_TRUST_ROOT`/`CAR_SIG_ENFORCE`/`CAR_UNSIGNED_ALLOW` env 通道 + unsignedAllow→confirmed=yes 豁免改写 + fp 指纹横幅 | ADR-003 追记、DEC-1 ②、S20 §5 复评行 |
 | `test/s24-signature-gate.spec.ts` | M5-S28 测试：8 个 test（warn 缺签横幅+fp+confirmed=no / unsignedAllow=yes 改写+横幅保留 / enforce 缺签 FAIL+空 plugins / 坏签名硬拒绝不可豁免 / 好签名静默 / load_total 分母 / reload 透传 / 单文件门+env 映射） | 全量 204 |
 
+| `src/runtime-core/`（7 文件）+ `src/kernel` Context 根作用域 `effect()` + `src/dx/doctor.ts` keychain 行 | M8 运行时底座：types DTO（finishReason 不可变透传口径）/ llm.ts（AdapterRegistry 重复 id 显式报错 + withFinishReasonGuard 不可变守卫 + RuntimeCore Effect 可逆注册 + openai-compat SSE 适配器：TLS 强制 / 未映射 finish fail-visible / 首块前重试 ≤2 指数退避 / 凭据门 resolve→reveal→Bearer / A080001 首块前传播）/ credentials（Keychain→env，A080001 引导 car doctor）/ redaction（redact + StreamRedactor 跨 chunk 驻留）/ telemetry（OTel 门面默认关三原则）/ chatStep（SQ-07：N1 前置断言→投影请求→流消费→assistant 落 M7→toolUse 交 M4）/ errors（CarM8Error 双轨码） | §3.2.M8、SQ-07、O-11/O-13/O-14 |
+| `test/s25-m8-runtime-core.spec.ts` | M8 测试：27 个 test（注册表/finishReason 守卫/Effect 可逆/凭据三层/脱敏/遥测双路径/openai-compat SSE·重试·凭据门/chatStep 集成六面/SQ-07 端到端） | §3.2.M8 AC |
+
 ## M5 状态
 
 - **M5 收口（2026-09-12）**：三项 deferred 全部转正并验证——win32 sandbox spike 四判据自动断言全 PASS（S24/S25/S26）、JSON Schema→TS 深度参数渲染（dee4d67）、跨宿主 fork/resume（03c0fec）。全量 **156/156**。
 - 工具面 9→10（新增 `session_fork`）；`session_start` 增 importJsonl 导入路径；RC-3 冻结未生效（1.0-rc tag 未切），工具面契约变更合规登记。
 - **S28 收口（2026-09-26）**：**DEC-1 裁决 = ②**（warn + 《签名强制启用指南》组合发布 + RC-3 承诺显式降级；数据窗口 0 会话不满足切 enforce 前提，D-2 红线禁止无数据 enforce；宽限期 = 1.0 发布日 + 90 天，到期 enforce 默认值翻转为**计划内变更**——S20 §5 复评行归档）。配套工程同日收口：**装载签名门接线**——verifier 自 M2-S6（e11d23b）入库零生产调用点的缺口补齐（此前「已实装仅切默认值」口径经双向核查不成立，S20 §6 勘误登记）：loadPlugins 五阶段→六阶段（verify 先于 parse 的 import()，模块执行前拦截）+ car run 直载门 + car reload 透传 + car_load_total/car_unsigned_confirmed 生产计数 + manifestHash 指纹兜底实装 + CAR_TRUST_ROOT/CAR_SIG_ENFORCE/CAR_UNSIGNED_ALLOW env 通道。全量 **204（201 PASS + 3 能力门控 skip / 0 fail）**。S29 前置三修复（ce0bf65）：G-01 钉 tap reporter（Node 23 spec 默认致解析落空）/ G-03 豁免清单对齐 CI 权威版 / release.yml publish tag 动态化（1.0.0→latest，rc 保留指向 rc.1）。**GO-1 复跑达成：12 PASS / 1 DRY-RUN / 0 FAIL**（G-10 Release 实查挂 GO-7 token rotate 后全链验证收口）。
+- **S29/S30 收口（2026-09-26）**：**1.0.0 正式发布，M5 全程闭环**。GO-7 token rotate 收官（新 npm token 入 repo secret + PAT `*0Fbq`，全链 13 PASS，旧凭证双撤销）；version 1.0.0（`9435f99`）→ tag v1.0.0 → 发布前彩排 11+2 → Release v1.0.0（用户创建）→ j16 首跑 E403（npm 2FA 策略，bypass token 回退路径兑现）→ re-run 绿 `npm publish --provenance --tag latest` → dist-tags 终态 latest=1.0.0 / rc=rc.1 → Release 资产两件错挂修正 → **post-publish 13 PASS / 0 DRY-RUN / 0 FAIL** → 外部验证者等价检查（SHA256 MATCH + cosign Verified OK）→ S30 终验报告。**宽限期：2026-09-26 → 2026-12-25 到期 enforce 翻转**。
 
 ## M6 状态
 
@@ -146,9 +150,28 @@ node --experimental-transform-types --test test/*.spec.ts
 - **CI 能力真跑（防幽灵门禁）**：j02/j03/j04 测试命令直挂 `--experimental-sqlite`（22.5+ 带 flag 引入）；zstd 为 **22.15+ 原生内置（无 CLI flag**，Stability: 1 实验标记），22.19 原生在场直跑。排障两轮（run 35451413014/35451612564）：①node 运行时 flag 不能走 `NODE_OPTIONS`（白名单拒绝 + job 级 env 炸 actions 自身 node24），必须直挂命令行；②「not allowed in NODE_OPTIONS」是通用拒绝文案、**不代表 flag 存在**——`--experimental-zstd` 从未存在过。zstd 在场/缺席双路径各由在场/缺席环境实跑（skip 显式登记非静默）。**CI 收官（run 35452486131）：16/16 全绿**，三平台 195 用例实跑（zstd 在场路径含 ≥3x 压缩比断言 CI 首次实测通过）。
 - 口径备注：§3.2.M7.2 的 `--session id` 形态以 index（sessionId→file 映射）为底座登记后续增强，export 本迭代以文件路径为入口（与 verify/replay 形态一致）；运行时 append 异步索引自动更新登记后续（缺失由 rebuild 兜底，异步可容忍语义自洽）；deriveMessages 的 roleConsistencyChecked 在 v1 无消息改写面，登记 N/A。详见 `car-docs/10-内核v1/M7-会话日志与审计收口.md`。
 
+## M8 状态
+
+- **M8 收口（2026-09-26）**：§3.2.M8 运行时底座（模型接入 A4 + 遥测 A5）收口——WIP 七文件（09-19 产出）经检查点 `93b3938` 入库（kernel 根作用域 effect() 补齐宿主侧 Effect 生命周期 + doctor keychain 通道）后，本迭代交付：**M8-BUG-1 修复**（AL-05 兜底 sawFinish 条件化——成功流零 error chunk，缺失仍显式报错）+ openai-compat SSE/重试/凭据门 8 测试 + chatStep SQ-07 集成 7 测试。全量 **231（228 PASS + 3 能力门控 skip / 0 fail）** + tsc strict 0 错（CI 首跑揪出 93b3938 遗留 strict 错误，`9898563` 修复）+ secrets-scan 97 文件 0 命中（93b3938 夹具命中已修——上次会话 PASS 声明系伪造渲染产物）。**CI 收官（run 36237615992）：16/16 全绿**。
+- 口径备注：chatStep 库面已备已测，**runTurn（M4）侧消费接线登记后续**（「已实装」口径不外推）；openai-compat 为参考适配器（ACL 接口面已钉死）；遥测 OTLP 最小实现（无重试/采样）。详见 `car-docs/10-内核v1/M8-运行时底座收口.md`。
+
+## 1.1 状态（签名收尾最小集，enforce 翻转准备）
+
+| `src/load/sign.ts` | 1.1-S1 签名原语：generateSigningKeypair（ed25519 PKCS8 DER / SPKI base64）+ signPluginFile（sidecar `<file>.minisig` 单段 base64）+ resolveTrustRoot（flag > env > pub 文件）——指南 §2 node -e 手工流固化，与 verifier/sigGate 签验同源互验 | 1.1 W2-1 |
+| `src/load/config.ts` | 1.1-S3 配置文件通道：`car.config.json`（cwd 发现 + `--config` 显式；D-11a ①）——键位 `sandbox.unsigned.allow`/`sandbox.sig.enforce`/`sandbox.sig.trustRoot`，手写校验 fail-visible（CAR-E-CONFIG：坏 JSON/未知键/类型错显式拒绝）+ mergeSignatureGate 优先级 flag > env > 配置 > 缺省（env 已定义即显式意见） | 1.1 W2-3、部署设计 §4.5.5 |
+| `src/dx/doctor.ts` +2 | 1.1-S2 doctorSignature 签名就绪行（mode 生效值含配置层 / 信任根可解析性 / 配置文件发现态）+ doctorKeychain 专测补齐（M8 §4.6「已接线未专测」出清） | 1.1 W2-2/W2-5 |
+| `src/cli.ts` | 1.1：`car plugin-sign keygen/sign/verify`（退出码家规 0/1/2；私钥 0600；重复 keygen 拒绝覆盖）+ `--config` 通道接入 run/reload/mcp-serve + **mcp-serve 装载接线**（`--plugin` 可重复 / CAR_PLUGINS env；六阶段门 verify 先于 import()；car_load_total/car_unsigned_confirmed 全链进 stderr 快照；装载 FAIL = 启动中止 exit 1 两模式一致，warn 仅豁免缺签） | 1.1 W2-1/W2-4 |
+| `test/s26-signature-closeout.spec.ts` + `test/s27-host-load-wiring.spec.ts` + `test/s18.spec.ts` 边界行 | 1.1 测试：s26 13 test（keygen 签验闭环 / 手工口径字节等价 / CLI spawn 全链退出码 / 配置 fail-visible / 优先级四向 / doctor 三通道 / keychain 平台三态）+ s27 4 test（真进程装载四态：warn 全链 / enforce fail-closed / parse FAIL 不静默 / 配置通道好签名）+ s18 无 --plugin 边界断言 | 1.1-GO |
+
+- **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 复跑**。
+- **边界口径（防外推）**：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`。
+
 ## 状态
 
-- **版本主线**：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）**
+- **版本主线**：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 翻转准备）**
+- **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 门禁已接入）。
 - **决策已闭环**：**T-1** enforce 阈值定稿 **A=5% / B=2% / C=30 会话** + 裁决**显式延期**（2026-09-09，S20 §5 归档；红线禁止以 warn 静默进 1.0）｜**T-4** MLPS-G1 定时导出维持部署方配套（2026-09-09，D-4 追记）｜**DEC-2** Windows CI 接入 / **DEC-3** 发布前 token rotate / **DEC-4** M3 预埋项纳入 1.0（均 2026-09-09 裁决）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lqc123qwe/car-runtime",
-  "version": "1.0.0",
+  "version": "1.1.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/src/cli.ts

@@ -8,10 +8,11 @@
  *   car session replay <events.jsonl[.zstd]>      deriveMessages 投影回放（不依赖模型状态）
  *   car session export <file> --out <dir> [--zstd]  取证包导出（SQ-06：断链中止；落盘读回重验，离线自证）
  *   car session rebuild-index <root> [--db <path>]  从 JSONL 重建 SQLite 会话索引（幂等；断链/坏格式文件入 errors 跳过）
- *   car doctor                          环境自检（Node 版本/沙箱/凭据/连通性）
+ *   car doctor                          环境自检（Node 版本/沙箱/凭据/签名/keychain/连通性）
+ *   car plugin-sign keygen|sign|verify  插件签名工具（1.1-S1：keygen/sign/verify；离线 minisign 轨）
  */
 import { createHash } from 'node:crypto'
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { probeCapabilities, SandboxExecutor } from './sandbox/sandbox.ts'
 import { SessionLog, loadSessionLog, type SessionEvent } from './session/log.ts'
@@ -21,13 +22,15 @@ import { exportForensicsBundle, verifyBundle, type ExportMeta } from './session/
 import { runTurn } from './loop/stop.ts'
 import { Context } from './kernel/context.ts'
 import { mountPlugin } from './load/loader.ts'
-import { verifyPluginFile, gateDepsFromEnv } from './load/sigGate.ts'
-import { doctorCredentials, doctorConnectivity } from './dx/doctor.ts'
+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'
 
 const HELP = `用法: car <command> [args]
-  run <plugin.ts> [--sig-enforce]
+  run <plugin.ts> [--sig-enforce] [--config <path>]
                                     装配并运行插件（快速上手流；装载前签名门 warn 缺省）
-  reload <file|dir> [--sig-enforce]
+  reload <file|dir> [--sig-enforce] [--config <path>]
                                     热重载插件并打印六阶段加载报告（含 verify 签名门）
   session verify <file>            哈希链完整性校验（撕裂尾显式报告）
   session replay <file>            会话回放（deriveMessages 投影）
@@ -36,8 +39,16 @@ const HELP = `用法: car <command> [args]
   session rebuild-index <root> [--db <path>]
                                     从 JSONL 重建 SQLite 会话索引（幂等）
   doctor                环境自检
+  plugin-sign keygen [--out <前缀>] [--force]
+                                    生成 ed25519 签名密钥对（<前缀>.priv PKCS8 DER / <前缀>.pub SPKI base64；缺省前缀 car-release）
+  plugin-sign sign <file...> [--key <priv>]
+                                    对插件文件签名，写 <file>.minisig sidecar（被签物 = 文件裸字节 sha256 hex；改动文件必须重签）
+  plugin-sign verify <file...> [--trust-root <spki base64>]
+                                    验证签名（信任根序：--trust-root > CAR_TRUST_ROOT > ./car-release.pub；缺签/坏签均 FAIL）
 签名门环境变量：CAR_SIG_ENFORCE=1 切 enforce；CAR_TRUST_ROOT=<ed25519 spki base64>；
-CAR_UNSIGNED_ALLOW=1 显式声明豁免（warn 缺签路径计数 confirmed=yes，横幅保留）`
+CAR_UNSIGNED_ALLOW=1 显式声明豁免（warn 缺签路径计数 confirmed=yes，横幅保留）
+配置文件通道（1.1）：cwd car.config.json 或 --config <path>；键位 sandbox.unsigned.allow /
+sandbox.sig.enforce / sandbox.sig.trustRoot；优先级 flag > env > 配置 > 缺省；未知键 fail-visible`
 
 // 进程内热重载会话（ReloadManager 持有 epoch 与实例注册表；同进程连续 reload 语义完整）
 let reloadMgrPromise: Promise<import('./load/report.ts').ReloadManager> | undefined
@@ -46,6 +57,38 @@ function getReloadManager() {
   return reloadMgrPromise
 }
 
+/** 取 flag 的值（--config <path> 等；缺位返回 undefined） */
+function flagValue(argv: string[], name: string): string | undefined {
+  const i = argv.indexOf(name)
+  return i >= 0 ? argv[i + 1] : undefined
+}
+
+/** mcp-serve 插件源收集：--plugin <file|dir> 可重复 + CAR_PLUGINS env（';' 分隔，Windows 安全） */
+function collectPluginSources(argv: string[]): { sources: string[]; error?: string } {
+  const sources: string[] = []
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== '--plugin') continue
+    const v = argv[++i]
+    if (!v) return { sources, error: '缺少 --plugin 路径' }
+    sources.push(v)
+  }
+  for (const s of (process.env.CAR_PLUGINS ?? '').split(';')) {
+    const t = s.trim()
+    if (t) sources.push(t)
+  }
+  return { sources }
+}
+
+/**
+ * 装载签名门选项装配（1.1-S3 统一入口）：flag > env > car.config.json > 缺省 warn。
+ * 配置文件 fail-visible：显式路径不存在 / 坏 JSON / 未登记键 → 返回 error 由调用方中止（exit 2）。
+ */
+function resolveSigGate(argv: string[]): { options: import('./load/sigGate.ts').SignatureGateOptions; error?: string } {
+  const cfg = loadCarConfig({ explicitPath: flagValue(argv, '--config') })
+  if (cfg.error) return { options: {}, error: cfg.error }
+  return { options: mergeSignatureGate(process.env, cfg.config, argv.includes('--sig-enforce')) }
+}
+
 async function main(): Promise<number> {
   const [, , cmd, ...rest] = process.argv
   switch (cmd) {
@@ -53,10 +96,10 @@ async function main(): Promise<number> {
       const file = rest[0]
       if (!file) { console.error('缺少插件文件参数'); return 2 }
       const t0 = Date.now()
-      // 环节 0：装载前签名门（M5-S28；--sig-enforce 显式切 enforce，env 通道见 HELP）
-      const sigOpts = gateDepsFromEnv()
-      if (rest.includes('--sig-enforce')) sigOpts.mode = 'enforce'
-      const g = verifyPluginFile(file, sigOpts)
+      // 环节 0：装载前签名门（M5-S28 装载接线 + 1.1-S3 配置通道：flag > env > car.config.json > 缺省 warn）
+      const sig = resolveSigGate(rest)
+      if (sig.error) { console.error(sig.error); return 2 }
+      const g = verifyPluginFile(file, sig.options)
       if (!g.allowed) { console.error(`签名门禁拒绝：${g.error ?? 'CAR-E-SIG: rejected'}`); return 1 }
       if (g.warning) console.log(`[0/5 签名] ⚠ ${g.warning}`)
       // 环节 1：装配加载
@@ -104,10 +147,10 @@ async function main(): Promise<number> {
       if (!target) { console.error('缺少插件文件或目录参数'); return 2 }
       const { formatLoadReport } = await import('./load/report.ts')
       const mgr = await getReloadManager()
-      // 装载签名门透传（M5-S28）：--sig-enforce / env 通道，六阶段报告含 verify
-      const sigOpts = gateDepsFromEnv()
-      if (rest.includes('--sig-enforce')) sigOpts.mode = 'enforce'
-      const { report, plugins } = await mgr.reload(target, { signature: sigOpts })
+      // 装载签名门透传（M5-S28 + 1.1-S3 配置通道）：flag > env > car.config.json，六阶段报告含 verify
+      const sig = resolveSigGate(rest)
+      if (sig.error) { console.error(sig.error); return 2 }
+      const { report, plugins } = await mgr.reload(target, { signature: sig.options })
       for (const line of formatLoadReport(report)) console.log(line)
       console.log(`装配插件：${plugins.map(p => `${p.manifest.name}@${p.manifest.version}`).join(', ') || '无'}`)
       return report.stages.some(s => s.status === 'FAIL') ? 1 : 0
@@ -121,6 +164,12 @@ async function main(): Promise<number> {
       for (const c of doctorCredentials()) {
         console.log(`credentials.${c.envVar}: ${c.present ? '已设置（值不打印）' : `未设置 — ${c.hint}`}`)
       }
+      // M8 增强：keychain 通道状态（模型凭据读取面；缺席显式降级不静默）
+      const kc = doctorKeychain()
+      console.log(`keychain: ${kc.available ? '就绪' : `缺席（显式降级）— ${kc.note}`}`)
+      // 1.1-S2 增强：签名就绪行（mode 生效值 / 信任根可解析性 / 配置文件通道发现态；诊断只读）
+      const sig = doctorSignature({ cwd: process.cwd(), configPath: flagValue(rest, '--config') })
+      console.log(`signature: ${sig.detail}`)
       // M6 增强：registry 连通性（不可达 = SKIPPED 显式跳过，离线不失败）
       const conn = await doctorConnectivity()
       console.log(`connectivity: ${conn.status} — ${conn.detail}${conn.status === 'PASS' ? `（${conn.latencyMs}ms）` : ''}`)
@@ -225,6 +274,11 @@ async function main(): Promise<number> {
     }
     case 'mcp-serve': {
       // E-6 宿主实连入口（M4-S18）：CAR-as-MCP-Server——宿主（Claude Code/Codex）经 stdio JSON-RPC 接入
+      // 1.1-S4 装载接线：--plugin <file|dir>（可重复）/ CAR_PLUGINS env → 六阶段流水线（verify 门先于
+      // import()）挂载进 Context + car_load_total/car_unsigned_confirmed 全链计数。
+      // 边界（1.1 规划 W2-4，防口径外推）：此处是「装载接线 + 采集全链」——插件被真实装配
+      // （factory 执行 + bindCore 冲刷注册项），但宿主会话执行插件工具的执行接线属 W1 登记后续
+      // （sessionTurn 仍为事件批归一化）。
       const hostIdx = rest.indexOf('--host')
       const { HOST_MAPPINGS } = await import('./host/mappings.ts')
       // 默认宿主取映射表首项（数据驱动，静态架构断言红线：宿主标识只在 mappings 数据文件）
@@ -233,11 +287,43 @@ async function main(): Promise<number> {
       if (!HOST_MAPPINGS.some(h => h.hostId === hostId)) {
         console.error(`未知宿主 "${hostId}"（可用：${HOST_MAPPINGS.map(h => h.hostId).join(' | ')}）`); return 2
       }
+      // 1.1-S3 配置通道（--config / cwd car.config.json）+ 签名门选项（flag > env > 配置 > 缺省 warn）
+      const sig = resolveSigGate(rest)
+      if (sig.error) { console.error(sig.error); return 2 }
+      const pluginsArg = collectPluginSources(rest)
+      if (pluginsArg.error) { console.error(pluginsArg.error); return 2 }
+      const { createCounters, assertZeroContent } = await import('./telemetry/metrics.ts')
+      const counters = createCounters()
+      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) } })
+          if (result.report.stages.some(s => s.status === 'FAIL')) {
+            // 加载期显式失败红线（两模式一致）：FAIL = 插件未装上，服务不得静默缺插件启动。
+            // DEC-1 warn/enforce 之分仅在签名门缺签路径（warn=横幅放行，enforce=verify FAIL 走此分支）
+            for (const line of formatLoadReport(result.report)) console.error(line)
+            console.error('[car mcp-serve] 装载 FAIL——fail-closed 启动中止（warn 仅豁免缺签，不豁免装载失败）')
+            return 1
+          }
+          for (const w of result.report.warnings) console.error(`[car mcp-serve] ⚠ ${w}`)
+          for (const p of result.plugins) {
+            ctx.plugin({ name: p.manifest.name, apply: c => {
+              p.bindCore({
+                registerTool: t => { hostTools.push(t); c.provide('tool:' + t.name, t) },
+                getRegisteredTools: () => hostTools,
+              })
+            } })
+          }
+          const names = result.plugins.map(p => `${p.manifest.name}@${p.manifest.version}`).join(', ')
+          console.error(`[car mcp-serve] plugins loaded: ${names}（tools: ${hostTools.map(t => t.name).join(', ') || '无'}；装载已接线，会话内执行接线属 W1 登记后续）`)
+        }
+      }
       const { HostGateway } = await import('./host/hostGateway.ts')
       const { createRuntimeFacade } = await import('./host/facade.ts')
       const { createStdioServer } = await import('./host/stdio.ts')
-      const { createCounters, assertZeroContent } = await import('./telemetry/metrics.ts')
-      const counters = createCounters()
       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' }) })
@@ -249,6 +335,98 @@ async function main(): Promise<number> {
       console.error(`[car mcp-serve] host=${hostId} requests=${n} snapshot=${JSON.stringify(snap)} zeroContent=${assertZeroContent(snap)}`)
       return 0
     }
+    case 'plugin-sign': {
+      // 1.1-S1 插件签名工具（指南 §2 node -e 手工流固化）：keygen / sign / verify
+      // 退出码沿用家规：0=成功，1=数据校验失败（签名/验签不通过），2=用法/输入不可用
+      const [sub, ...sargs] = rest
+      const parseFiles = (argv: string[], keyFlag?: string): { files: string[]; keyPath?: string; trustRoot?: string; error?: string } => {
+        const files: string[] = []
+        let keyPath: string | undefined
+        let trustRoot: string | undefined
+        for (let i = 0; i < argv.length; i++) {
+          const a = argv[i]!
+          if (keyFlag && a === keyFlag) {
+            keyPath = argv[++i]
+            if (!keyPath) return { files, error: `缺少 ${keyFlag} 路径` }
+          } else if (a === '--trust-root') {
+            trustRoot = argv[++i]
+            if (!trustRoot) return { files, error: '缺少 --trust-root 值' }
+          } else if (a.startsWith('--')) {
+            return { files, error: `未知选项 ${a}` }
+          } else files.push(a)
+        }
+        return { files, keyPath, trustRoot }
+      }
+      if (sub === 'keygen') {
+        let prefix = 'car-release'
+        let force = false
+        for (let i = 0; i < sargs.length; i++) {
+          const a = sargs[i]!
+          if (a === '--out') { prefix = sargs[++i] ?? ''; if (!prefix) { console.error('缺少 --out 前缀'); return 2 } }
+          else if (a === '--force') force = true
+          else if (a.startsWith('--')) { console.error(`未知选项 ${a}`); return 2 }
+          else { console.error(`多余位置参数 ${a}`); return 2 }
+        }
+        const privPath = `${prefix}.priv`
+        const pubPath = `${prefix}.pub`
+        if (!force && (existsSync(privPath) || existsSync(pubPath))) {
+          console.error(`已存在 ${privPath} / ${pubPath}——拒绝覆盖（--force 显式覆盖）。注意：覆盖 ≠ 轮换，旧公钥仍在用请先按轮换流程处置`)
+          return 2
+        }
+        const kp = generateSigningKeypair()
+        writeFileSync(privPath, kp.privateKeyDer, { mode: 0o600 })
+        writeFileSync(pubPath, kp.publicKeyBase64)
+        console.log(`密钥对已生成（前缀 ${prefix}）：`)
+        console.log(`  私钥 ${privPath}（PKCS8 DER；离线保管，不入仓库——secrets 红线）`)
+        console.log(`  公钥 ${pubPath}（SPKI DER base64）`)
+        console.log(`信任根（CAR_TRUST_ROOT 值，或 plugin-sign verify --trust-root）：`)
+        console.log(kp.publicKeyBase64)
+        return 0
+      }
+      if (sub === 'sign') {
+        const p = parseFiles(sargs, '--key')
+        if (p.error) { console.error(p.error); return 2 }
+        if (!p.files.length) { console.error('缺少插件文件参数'); return 2 }
+        const keyPath = p.keyPath ?? 'car-release.priv'
+        let priv: Buffer
+        try { priv = readFileSync(keyPath) } catch {
+          console.error(`私钥不可读：${keyPath}（先 car plugin-sign keygen 生成，或 --key 指定路径）`)
+          return 2
+        }
+        let failed = false
+        for (const f of p.files) {
+          try {
+            const r = signPluginFile(f, priv)
+            console.log(`signed ${r.file} fp:${r.manifestHash.slice(0, 12)} → ${r.sidecar}`)
+          } catch (e) {
+            console.error(`sign FAIL ${f} — ${(e as Error).message}`)
+            failed = true
+          }
+        }
+        return failed ? 1 : 0
+      }
+      if (sub === 'verify') {
+        const p = parseFiles(sargs)
+        if (p.error) { console.error(p.error); return 2 }
+        if (!p.files.length) { console.error('缺少插件文件参数'); return 2 }
+        // 信任根解析序（与指南 §4 对齐）：--trust-root > CAR_TRUST_ROOT env > ./car-release.pub
+        const tr = resolveTrustRoot({ flag: p.trustRoot, env: process.env, pubFilePath: 'car-release.pub' })
+        if (!tr.value) {
+          console.error('无信任根：--trust-root / CAR_TRUST_ROOT / ./car-release.pub 均未提供（keygen 产出的 .pub 即信任根）')
+          return 2
+        }
+        let failed = false
+        for (const f of p.files) {
+          // verify 语义固定 enforce：缺签与坏签同为 FAIL（验签命令不做 warn 放行）
+          const g = verifyPluginFile(f, { mode: 'enforce', trustRootPublicKey: tr.value })
+          if (g.allowed && !g.warning) console.log(`verify: PASS ${f} fp:${g.manifestHash?.slice(0, 12)}（信任根来源 ${tr.source}）`)
+          else { console.error(`verify: FAIL ${f} — ${g.error ?? g.warning ?? 'rejected'}`); failed = true }
+        }
+        return failed ? 1 : 0
+      }
+      console.error('用法: car plugin-sign <keygen|sign|verify> [args]（--help 查看全部命令）')
+      return 2
+    }
     default:
       console.log(HELP)
       return cmd ? 2 : 0

package/src/dx/doctor.ts

@@ -4,7 +4,13 @@
  * 口径：
  *  - 凭据检查只探存在性、绝不打印值（secrets 红线：值入日志即泄露面）
  *  - 连通性检查网络不可达 = 显式 SKIPPED 而非 FAIL——测试环境必须可离线通过（不失败）
+ *  - 1.1-S2：签名就绪检查行（mode / 信任根 / 配置文件通道发现态）——诊断面只读，
+ *    门禁判定仍在 sigGate/verifier；公钥可打印、信任根值本身不打印
  */
+import { createPublicKey } from 'node:crypto'
+import { CredentialService } from '../runtime-core/credentials.ts'
+import { loadCarConfig, mergeSignatureGate } from '../load/config.ts'
+
 export interface CredentialCheck {
   name: string
   envVar: string
@@ -36,6 +42,54 @@ export interface ConnectivityResult {
   latencyMs: number
 }
 
+/** M8 增强：keychain 通道状态（模型凭据读取面，§3.2.M8.2 凭据行）——能力探测口径，缺席显式降级不静默；离线可过 */
+export function doctorKeychain(opts: { platform?: NodeJS.Platform } = {}): { available: boolean; note: string } {
+  return new CredentialService({ platform: opts.platform }).channelStatus
+}
+
+export interface SignatureCheck {
+  /** 生效模式（flag > env > 配置 > 缺省 warn——DEC-1 ②；enforce 缺省翻转 2026-12-25 登记计划内变更） */
+  mode: 'warn' | 'enforce'
+  /** 信任根通道：absent=未配置（全部插件按 unsigned 处理）；valid=在场且可解析；invalid=在场但解析失败（enforce 下拒签风险） */
+  trustRoot: 'absent' | 'valid' | 'invalid'
+  /** 配置文件通道（1.1-S3）：absent=cwd 未发现；found=已发现且校验通过；invalid=发现但解析/校验失败（fail-visible） */
+  configFile: 'absent' | 'found' | 'invalid'
+  detail: string
+}
+
+/** 1.1-S2 签名就绪检查：mode 生效值 + 信任根在场可解析性 + car.config.json 发现态（离线可过；值不打印） */
+export function doctorSignature(opts: { env?: NodeJS.ProcessEnv; cwd?: string; configPath?: string } = {}): SignatureCheck {
+  const env = opts.env ?? process.env
+  const cfg = loadCarConfig({ explicitPath: opts.configPath, cwd: opts.cwd })
+  let trustRoot: SignatureCheck['trustRoot'] = 'absent'
+  const raw = env.CAR_TRUST_ROOT || cfg.config.sandbox?.sigTrustRoot
+  if (raw) {
+    try {
+      createPublicKey({ key: Buffer.from(raw, 'base64'), format: 'der', type: 'spki' })
+      trustRoot = 'valid'
+    } catch {
+      trustRoot = 'invalid'
+    }
+  }
+  // 生效模式含配置层（配置文件解析失败时按 env/缺省口径合并，invalid 态在 configFile 显式呈现）
+  const { mode } = mergeSignatureGate(env, cfg.error ? {} : cfg.config)
+  const configFile: SignatureCheck['configFile'] = cfg.error ? 'invalid' : cfg.path ? 'found' : 'absent'
+  const parts = [
+    `mode=${mode}${mode === 'warn' ? '（DEC-1 ② 缺省；2026-12-25 到期翻转）' : ''}`,
+    trustRoot === 'absent'
+      ? '信任根未配置（全部插件按 unsigned 处理；car plugin-sign keygen 产出 .pub 即信任根）'
+      : trustRoot === 'valid'
+        ? '信任根已配置（ed25519 spki 可解析，值不打印）'
+        : '信任根已配置但不可解析（CAR-E-SIG 拒签风险——检查 CAR_TRUST_ROOT / sandbox.sig.trustRoot 是否为 spki base64）',
+    configFile === 'absent'
+      ? '配置文件未发现（car.config.json）'
+      : configFile === 'found'
+        ? `配置文件 ${cfg.path}（校验通过）`
+        : `配置文件无效（${cfg.error}）`,
+  ]
+  return { mode, trustRoot, configFile, detail: parts.join('；') }
+}
+
 /**
  * registry 连通性检查：可达 = PASS（含延迟）；不可达/显式跳过 = SKIPPED（不失败）。
  * 默认 registry 取 CAR_REGISTRY_URL，缺省 npmjs。

package/src/kernel/context.ts

@@ -50,6 +50,16 @@ export class Context {
     return s.impl
   }
 
+  /** 根作用域副作用登记（宿主 SDK 面，§3.2.M8 SDK 行）——与插件 fiber Effect 同纪律：body 即执行，disposer 入回卷清单 */
+  private rootDisposables: { label: string; disposer: Disposer }[] = []
+
+  /** 根作用域 Effect：宿主侧注册（RuntimeCore.registerLlmAdapter 等）入 disposeRuntime 回卷范围 */
+  effect(body: () => Disposer | Disposer[], label = 'anonymous'): void {
+    const res = body()
+    const disposers = typeof res === 'function' ? [res] : [...res]
+    for (const d of disposers) this.rootDisposables.push({ label, disposer: d as Disposer })
+  }
+
   /** 注册插件：依赖就绪即挂载，否则进入 PENDING 队列 */
   plugin(def: PluginDef): void {
     if (this.fibers.has(def.name)) {
@@ -115,6 +125,11 @@ export class Context {
   async disposeRuntime(opts: { order?: 'strict-topo' | 'concurrent' } = {}): Promise<DisposeReport> {
     const order = this.topoOrder()
     const report: DisposeReport = { unloaded: [], order: [], errors: [] }
+    // 根作用域（宿主 SDK 注册面，§3.2.M8）先于插件回卷：创建序的逆 = 根最后建、最先撤
+    for (const { label, disposer } of [...this.rootDisposables].reverse()) {
+      try { await disposer() } catch (error) { report.errors.push({ plugin: '<root>', label, error }) }
+    }
+    this.rootDisposables = []
     if ((opts.order ?? 'strict-topo') === 'strict-topo') {
       // 逐层排空：Kahn 分层为 provider→consumer 方向，卸载需反转（消费者层先于提供者层）
       for (const layer of [...order.layers].reverse()) {

package/src/load/config.ts

@@ -0,0 +1,129 @@
+/**
+ * 1.1-S3 · 签名配置文件通道（sandbox.* 键位空间；部署设计 §4.5.5 载体落地）
+ *
+ * 口径：
+ *  - 载体 = car.config.json（D-11a ①，2026-09-27 裁决：零依赖 / 免代码求值 / fail-visible 简单；
+ *    系统设计 §3.2 的 car.config.ts + zod configLoader 完整形态登记后续，届时迁移并保持键位兼容）
+ *  - 键位空间（嵌套 JSON 渲染点分键名）：
+ *      sandbox.unsigned.allow  （部署设计 §4.5.5 冻结键；= CAR_UNSIGNED_ALLOW 等价通道）
+ *      sandbox.sig.enforce     （= CAR_SIG_ENFORCE）
+ *      sandbox.sig.trustRoot   （= CAR_TRUST_ROOT；ed25519 公钥非凭据——CR-05「凭据禁入配置明文」不破）
+ *    未登记键 / 类型错 / 坏 JSON 一律 CAR-E-CONFIG 显式拒绝（fail-visible，禁静默忽略——
+ *    防拼写漂移导致的「配置写了但不生效」）
+ *  - 优先级（1.1 规划 §3 S3）：flag > env > 配置文件 > 缺省。env 已定义即为显式意见
+ *    （CAR_SIG_ENFORCE 非 '1' = 显式 warn，可压过配置 enforce；未定义才落到配置层）。
+ *    无配置文件 + 无 env 时行为与 1.0 完全一致（warn / 无信任根 / 不豁免）。
+ *  - 本模块只读配置与合并优先级；门禁判定在 sigGate/verifier。发现序：显式路径 > cwd car.config.json。
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { isAbsolute, join } from 'node:path'
+import type { SignatureGateOptions } from './sigGate.ts'
+
+export const CONFIG_FILENAME = 'car.config.json'
+
+export interface SandboxSigConfig {
+  unsignedAllow?: boolean
+  sigEnforce?: boolean
+  sigTrustRoot?: string
+}
+
+export interface CarConfig {
+  sandbox?: SandboxSigConfig
+}
+
+export interface ConfigLoadResult {
+  /** 实际读取的配置文件路径（cwd 未发现时缺省——未发现是正常态非错误） */
+  path?: string
+  config: CarConfig
+  /** fail-visible：显式路径不存在 / 坏 JSON / 未登记键 / 类型错的原因（非空 = 调用方必须中止） */
+  error?: string
+}
+
+/** 加载配置：显式路径（必须存在，否则报错）或 cwd 发现（未发现 = 正常态返回空配置） */
+export function loadCarConfig(opts: { explicitPath?: string; cwd?: string } = {}): ConfigLoadResult {
+  let path: string | undefined
+  if (opts.explicitPath) {
+    path = isAbsolute(opts.explicitPath) ? opts.explicitPath : join(opts.cwd ?? process.cwd(), opts.explicitPath)
+    if (!existsSync(path)) {
+      return { path, config: {}, error: `CAR-E-CONFIG: 配置文件不存在：${path}（--config 显式指定的路径必须存在）` }
+    }
+  } else {
+    path = join(opts.cwd ?? process.cwd(), CONFIG_FILENAME)
+    if (!existsSync(path)) return { config: {} }
+  }
+  let raw: unknown
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf-8'))
+  } catch (e) {
+    return { path, config: {}, error: `CAR-E-CONFIG: 配置文件解析失败（${(e as Error).message}）——坏 JSON 显式拒绝，不静默忽略` }
+  }
+  const v = validate(raw)
+  return v.error ? { path, config: {}, error: v.error } : { path, config: v.config }
+}
+
+/** 手写校验（fail-visible；零依赖红线——不引 zod，D-11a ①） */
+function validate(raw: unknown): { config: CarConfig; error?: string } {
+  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+    return { config: {}, error: 'CAR-E-CONFIG: 配置顶层必须为 JSON 对象' }
+  }
+  const out: CarConfig = {}
+  for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+    if (k !== 'sandbox') {
+      return { config: {}, error: `CAR-E-CONFIG: 未知顶层键 "${k}"（1.1 登记键位空间仅 sandbox.*）` }
+    }
+    if (typeof v !== 'object' || v === null || Array.isArray(v)) {
+      return { config: {}, error: 'CAR-E-CONFIG: sandbox 必须为对象' }
+    }
+    const sb: SandboxSigConfig = {}
+    for (const [sk, sv] of Object.entries(v as Record<string, unknown>)) {
+      if (sk === 'unsigned') {
+        if (typeof sv !== 'object' || sv === null || Array.isArray(sv)) return { config: {}, error: 'CAR-E-CONFIG: sandbox.unsigned 必须为对象' }
+        for (const [uk, uv] of Object.entries(sv as Record<string, unknown>)) {
+          if (uk !== 'allow') return { config: {}, error: `CAR-E-CONFIG: 未知键 sandbox.unsigned.${uk}（登记键位：sandbox.unsigned.allow）` }
+          if (typeof uv !== 'boolean') return { config: {}, error: 'CAR-E-CONFIG: sandbox.unsigned.allow 必须为布尔' }
+          sb.unsignedAllow = uv
+        }
+      } else if (sk === 'sig') {
+        if (typeof sv !== 'object' || sv === null || Array.isArray(sv)) return { config: {}, error: 'CAR-E-CONFIG: sandbox.sig 必须为对象' }
+        for (const [gk, gv] of Object.entries(sv as Record<string, unknown>)) {
+          if (gk === 'enforce') {
+            if (typeof gv !== 'boolean') return { config: {}, error: 'CAR-E-CONFIG: sandbox.sig.enforce 必须为布尔' }
+            sb.sigEnforce = gv
+          } else if (gk === 'trustRoot') {
+            if (typeof gv !== 'string' || !gv.trim()) return { config: {}, error: 'CAR-E-CONFIG: sandbox.sig.trustRoot 必须为非空字符串（ed25519 spki base64）' }
+            sb.sigTrustRoot = gv.trim()
+          } else {
+            return { config: {}, error: `CAR-E-CONFIG: 未知键 sandbox.sig.${gk}（登记键位：sandbox.sig.enforce / sandbox.sig.trustRoot）` }
+          }
+        }
+      } else {
+        return { config: {}, error: `CAR-E-CONFIG: 未知 sandbox 键 "${sk}"（1.1 登记键位：sandbox.unsigned.* / sandbox.sig.*）` }
+      }
+    }
+    out.sandbox = sb
+  }
+  return { config: out }
+}
+
+/** 合并产出（mode/unsignedAllow 恒有值——比 SignatureGateOptions 的可选字段更窄，doctor 等消费方免缺省分支） */
+export interface ResolvedSignatureGate {
+  mode: 'warn' | 'enforce'
+  trustRootPublicKey?: string
+  unsignedAllow: boolean
+}
+
+/**
+ * 优先级合并（flag > env > 配置 > 缺省）：产出装载签名门选项。
+ * flagEnforce = CLI --sig-enforce；env 已定义即为显式意见（压过配置），未定义落配置层。
+ */
+export function mergeSignatureGate(env: NodeJS.ProcessEnv, cfg: CarConfig, flagEnforce?: boolean): ResolvedSignatureGate {
+  // cfg 为校验器产出的扁平形状（sandbox.{unsignedAllow,sigEnforce,sigTrustRoot}，JSON 嵌套键已拍平）
+  let mode: 'warn' | 'enforce' = cfg.sandbox?.sigEnforce === true ? 'enforce' : 'warn'
+  if (env.CAR_SIG_ENFORCE !== undefined) mode = env.CAR_SIG_ENFORCE === '1' ? 'enforce' : 'warn'
+  if (flagEnforce) mode = 'enforce'
+  let trustRootPublicKey = cfg.sandbox?.sigTrustRoot
+  if (env.CAR_TRUST_ROOT) trustRootPublicKey = env.CAR_TRUST_ROOT
+  let unsignedAllow = cfg.sandbox?.unsignedAllow === true
+  if (env.CAR_UNSIGNED_ALLOW !== undefined) unsignedAllow = env.CAR_UNSIGNED_ALLOW === '1'
+  return { mode, trustRootPublicKey: trustRootPublicKey || undefined, unsignedAllow }
+}