@lqc123qwe/car-runtime 1.13.0 → 1.14.0

package/dist/seam.d.ts

@@ -17,6 +17,11 @@
  *   只读载入面；载入/校验单一权威在内核，桌面禁自实现哈希重算）+ K-S3-3 exportForensicsBundle/verifyBundle 出面
  *   （取证包导出 + 读回重验；断链即中止语义随本面）。恢复面 K-S3-2 零登记确认：SessionLog.fromEvents 自 M5 DEC-4
  *   起已随本面可达（fork.ts 生产调用点），S2 D-S2-6 前提修正登记（S3 执行期发现）。
+ * 加法登记：1.14.0 —— PluginManager 装载报告面（K-S4-1 / D-43）：loadPlugins 出面（六阶段流水线
+ *   discover/verify/parse/validate/topo/register——LoadReportVO 结构化 VO，verify/topo 真值取代 v0.1 桌面
+ *   mountPlugin 组合呈现的 SKIPPED 标注）+ ReloadManager 出面（热重载 epoch 击穿 + invalidate 语义随本面）+
+ *   verifyPluginFile 出面（签名校验挂载点——宿主自有装载路径可复用同一签名门；minisign 轨唯一实装，sigstore
+ *   主轨维持 verifier 骨架期预留——D-43 裁决：登记 strict 期限不引入 sigstore 依赖，engines 硬不兼容见评估报告）。
  */
 export { SessionLog, loadSessionLog, deriveSessionId, type SessionEvent, type EventKind, type Actor } from './session/log.ts';
 export { SessionFileStore } from './session/store.ts';
@@ -40,3 +45,5 @@ export { renderSdkFromRegistry } from './ptc/sdk.ts';
 export type { McpClientSpanHandle, PtcRelayHandle } from './runtime-core/trace.ts';
 export { redact, type RedactionResult } from './runtime-core/redaction.ts';
 export { exportForensicsBundle, verifyBundle, type ForensicsBundle, type ExportMeta } from './session/export.ts';
+export { loadPlugins, ReloadManager, type LoadReportVO, type LoadPluginsResult, type LoadPluginsOptions, type LoadStage, type StageStatus, type PeerConflictChain } from './load/report.ts';
+export { verifyPluginFile, type SignatureGateOptions, type SigGateResult } from './load/sigGate.ts';

package/dist/seam.js

@@ -17,6 +17,11 @@
  *   只读载入面；载入/校验单一权威在内核，桌面禁自实现哈希重算）+ K-S3-3 exportForensicsBundle/verifyBundle 出面
  *   （取证包导出 + 读回重验；断链即中止语义随本面）。恢复面 K-S3-2 零登记确认：SessionLog.fromEvents 自 M5 DEC-4
  *   起已随本面可达（fork.ts 生产调用点），S2 D-S2-6 前提修正登记（S3 执行期发现）。
+ * 加法登记：1.14.0 —— PluginManager 装载报告面（K-S4-1 / D-43）：loadPlugins 出面（六阶段流水线
+ *   discover/verify/parse/validate/topo/register——LoadReportVO 结构化 VO，verify/topo 真值取代 v0.1 桌面
+ *   mountPlugin 组合呈现的 SKIPPED 标注）+ ReloadManager 出面（热重载 epoch 击穿 + invalidate 语义随本面）+
+ *   verifyPluginFile 出面（签名校验挂载点——宿主自有装载路径可复用同一签名门；minisign 轨唯一实装，sigstore
+ *   主轨维持 verifier 骨架期预留——D-43 裁决：登记 strict 期限不引入 sigstore 依赖，engines 硬不兼容见评估报告）。
  */
 export { SessionLog, loadSessionLog, deriveSessionId } from './session/log.js';
 export { SessionFileStore } from './session/store.js';
@@ -40,3 +45,6 @@ export { renderSdkFromRegistry } from './ptc/sdk.js';
 // —— 1.13.0：桌面 S3 治理面（文件安全/审计/取证）——
 export { redact } from './runtime-core/redaction.js';
 export { exportForensicsBundle, verifyBundle } from './session/export.js';
+// —— 1.14.0（K-S4-1 / D-43）：PluginManager 装载报告面 + 签名校验挂载点 ——
+export { loadPlugins, ReloadManager } from './load/report.js';
+export { verifyPluginFile } from './load/sigGate.js';

package/dist/session/compact.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 1.14-S2 · 历史压缩面（K-MP-2 / D-40）——策略器 + 执行器 + 确定性摘要
+ *
+ * 口径（红线先立后码）：
+ *  - **append-only 红线**：压缩 = 追加一条 'compact' 事件（payload 携带摘要 + 折叠前缀边界
+ *    compactedUpTo），**不改写 / 不删除任何已落链事件**——SessionLog 无 update/delete API，
+ *    压缩只走 append；node:test 断言压缩前后 verifyChain() 均 null 且旧事件逐字节不变；
+ *  - **投影语义**：compact 只影响其后请求的投影（deriveMessages last-wins），压缩前快照
+ *    （atSeq ≤ compact.seq）投影仍为全量形态——N1 不变量（Model-visible means logged）
+ *    逐快照自洽，无需豁免；
+ *  - **保护段**：首个 system 事件（会话级提示）+ 最近 N turn（protectLastTurns，缺省 4）
+ *    不进折叠区间；中途 system 事件按普通事件折叠（内容保留进摘要，信息不丢——D-40 执行期细化）；
+ *  - **工具对完整性（toolPairIntegrity）**：折叠边界若落在 toolCall↔toolResult 配对中间
+ *    （call 在区间内、result 在保护段）→ 边界回退到该 toolCall（成对整体移出），循环至不动点；
+ *  - **fail-visible**：无可压缩区间（全部在保护段 / 已压缩过）→ CAR-E-COMPACT-NORANGE 显式报错，
+ *    禁静默成功；摘要生成产物非非空字符串 → CAR-E-COMPACT-SUMMARY 显式报错；
+ *  - **零新依赖**：摘要缺省为确定性生成器（轮次意图 + 工具调用统计 + 收口状态——事实拼装，
+ *    禁估算）；宿主可注入 LLM 摘要（summarize 缝——内核不依赖 LLM 做压缩）；
+ *  - **触发面**：shouldCompact 判定（thresholdEvents 事实计数，非 token 估算）+ applyCompaction
+ *    立即 API；自动挂载点在宿主装配层（runTurn 之间调用，内核不改 runTurn 语义）。
+ */
+import type { SessionEvent, SessionLog } from './log.ts';
+export interface CompactionConfig {
+    /** 缺省 false = 行为零变化（1.13 兼容线） */
+    enabled?: boolean;
+    /** 距上次压缩以来的新增事件数阈值（事实计数，非 token 估算）；缺省 200 */
+    thresholdEvents?: number;
+    /** 保护最近 N 个 turn 不折叠；缺省 4 */
+    protectLastTurns?: number;
+}
+export interface CompactionPlan {
+    /** 折叠前缀边界 [0, compactedUpTo)——compact 事件 payload 原样携带 */
+    compactedUpTo: number;
+    /** 折叠区间覆盖的 turn 数（去重） */
+    compactedTurns: number;
+    /** 折叠区间事件引用（供摘要生成；只读） */
+    events: readonly SessionEvent[];
+}
+/** shouldCompact：距上次压缩的新增事件数 ≥ thresholdEvents（enabled 缺省关 = 零变化） */
+export declare function shouldCompact(log: SessionLog, cfg: CompactionConfig | undefined): boolean;
+/**
+ * planCompaction：计算折叠区间（纯函数，不落链）。
+ * 保护段 = 首个 system 事件 + 最近 protectLastTurns 个 turn（按 turnId 首次出现序）；
+ * 边界回退保证 toolCall↔toolResult 成对（toolPairIntegrity）；无可压缩区间显式报错。
+ */
+export declare function planCompaction(log: SessionLog, protectLastTurns?: number): CompactionPlan;
+/** 确定性摘要（缺省生成器）：事实拼装（轮次意图 + 工具统计 + 收口状态），禁估算禁 LLM 依赖 */
+export declare function defaultSummarizer(events: readonly SessionEvent[]): string;
+/**
+ * applyCompaction：执行压缩（唯一落链动作 = append 一条 'compact' 事件——原事件链不改写）。
+ * summarize 缝：宿主可注入 LLM 摘要（返回非空字符串；缺省确定性生成器）。
+ */
+export declare function applyCompaction(log: SessionLog, opts?: {
+    protectLastTurns?: number;
+    turnId?: string;
+    summarize?: (events: readonly SessionEvent[]) => string;
+}): SessionEvent;

package/dist/session/compact.js

@@ -0,0 +1,128 @@
+/** 上次压缩边界（无 compact 事件 = 0）——重复压缩不越界（幂等区间的下界） */
+function lastCompactedUpTo(log) {
+    let last = 0;
+    for (const e of log.events) {
+        if (e.kind !== 'compact')
+            continue;
+        const p = (e.payload ?? {});
+        if (typeof p.compactedUpTo === 'number' && p.compactedUpTo > last)
+            last = p.compactedUpTo;
+    }
+    return last;
+}
+/** shouldCompact：距上次压缩的新增事件数 ≥ thresholdEvents（enabled 缺省关 = 零变化） */
+export function shouldCompact(log, cfg) {
+    if (!cfg || cfg.enabled !== true)
+        return false;
+    const threshold = cfg.thresholdEvents ?? 200;
+    return log.events.length - lastCompactedUpTo(log) >= threshold;
+}
+/**
+ * planCompaction：计算折叠区间（纯函数，不落链）。
+ * 保护段 = 首个 system 事件 + 最近 protectLastTurns 个 turn（按 turnId 首次出现序）；
+ * 边界回退保证 toolCall↔toolResult 成对（toolPairIntegrity）；无可压缩区间显式报错。
+ */
+export function planCompaction(log, protectLastTurns = 4) {
+    const events = log.events;
+    const floor = lastCompactedUpTo(log); // 上界不越过上次压缩边界（幂等）
+    // 保护起点候选：最近 N 个 turn 的首事件 seq
+    const turnFirst = new Map();
+    for (const e of events) {
+        if (e.turnId === 'compaction')
+            continue; // 压缩事件自身不构成 turn
+        if (!turnFirst.has(e.turnId))
+            turnFirst.set(e.turnId, e.seq);
+    }
+    const recentTurns = [...turnFirst.entries()].slice(-protectLastTurns);
+    let protectStart = recentTurns.length ? Math.min(...recentTurns.map(([, seq]) => seq)) : events.length;
+    // 统一规则：折叠区间 = [lowerBound, protectStart)，lowerBound = max(上次压缩边界, 首个 system.seq + 1)
+    // ——首个 system（会话级提示）恒不被折叠；floor 已含它时（上次压缩边界在其后）不受限
+    const firstSystem = events.find(e => e.kind === 'system');
+    const lowerBound = firstSystem ? Math.max(floor, firstSystem.seq + 1) : floor;
+    if (protectStart <= lowerBound) {
+        throw new Error(`CAR-E-COMPACT-NORANGE: 无可压缩区间（保护段 = 首个 system + 最近 ${protectLastTurns} turn，上次压缩边界 = ${floor}）——禁静默成功`);
+    }
+    // toolPairIntegrity：边界落在配对中间 → 回退到 toolCall（成对整体移出），循环至不动点
+    for (let guard = 0; guard < 1000; guard++) {
+        const callIds = new Map(); // id → call seq（区间内）
+        for (let i = lowerBound; i < protectStart; i++) {
+            const e = events[i];
+            if (e.kind === 'toolCall') {
+                const id = e.payload?.id;
+                if (typeof id === 'string')
+                    callIds.set(id, e.seq);
+            }
+        }
+        let earliestCallSeq;
+        for (let i = protectStart; i < events.length; i++) {
+            const e = events[i];
+            if (e.kind !== 'toolResult')
+                continue;
+            const id = e.payload?.id;
+            if (typeof id === 'string' && callIds.has(id)) {
+                const callSeq = callIds.get(id);
+                if (earliestCallSeq === undefined || callSeq < earliestCallSeq)
+                    earliestCallSeq = callSeq;
+            }
+        }
+        if (earliestCallSeq === undefined)
+            break; // 无破裂配对——边界成立
+        protectStart = earliestCallSeq; // 成对整体移出
+        if (protectStart <= lowerBound) {
+            throw new Error(`CAR-E-COMPACT-NORANGE: 工具对回退后无区间（toolCall↔toolResult 成对完整性不可满足）——禁静默成功`);
+        }
+    }
+    const compacted = events.slice(lowerBound, protectStart);
+    const turns = new Set(compacted.map(e => e.turnId));
+    return { compactedUpTo: protectStart, compactedTurns: turns.size, events: compacted };
+}
+/** 确定性摘要（缺省生成器）：事实拼装（轮次意图 + 工具统计 + 收口状态），禁估算禁 LLM 依赖 */
+export function defaultSummarizer(events) {
+    const cut = (v, n) => {
+        const s = typeof v === 'string' ? v : JSON.stringify(v);
+        return s.length > n ? s.slice(0, n) + '…' : s;
+    };
+    const lines = [`[会话压缩摘要] 折叠事件 ${events.length} 条（${events[0]?.seq ?? 0}–${events.at(-1)?.seq ?? 0}）：`];
+    const toolCounts = new Map();
+    const endReasons = new Map();
+    for (const e of events) {
+        if (e.kind === 'user')
+            lines.push(`- [${e.turnId}] 用户：${cut(e.payload, 200)}`);
+        else if (e.kind === 'assistant' && typeof e.payload === 'string' && e.payload.trim())
+            lines.push(`- [${e.turnId}] 助手：${cut(e.payload, 160)}`);
+        else if (e.kind === 'toolCall') {
+            const p = e.payload;
+            const name = typeof p?.tool === 'string' ? p.tool : '?';
+            toolCounts.set(name, (toolCounts.get(name) ?? 0) + 1);
+        }
+        else if (e.kind === 'turnEnd') {
+            const r = e.meta?.reason;
+            const key = typeof r === 'string' ? r : 'unknown';
+            endReasons.set(key, (endReasons.get(key) ?? 0) + 1);
+        }
+    }
+    if (toolCounts.size) {
+        lines.push(`工具调用：${[...toolCounts.entries()].map(([t, n]) => `${t} ×${n}`).join('、')}`);
+    }
+    if (endReasons.size) {
+        lines.push(`turn 收口：${[...endReasons.entries()].map(([r, n]) => `${r} ×${n}`).join('、')}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * applyCompaction：执行压缩（唯一落链动作 = append 一条 'compact' 事件——原事件链不改写）。
+ * summarize 缝：宿主可注入 LLM 摘要（返回非空字符串；缺省确定性生成器）。
+ */
+export function applyCompaction(log, opts = {}) {
+    const plan = planCompaction(log, opts.protectLastTurns ?? 4);
+    const summary = opts.summarize ? opts.summarize(plan.events) : defaultSummarizer(plan.events);
+    if (typeof summary !== 'string' || !summary.trim().length) {
+        throw new Error(`CAR-E-COMPACT-SUMMARY: 摘要生成产物为空（fail-visible，禁静默折叠空摘要）`);
+    }
+    return log.append('runtime', 'compact', opts.turnId ?? 'compaction', {
+        summary,
+        compactedUpTo: plan.compactedUpTo,
+        compactedTurns: plan.compactedTurns,
+        compactedEvents: plan.events.length,
+    });
+}

package/dist/session/log.d.ts

@@ -1,4 +1,4 @@
-export type EventKind = 'user' | 'assistant' | 'toolCall' | 'toolResult' | 'turnEnd' | 'goalUpdate' | 'hostRaw' | 'fork' | 'system' | 'usage';
+export type EventKind = 'user' | 'assistant' | 'toolCall' | 'toolResult' | 'turnEnd' | 'goalUpdate' | 'hostRaw' | 'fork' | 'system' | 'usage' | 'compact' | 'routing';
 export type Actor = 'user' | 'model' | 'plugin' | 'runtime';
 export interface SessionEvent {
     seq: number;
@@ -41,6 +41,10 @@ export declare class SessionLog {
      * 模型可见流只保留最终结果（真实 provider 对重复 tool_call_id/tool_use_id 拒绝或未定义，
      * 1.4 观察项经真实适配器落地升级为缺陷面）。id 缺席不收敛（hostRaw/无 id 载荷形态不变，
      * golden ④ 投影语义兼容）；授权拒绝单条即唯一结果原样保留。适配器侧零改动（消费已收敛上游）。
+     * 1.14-S2（K-MP-2 / D-40）：compact 事件投影——scoped 内最后一条 compact 生效（last-wins），
+     * 其 compactedUpTo 前缀折叠为单条 system 摘要（事件原文不改写，仅投影层折叠）；compact 之前的
+     * 请求快照（atSeq ≤ compact.seq）不含 compact 事件 → 投影仍为全量形态（N1 不变量自洽——
+     * 「请求时发出 = 日志前缀投影」逐快照成立）；无 compact 事件的日志投影与 1.13 逐字节一致。
      */
     deriveMessages(upTo?: number): Array<{
         role: string;

package/dist/session/log.js

@@ -64,11 +64,29 @@ export class SessionLog {
      * 模型可见流只保留最终结果（真实 provider 对重复 tool_call_id/tool_use_id 拒绝或未定义，
      * 1.4 观察项经真实适配器落地升级为缺陷面）。id 缺席不收敛（hostRaw/无 id 载荷形态不变，
      * golden ④ 投影语义兼容）；授权拒绝单条即唯一结果原样保留。适配器侧零改动（消费已收敛上游）。
+     * 1.14-S2（K-MP-2 / D-40）：compact 事件投影——scoped 内最后一条 compact 生效（last-wins），
+     * 其 compactedUpTo 前缀折叠为单条 system 摘要（事件原文不改写，仅投影层折叠）；compact 之前的
+     * 请求快照（atSeq ≤ compact.seq）不含 compact 事件 → 投影仍为全量形态（N1 不变量自洽——
+     * 「请求时发出 = 日志前缀投影」逐快照成立）；无 compact 事件的日志投影与 1.13 逐字节一致。
      */
     deriveMessages(upTo) {
         const scoped = upTo !== undefined ? this.events.slice(0, upTo) : this.events;
-        const lastSeqById = new Map();
+        let compactEvent;
         for (const e of scoped) {
+            if (e.kind === 'compact')
+                compactEvent = e;
+        } // last-wins
+        let compactedUpTo;
+        if (compactEvent) {
+            const cp = (compactEvent.payload ?? {});
+            if (typeof cp.summary !== 'string' || !cp.summary.length || typeof cp.compactedUpTo !== 'number') {
+                throw new Error(`CAR-E-COMPACT-PAYLOAD: compact 事件 seq=${compactEvent.seq} 缺有效 summary/compactedUpTo（投影拒绝——fail-visible）`);
+            }
+            compactedUpTo = cp.compactedUpTo; // 折叠边界 = payload 声明的前缀边界（非 compact 事件自身 seq）
+        }
+        const projected = compactedUpTo !== undefined ? scoped.filter(e => e.seq >= compactedUpTo) : scoped;
+        const lastSeqById = new Map();
+        for (const e of projected) {
             if (e.kind !== 'toolResult')
                 continue;
             const id = e.payload?.id;
@@ -76,7 +94,9 @@ export class SessionLog {
                 lastSeqById.set(id, e.seq);
         }
         const out = [];
-        for (const e of scoped) {
+        if (compactEvent)
+            out.push({ role: 'system', content: (compactEvent.payload.summary) });
+        for (const e of projected) {
             if (e.kind === 'system')
                 out.push({ role: 'system', content: e.payload });
             else if (e.kind === 'user')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lqc123qwe/car-runtime",
-  "version": "1.13.0",
+  "version": "1.14.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

@@ -25,6 +25,7 @@ import { Context } from './kernel/context.ts'
 import { mountPlugin } from './load/loader.ts'
 import { verifyPluginFile } from './load/sigGate.ts'
 import { loadCarConfig, mergeSignatureGate, mergeLlmConfig, warmCarConfig } from './load/config.ts'
+import { assembleModelPool } from './load/pool.ts'
 import { generateSigningKeypair, signPluginFile, resolveTrustRoot } from './load/sign.ts'
 import { doctorCredentials, doctorConnectivity, doctorKeychain, doctorSignature, doctorModelReadiness } from './dx/doctor.ts'
 import { RuntimeCore, createOpenAICompatAdapter, createAnthropicAdapter } from './runtime-core/llm.ts'
@@ -64,8 +65,9 @@ const HELP = `用法: car <command> [args]
 CAR_UNSIGNED_ALLOW=1 显式声明豁免（warn 缺签路径计数 confirmed=yes，横幅保留）
 配置文件通道（1.5 起双载体）：cwd car.config.ts（export default {…}；发现序 ts > json）或
 car.config.json 或 --config <path>；键位 sandbox.unsigned.allow / sandbox.sig.enforce /
-sandbox.sig.trustRoot / llm.* / mcp.servers.*（stdio: command/args/env；远程: url/headers，
-\${ENV_VAR} 引用注入凭据）；优先级 flag > env > 配置 > 缺省；未知键 fail-visible`
+sandbox.sig.trustRoot / llm.* / llm.modelPool.*（多端点 fallback：endpoints id/baseUrl/model/
+adapterId/keyEnv/priority/weight/maxTokens + probe + maxAttempts；路由决策落链）/ mcp.servers.*
+（stdio: command/args/env；远程: url/headers，\${ENV_VAR} 引用注入凭据）；优先级 flag > env > 配置 > 缺省；未知键 fail-visible`
 
 // 进程内热重载会话（ReloadManager 持有 epoch 与实例注册表；同进程连续 reload 语义完整）
 let reloadMgrPromise: Promise<import('./load/report.ts').ReloadManager> | undefined
@@ -193,27 +195,55 @@ async function main(): Promise<number> {
           ...(mtFlag !== undefined ? { maxTokens: Number(mtFlag) } : {}),
         })
         const prompt = flagValue(rest, '--prompt')
-        if (!llm.baseUrl || !llm.model || prompt === undefined) {
-          console.error('CAR-E-LLM-CONFIG: 真实模型路径需要 baseUrl + model + --prompt——')
-          console.error('  配置：car.config.ts（export default）或 car.config.json {"llm":{"baseUrl":"https://…","model":"…"}} / env CAR_LLM_BASE_URL+CAR_LLM_MODEL / flag --base-url --model --prompt')
-          console.error('  anthropic：llm.adapterId "anthropic"（或 --adapter-id anthropic）+ baseUrl https://api.anthropic.com；凭据 ANTHROPIC_API_KEY')
-          console.error('  凭据：OPENAI_API_KEY / ANTHROPIC_API_KEY（env fallback 需 CAR_ALLOW_ENV_CREDENTIALS=1 或 llm.allowEnvFallback）或 keychain；诊断：car doctor')
+        if (prompt === undefined) {
+          console.error('CAR-E-LLM-CONFIG: 真实模型路径需要 --prompt——')
           console.error('  （无模型演示流：--demo）')
           return 2
         }
-        const modelName = llm.model
+        // 1.14-S4（K-POOL-1 / D-42）：modelPool 登记时池装配压过 llm.baseUrl/model/adapterId（每次路由决策落链可解释）
+        const poolCfg = cfgLlm.config.modelPool ?? null
+        const cfgBaseUrl = llm.baseUrl
+        const cfgModel = llm.model
+        let modelName = cfgModel ?? ''
         const credService = new CredentialService()
         const core = new RuntimeCore(credService)
         core.bindContext(ctx)
         // 适配器经根作用域 effect 可逆注册（bindContext 必须先于 register——否则走非可逆直注册分支）；
-        // 1.5-S1（D-20）：adapterId='anthropic' → anthropic 适配器（Messages API）；缺省 openai-compat 不变
-        core.registerLlmAdapter(llm.adapterId === 'anthropic'
-          ? createAnthropicAdapter({ baseUrl: llm.baseUrl, credentials: credService, provider: 'anthropic' })
-          : createOpenAICompatAdapter({
-              baseUrl: llm.baseUrl,
-              credentials: credService,
-              provider: 'openai-compat',
-            }), { default: true })
+        // 1.5-S1（D-20）：adapterId='anthropic' → anthropic 适配器（Messages API）；缺省 openai-compat 不变；
+        // 1.14-S4（K-POOL-1 / D-42）：modelPool 登记时池装配压过单端点（onDecide → routing/decide 落链）
+        if (poolCfg) {
+          const assembly = assembleModelPool({
+            pool: poolCfg,
+            credentials: credService,
+            onDecide: d => log.append('runtime', 'routing', d.turnId ?? 'T0', {
+              type: 'decide',
+              selected: d.selected,
+              reason: d.reason,
+              retries: d.retries,
+              attempts: d.attempts,
+            }),
+          })
+          core.registerLlmAdapter(assembly.adapter, { default: true })
+          // chatStep model 形参 = 首位候选（池内逐成员改写 req.model——usage 按成员模型落账）
+          modelName = assembly.members[0]!.model
+          console.log(`[pool] ${assembly.members.length} 端点入池（候选序：${assembly.members.map(m => m.id).join(' → ')}）`)
+        } else {
+          if (!cfgBaseUrl || !cfgModel) {
+            console.error('CAR-E-LLM-CONFIG: 真实模型路径需要 baseUrl + model——')
+            console.error('  配置：car.config.ts（export default）或 car.config.json {"llm":{"baseUrl":"https://…","model":"…"}} / env CAR_LLM_BASE_URL+CAR_LLM_MODEL / flag --base-url --model')
+            console.error('  anthropic：llm.adapterId "anthropic"（或 --adapter-id anthropic）+ baseUrl https://api.anthropic.com；凭据 ANTHROPIC_API_KEY')
+            console.error('  模型池：llm.modelPool.endpoints（多端点 fallback + health 预检；凭据 keyEnv 引用；路由决策落链）')
+            console.error('  凭据：OPENAI_API_KEY / ANTHROPIC_API_KEY（env fallback 需 CAR_ALLOW_ENV_CREDENTIALS=1 或 llm.allowEnvFallback）或 keychain；诊断：car doctor')
+            return 2
+          }
+          core.registerLlmAdapter(llm.adapterId === 'anthropic'
+            ? createAnthropicAdapter({ baseUrl: cfgBaseUrl, credentials: credService, provider: 'anthropic' })
+            : createOpenAICompatAdapter({
+                baseUrl: cfgBaseUrl,
+                credentials: credService,
+                provider: 'openai-compat',
+              }), { default: true })
+        }
         // MCP 工具进 turn（D-18）：--mcp <serverId>（可重复；server 启动规格在 car.config.json mcp.servers 登记）
         const mcpIds: string[] = []
         // 1.8-D29：活跃 turn span 句柄（startTurn 后赋值——MCP 工具闭包运行期取 client span 挂链面）
@@ -302,7 +332,8 @@ async function main(): Promise<number> {
               model: modelName,
               tools: toToolDefinitions(toolsMap),
               ...(llm.maxTokens !== undefined ? { maxTokens: llm.maxTokens } : {}),
-              ...(llm.adapterId ? { adapterId: llm.adapterId } : {}),
+              // 1.14-S4：池装配时不传 adapterId（池适配器 = default；req.model 由池内按成员改写）
+              ...(poolCfg ? {} : llm.adapterId ? { adapterId: llm.adapterId } : {}),
               signal,
             }).then(
               res => { step.end(res.stopReason); return res },

package/src/load/config.ts

@@ -35,12 +35,59 @@ export interface SandboxSigConfig {
   sigTrustRoot?: string
 }
 
+export interface CompactionConfig {
+  /** 缺省 false = 行为零变化（1.13 兼容线） */
+  enabled?: boolean
+  /** 距上次压缩的新增事件数阈值（事实计数非估算）；缺省 200 */
+  thresholdEvents?: number
+  /** 保护最近 N 个 turn 不折叠；缺省 4 */
+  protectLastTurns?: number
+}
+
 export interface LlmConfig {
   baseUrl?: string
   model?: string
   adapterId?: string
   maxTokens?: number
   allowEnvFallback?: boolean
+  /** 1.14-S2（K-MP-2 / D-40）：历史压缩策略（阈值自动触发判定入参；立即压缩 API 独立可用） */
+  compaction?: CompactionConfig
+}
+
+/** 1.14-S4（K-POOL-1 / D-42）：模型池端点登记（多端点 fallback 候选；凭据仅收 keyEnv 引用） */
+export interface ModelPoolEndpointSpec {
+  /** 端点标识（routing/decide 落链定位；缺省 ep-1..N 派生；重复显式拒绝） */
+  id?: string
+  baseUrl: string
+  model: string
+  /** 适配器家族（config 可装配集 = 内置两族；缺省 openai-compat） */
+  adapterId?: 'openai-compat' | 'anthropic'
+  /** 凭据 env 变量名引用（明文 key 显式拒绝——CR-05；缺省按 adapterId 缺省表 + CAR_LLM_API_KEY） */
+  keyEnv?: string
+  /** 优先级：数值越小越优先（缺省 0） */
+  priority?: number
+  /** 同优先级内次序：越大越先（缺省 0——D-42：登记生效为排序 tie-break，不做负载均衡调度） */
+  weight?: number
+  /** 成员级 maxTokens（缺省回落 llm.maxTokens） */
+  maxTokens?: number
+}
+
+/** 1.14-S4（K-POOL-1 / D-42）：health 预检策略（doctor 面同款口径——值不打印） */
+export interface ModelPoolProbeConfig {
+  /** 缺省开；不可达端点按序跳过（fail-visible 落 routing/decide attempts） */
+  enabled?: boolean
+  /** 单端点探测超时（缺省 4000ms） */
+  timeoutMs?: number
+  /** 探测结果缓存 TTL（缺省 30000ms；0 = 每请求重探） */
+  ttlMs?: number
+}
+
+/** 1.14-S4（K-POOL-1 / D-42）：模型池登记。与 llm.baseUrl/model/adapterId 并存时池装配压过（每次路由决策落链可解释）；llm.maxTokens/allowEnvFallback/compaction 仍生效。无 modelPool 配置 = 行为与 1.13 逐字节一致（兼容验收线） */
+export interface ModelPoolConfig {
+  endpoints: ModelPoolEndpointSpec[]
+  probe?: ModelPoolProbeConfig
+  /** 候选请求尝试上限（含首选；缺省 = 端点数） */
+  maxAttempts?: number
 }
 
 export interface McpServerSpec {
@@ -59,6 +106,8 @@ export interface CarConfig {
   sandbox?: SandboxSigConfig
   /** 1.4-S3（D-16）：模型接入配置键位空间；凭据禁入（CR-05）——只放端点/模型名/开关 */
   llm?: LlmConfig
+  /** 1.14-S4（K-POOL-1 / D-42）：模型池登记（多端点 fallback；与 llm.* 并存时池压过，路由决策落链） */
+  modelPool?: ModelPoolConfig
   /** 1.4-S7（D-18）：MCP server 登记面（--mcp <id> 显式启用） */
   mcp?: { servers: Record<string, McpServerSpec> }
 }
@@ -82,6 +131,66 @@ const nonEmptyTrimmed = () =>
 const stringMap = () =>
   z.record(z.string(), z.string({ invalid_type_error: '必须为字符串' }), { invalid_type_error: '必须为字符串映射', required_error: '必须为字符串映射' })
 
+// 1.14-S4（K-POOL-1）辅助：正整数 / 非负整数
+const positiveInt = () =>
+  z.number({ invalid_type_error: '必须为正整数', required_error: '必须为正整数' })
+    .refine(v => Number.isFinite(v) && Number.isInteger(v) && v > 0, { message: '必须为正整数' })
+const nonNegativeInt = () =>
+  z.number({ invalid_type_error: '必须为非负整数', required_error: '必须为非负整数' })
+    .refine(v => Number.isFinite(v) && Number.isInteger(v) && v >= 0, { message: '必须为非负整数' })
+
+// 明文凭据键黑名单（1.14-S4 / CR-05）：专用文案先于未知键检查（首个 issue 渲染）
+const PLAINTEXT_CRED_KEYS = ['key', 'apiKey', 'api_key', 'apikey', 'token', 'password']
+const ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/
+const POOL_ENDPOINT_KEYS = new Set(['id', 'baseUrl', 'model', 'adapterId', 'keyEnv', 'priority', 'weight', 'maxTokens'])
+
+/**
+ * 池端点 schema（1.14-S4）：passthrough + superRefine 显式拒绝（等价 strict，但明文凭据键
+ * 给专用文案——CR-05 红线「明文 key 显式拒绝」必须可读可引导，不能只报「未知键」）。
+ */
+const poolEndpointSchema = z.object({
+  id: nonEmptyTrimmed().optional(),
+  baseUrl: nonEmptyTrimmed().refine(v => /^https?:\/\//.test(v), { message: '必须为 http(s) URL' }),
+  model: nonEmptyTrimmed(),
+  adapterId: z.enum(['openai-compat', 'anthropic'], { errorMap: () => ({ message: '必须为 openai-compat 或 anthropic（config 可装配集 = 内置两族）' }) }).optional(),
+  keyEnv: nonEmptyTrimmed().refine(v => ENV_NAME_RE.test(v), { message: '必须为环境变量名（明文凭据禁入——凭据仅收 keyEnv 引用，CR-05）' }).optional(),
+  priority: positiveInt().optional(),
+  weight: nonNegativeInt().optional(),
+  maxTokens: positiveInt().optional(),
+}).passthrough().superRefine((obj, ctx) => {
+  for (const k of PLAINTEXT_CRED_KEYS) {
+    if (k in obj) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: [k], message: `明文凭据禁入——凭据仅收 keyEnv（环境变量名引用），明文键 "${k}" 一律拒绝` })
+      return
+    }
+  }
+  for (const k of Object.keys(obj)) {
+    if (!POOL_ENDPOINT_KEYS.has(k)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: [k], message: '未登记键（登记键位：id/baseUrl/model/adapterId/keyEnv/priority/weight/maxTokens）' })
+      return
+    }
+  }
+})
+
+const modelPoolSchema = z.object({
+  endpoints: z.array(poolEndpointSchema, { invalid_type_error: '必须为端点数组', required_error: '必须为端点数组' })
+    .min(1, { message: '至少登记一个端点（池空 = CAR-E-CONFIG；无池需求请移除 modelPool 键，行为与 1.13 一致）' }),
+  probe: z.object({
+    enabled: z.boolean({ invalid_type_error: '必须为布尔', required_error: '必须为布尔' }).optional(),
+    timeoutMs: positiveInt().optional(),
+    ttlMs: nonNegativeInt().optional(),
+  }).strict().optional(),
+  maxAttempts: positiveInt().optional(),
+}).strict().superRefine((obj, ctx) => {
+  // 端点 id 唯一（缺省派生同口径）——routing/decide 落链定位歧义禁入
+  const ids = new Set<string>()
+  for (const [i, ep] of (obj.endpoints ?? []).entries()) {
+    const id = ep.id ?? `ep-${i + 1}`
+    if (ids.has(id)) ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['endpoints', i], message: `端点 id "${id}" 重复（落链定位歧义，禁静默）` })
+    ids.add(id)
+  }
+})
+
 const mcpServerSchema = z.object({
   command: nonEmptyTrimmed().optional(),
   url: nonEmptyTrimmed().refine(v => /^https?:\/\//.test(v), { message: '必须为 http(s) URL' }).optional(),
@@ -118,14 +227,24 @@ const rawSchema = z.object({
       .refine(v => Number.isFinite(v) && Number.isInteger(v) && v > 0, { message: '必须为正整数' })
       .optional(),
     allowEnvFallback: z.boolean({ invalid_type_error: '必须为布尔', required_error: '必须为布尔' }).optional(),
+    // 1.14-S2（K-MP-2 / D-40）：历史压缩策略（阈值事实计数，非 token 估算）
+    compaction: z.object({
+      enabled: z.boolean({ invalid_type_error: '必须为布尔', required_error: '必须为布尔' }).optional(),
+      thresholdEvents: z.number({ invalid_type_error: '必须为正整数', required_error: '必须为正整数' })
+        .refine(v => Number.isInteger(v) && v > 0, { message: '必须为正整数' }).optional(),
+      protectLastTurns: z.number({ invalid_type_error: '必须为正整数', required_error: '必须为正整数' })
+        .refine(v => Number.isInteger(v) && v > 0, { message: '必须为正整数' }).optional(),
+    }).strict().optional(),
   }).strict().optional(),
+  // 1.14-S4（K-POOL-1 / D-42）：模型池登记（多端点 fallback + health + routing/decide 落链）
+  modelPool: modelPoolSchema.optional(),
   mcp: z.object({
     servers: z.record(z.string(), mcpServerSchema, { invalid_type_error: '必须为对象（serverId → 启动规格）' }),
   }).strict().optional(),
 }, { invalid_type_error: '配置顶层必须为 JSON 对象' }).strict()
 
 /** 未登记键提示（渲染层拼 path）——与系统设计键位空间同步 */
-const KEY_SPACES = '登记键位：sandbox.* / llm.* / mcp.servers.*'
+const KEY_SPACES = '登记键位：sandbox.* / llm.* / llm.modelPool.* / mcp.servers.*'
 
 /** zod issue → CAR-E-CONFIG 渲染（首个 issue；unrecognized_keys 按键路径展开） */
 function renderIssue(error: z.ZodError): string {
@@ -161,6 +280,13 @@ function parseCarConfig(raw: unknown): { config: CarConfig; error?: string } {
     if (d.llm.adapterId !== undefined) llm.adapterId = d.llm.adapterId
     if (d.llm.maxTokens !== undefined) llm.maxTokens = d.llm.maxTokens
     if (d.llm.allowEnvFallback !== undefined) llm.allowEnvFallback = d.llm.allowEnvFallback
+    if (d.llm.compaction) {
+      const cp: CompactionConfig = {}
+      if (d.llm.compaction.enabled !== undefined) cp.enabled = d.llm.compaction.enabled
+      if (d.llm.compaction.thresholdEvents !== undefined) cp.thresholdEvents = d.llm.compaction.thresholdEvents
+      if (d.llm.compaction.protectLastTurns !== undefined) cp.protectLastTurns = d.llm.compaction.protectLastTurns
+      llm.compaction = cp
+    }
     out.llm = llm
   }
   if (d.mcp) {
@@ -176,6 +302,14 @@ function parseCarConfig(raw: unknown): { config: CarConfig; error?: string } {
     }
     out.mcp = { servers }
   }
+  if (d.modelPool) {
+    const mp = d.modelPool as { endpoints: ModelPoolEndpointSpec[]; probe?: ModelPoolProbeConfig; maxAttempts?: number }
+    out.modelPool = {
+      endpoints: mp.endpoints.map(ep => ({ ...ep })),
+      ...(mp.probe ? { probe: { ...mp.probe } } : {}),
+      ...(mp.maxAttempts !== undefined ? { maxAttempts: mp.maxAttempts } : {}),
+    }
+  }
   return { config: out }
 }