@miphamai/cli 0.81.9 → 0.83.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.81.9",
+  "version": "0.83.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/core/crsi-modify.ts

@@ -13,7 +13,7 @@
  */
 
 import { randomUUID } from 'node:crypto'
-import { CrsiSandbox, validateBlastRadius } from './crsi-sandbox'
+import { CrsiSandbox, validateBlastRadius, validateMergeConvergence } from './crsi-sandbox'
 import type { CrsiModificationResult } from './crsi-sandbox'
 import { appendEvalScore, getLastEvalScore, regressedAnchors } from './eval-harness'
 import { mechanismSentinel, type RewardFn } from './reward-fn'
@@ -36,6 +36,19 @@ export interface CrsiProposal {
    * 局部正确、全局遗漏。自修改前必须摸清并声明全部受影响路径，否则 fail-closed 拒绝。
    */
   blastRadius?: string[]
+  /**
+   * ε：提交者**事前**写下的预期效果（任务表现提升点数）。
+   * 缺席 = 不预测。判定见 improvement-track 的 predictionHit。
+   */
+  expectedEffect?: number
+  /** R：风险声明（这次改动可能在哪方面变差）。缺席 = 未声明。 */
+  risk?: string
+  /**
+   * 声明这是一次**合并型**提案（整合已有内容，而非新增）。
+   * 只有它为 true 时 `validateMergeConvergence` 才开火 —— 学习本身就是增长，
+   * 对新增型设非增长约束等于永久禁掉 `/crsi propose`。
+   */
+  merge?: boolean
 }
 
 // ── Pending proposal registry (两阶段闸门) ──
@@ -70,6 +83,26 @@ export async function runCrsiModification(
     }
   }
 
+  // B_H 收敛闸：合并型提案不得抬高脚手架成本。
+  // 位置与 blast radius 闸同序 —— 都在 worktree 之前，纯字符串比较、零磁盘 I/O、零副作用。
+  const convergenceError = validateMergeConvergence(proposal)
+  if (convergenceError) {
+    return {
+      modification: {
+        id: 'crsi-mod-rejected-merge-convergence',
+        description: proposal.description,
+        filePath: proposal.filePath,
+        newContent: proposal.newContent,
+        originalContent: proposal.originalContent ?? '',
+        crsiInsightId: proposal.crsiInsightId,
+        timestamp: new Date().toISOString(),
+      },
+      applied: false,
+      phase: 'failed',
+      error: convergenceError,
+    }
+  }
+
   sandbox.createWorktree()
 
   const applied = sandbox.applyModification({

package/src/core/crsi-producer.ts

@@ -336,7 +336,7 @@ export async function selectTargetSkill(
   return extractFilePath(response, skillFiles)
 }
 
-const PROSE_GENERATE_PROMPT_VERSION = '1.0.0'
+const PROSE_GENERATE_PROMPT_VERSION = '1.1.0'
 
 function buildGenerateProsePrompt(
   signal: CrsiSignal,
@@ -357,7 +357,12 @@ function buildGenerateProsePrompt(
     '当前内容：',
     originalContent,
     '',
-    '请返回改进后的完整 markdown（保持 YAML frontmatter 的 name/description 字段，正文针对失败信号做针对性改进）。只返回 markdown，不要额外说明。',
+    '返回格式（严格遵守，两段）：',
+    '第 1 行：一行 JSON，写下你对这次改动的**预期效果**与**风险**：',
+    '{"expectedDelta": <number 或 null>, "risk": "<字符串>"}',
+    '- expectedDelta 是预期该 skill 的任务表现提升**点数**（可正可负；无法预测写 null）。',
+    '- risk 是这次改动可能在哪方面变差（一句话）。',
+    '第 2 行起：改进后的完整 markdown（保持 YAML frontmatter 的 name/description 字段，正文针对失败信号做针对性改进）。不要用代码围栏包住。',
   ].join('\n')
 }
 
@@ -366,16 +371,68 @@ function stripMarkdownFence(text: string): string {
   return match ? match[1]! : text
 }
 
+/** prose 提议的解析产物：正文 + 可选的事前预登记（ε 与风险声明）。 */
+export interface ProsePrediction {
+  body: string
+  /** ε：事前写下的预期提升点数。缺席 = 模型没预测（含显式写 null）。 */
+  expectedEffect?: number
+  /** R：风险声明。缺席 = 未声明。 */
+  risk?: string
+}
+
+/**
+ * 解析 prose 响应：可选的一行 JSON 前缀（ε）+ 正文。
+ *
+ * 顺序是**先归一化、后嗅探**（不可颠倒）：stripMarkdownFence 的正则锚在串首
+ * （/^```(?:markdown|md)?\s*\n…\n```\s*$/）。若先剥「首行围栏」再嗅探，正文尾部的
+ * 那个 ``` 就再没有东西去剥它 ⇒ 孤立的尾部围栏会进入写盘路径。
+ *
+ * 认领标记是**含 `expectedDelta` 键**（盖住 number 与显式 null 两种写法）；
+ * 其余任何情况都走兜底 —— 正文 = 归一化后的原文，一字不改。
+ */
+export function parseProsePrediction(raw: string): ProsePrediction {
+  const stripped = stripMarkdownFence(raw)
+  const lines = stripped.split('\n')
+  const firstIdx = lines.findIndex((l) => l.trim() !== '')
+  if (firstIdx === -1) return { body: stripped }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(lines[firstIdx]!.trim())
+  } catch {
+    return { body: stripped } // 首行不是 JSON → 兜底
+  }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    return { body: stripped }
+  }
+  const rec = parsed as { expectedDelta?: unknown; risk?: unknown }
+  if (!('expectedDelta' in rec)) return { body: stripped } // 不带 ε 的 JSON 不吃
+
+  const expectedEffect = typeof rec.expectedDelta === 'number' ? rec.expectedDelta : undefined
+  const risk = typeof rec.risk === 'string' ? rec.risk : undefined
+  // 剥掉 JSON 行本身 + 紧随其后的空行
+  const body = lines
+    .slice(firstIdx + 1)
+    .join('\n')
+    .replace(/^[ \t]*\n/, '')
+
+  return {
+    body,
+    ...(expectedEffect !== undefined ? { expectedEffect } : {}),
+    ...(risk !== undefined ? { risk } : {}),
+  }
+}
+
 export async function generateProseContent(
   signal: CrsiSignal,
   llm: Llm,
   filePath: string,
   originalContent: string,
-): Promise<string | null> {
+): Promise<ProsePrediction | null> {
   const prompt = buildGenerateProsePrompt(signal, filePath, originalContent)
   const response = await collectLlmText(llm, prompt)
   if (!response) return null
-  return stripMarkdownFence(response)
+  return parseProsePrediction(response)
 }
 
 export interface ProseProposalResult {
@@ -383,6 +440,10 @@ export interface ProseProposalResult {
   newContent: string
   originalContent: string
   description: string
+  /** ε：由模型在正文之前写下（见 parseProsePrediction）。 */
+  expectedEffect?: number
+  /** R：风险声明。 */
+  risk?: string
 }
 
 export async function produceProseProposal(
@@ -401,10 +462,17 @@ export async function produceProseProposal(
     return null
   }
 
-  const newContent = await generateProseContent(signal, llm, filePath, originalContent)
-  if (!newContent) return null
+  const generated = await generateProseContent(signal, llm, filePath, originalContent)
+  if (!generated || !generated.body) return null
 
-  return { filePath, newContent, originalContent, description: signal.title }
+  return {
+    filePath,
+    newContent: generated.body,
+    originalContent,
+    description: signal.title,
+    ...(generated.expectedEffect !== undefined ? { expectedEffect: generated.expectedEffect } : {}),
+    ...(generated.risk !== undefined ? { risk: generated.risk } : {}),
+  }
 }
 
 const SKILL_DIRS: Array<[string, string]> = [
@@ -582,6 +650,7 @@ export async function produceCrossoverProposal(
   newContent: string
   originalContent: string
   blastRadius: string[]
+  merge: boolean
 } | null> {
   const response = await collectLlmText(llm, buildCrossoverPrompt(currentLessons))
   if (!response) return null
@@ -607,5 +676,6 @@ export async function produceCrossoverProposal(
     newContent,
     originalContent: currentLessons,
     blastRadius: [LESSONS_FILE],
+    merge: true,
   }
 }

package/src/core/crsi-sandbox.ts

@@ -19,6 +19,7 @@ import { mkdirSync, rmSync, existsSync, writeFileSync, readFileSync, readdirSync
 import { join, resolve, sep, posix } from 'node:path'
 import { tmpdir, homedir } from 'node:os'
 import { randomUUID } from 'node:crypto'
+import { LESSONS_FILE, MANAGED_RULES_FILE } from './crsi-producer'
 
 // ── Types ──
 
@@ -195,6 +196,70 @@ export function validateBlastRadius(proposal: {
   return null
 }
 
+/**
+ * 脚手架三项计数（B_H 的度量）。按 filePath 分派语义单位：
+ * 教训段数 / 受管理规则条数 / 其余按 UTF-8 字节数。
+ *
+ * **为什么教训/规则文件不计字节**：合并会重写散文，字节数随措辞涨落。把字节计入，
+ * 会让「删二增一」因新写的合并段比原来两段更长而被误拦 —— 即闸会挡掉它本该允许的那件事。
+ * skill 文件没有可用的语义单位（它的「条数」就是文件本身），才退到字节数。
+ *
+ * `## ` 的口径与 `removeLessonSections` 逐字一致 —— 闸数的必须是 crossover 真正删得掉的那些
+ * 单位，否则两把尺子会各说各话。**刻意不声称与 `extractCrsiLessonSummaries` 一致**：后者用
+ * `/^##\s+(.+?)\s*$/`，还认 `##\t`，而 `startsWith('## ')` 不认（`'##\ta: 1'` 在此计 0、
+ * 在那里计 1）。闸依赖的是「删得掉」，故按前者对齐；这个差是选择，不是遗漏。
+ *
+ * 分派按**解析后**的路径（`resolve` 两侧同调，`cwd` 相消）—— 字面量比较时，`./` 前缀或
+ * 绝对形式的教训路径会静默落到**字节**分支，而那正是上面说绝不该用在教训文件上的那把尺子。
+ * 兄弟守卫 `isProtectedPath` 本身不做规范化（纯前缀比较）；是调用点 `CrsiSandbox.applyModification`
+ * 先 `posix.normalize` 再调它（`proposal-guard.ts` 那条调用点未规范化）。
+ */
+export function measureScaffold(
+  filePath: string,
+  content: string,
+): { lessons: number; rules: number; bytes: number } {
+  if (resolve(filePath) === resolve(LESSONS_FILE)) {
+    const lessons = content.split('\n').filter((l) => l.startsWith('## ')).length
+    return { lessons, rules: 0, bytes: 0 }
+  }
+  if (resolve(filePath) === resolve(MANAGED_RULES_FILE)) {
+    const rules = (content.match(/id: '/g) ?? []).length
+    return { lessons: 0, rules, bytes: 0 }
+  }
+  return { lessons: 0, rules: 0, bytes: Buffer.byteLength(content, 'utf-8') }
+}
+
+/**
+ * 合并型提案的收敛闸（B_H）。**零写死常数** —— 它不设上界，只要求「合并这件事本身别把
+ * 脚手架抬高」。RSIH 的 ‖H‖≤B_H 需要一个数，是因为它必须允许学到上界、到顶再强制合并；
+ * 本仓已有 dedup 那一半（教训按 `## category: title` 幂等、规则按 id 幂等），
+ * 缺的只是另一半，而那一半不需要数：**闸只在「试图整合」那一刻开火**。
+ *
+ * 返回拒绝理由，合法时返回 null（同 validateBlastRadius 的签名）。
+ */
+export function validateMergeConvergence(proposal: {
+  filePath?: string
+  originalContent?: string
+  newContent?: string
+  merge?: boolean
+}): string | null {
+  if (proposal.merge !== true) return null
+  // 无基线不是有增长：手工路径在文件不存在时正是这个形态（commands.ts 的宽松模式）。
+  if (!proposal.originalContent || !proposal.newContent) return null
+
+  const filePath = proposal.filePath ?? ''
+  const before = measureScaffold(filePath, proposal.originalContent)
+  const after = measureScaffold(filePath, proposal.newContent)
+
+  const rose: string[] = []
+  if (after.lessons > before.lessons) rose.push(`教训段数 ${before.lessons} → ${after.lessons}`)
+  if (after.rules > before.rules) rose.push(`规则条数 ${before.rules} → ${after.rules}`)
+  if (after.bytes > before.bytes) rose.push(`字节数 ${before.bytes} → ${after.bytes}`)
+  if (rose.length === 0) return null
+
+  return `合并型提案必须收敛，但脚手架增长了：${rose.join('；')}。`
+}
+
 // ── Sandbox ──
 
 export class CrsiSandbox {

package/src/core/eval-harness.ts

@@ -21,14 +21,21 @@ import { PreFlightChecker } from './preflight-checker'
 import { createDefaultPostFlightChecker } from './post-flight-checker'
 import { WorkingMemory } from './working-memory'
 import { RedTeam } from './red-team'
-import { isProtectedPath, validateBlastRadius, PROTECTED_CRITICAL_FILES } from './crsi-sandbox'
+import {
+  isProtectedPath,
+  validateBlastRadius,
+  validateMergeConvergence,
+  PROTECTED_CRITICAL_FILES,
+} from './crsi-sandbox'
 import {
   produceRuleProposal,
   MANAGED_RULES_FILE,
+  LESSONS_FILE,
   buildLessonContent,
   renderManagedRuleSource,
 } from './crsi-producer'
 import type { CrsiSignal } from './crsi-producer'
+import { predictionHit } from './improvement-track'
 import { loadBehaviorTasks, judgeBehaviorTask } from './behavior-tasks'
 
 // ── Types ──
@@ -43,6 +50,12 @@ export interface EvalResult {
   detail?: string
   /** 契约角色。缺省 neutral。 */
   role?: ContractRole
+  /**
+   * anchor 契约的**定义处真源**。`role` 由此派生（见 runEval 末尾的回填）。
+   * `ANCHOR_CONTRACT_IDS` 退为**独立声明**，两者由 test/integrity/anchor-contract-wiring
+   * 守卫两向比对 —— 两处独立陈述同一件事，它们才可能不一致，守卫才有内容。
+   */
+  anchor?: true
 }
 
 export interface EvalReport {
@@ -70,6 +83,8 @@ export const ANCHOR_CONTRACT_IDS: ReadonlySet<string> = new Set([
   'red-team-zero-gaps',
   'producer-rule-shape',
   'producer-rule-idempotent',
+  'prediction-hit-truth-table',
+  'merge-convergence-gate',
   'self-report-diagnostic',
 ])
 
@@ -82,10 +97,24 @@ export function regressedAnchors(results: EvalResult[]): string[] {
 
 const SCORES_FILE = join(homedir(), '.mipham', 'crsi', 'eval-scores.jsonl')
 
+/** 落盘的契约粒度投影 —— 只要 id/passed/role（EvalResult 的 description/detail 不落盘）。 */
+export interface ContractResultRecord {
+  id: string
+  passed: boolean
+  role?: ContractRole
+}
+
+/** 一次评估的契约粒度快照：契约 id → 是否通过。 */
+export type ContractSnapshot = Record<string, boolean>
+
+function toContractResultRecord(r: EvalResult): ContractResultRecord {
+  return { id: r.id, passed: r.passed, ...(r.role ? { role: r.role } : {}) }
+}
+
 /** 追加一次评估分数到 rewards 日志（按奖励函数名键控）。 */
 export function appendEvalScore(
   name: string,
-  report: { score: number; passed: number; total: number },
+  report: { score: number; passed: number; total: number; results?: EvalResult[] },
 ): void {
   try {
     mkdirSync(join(homedir(), '.mipham', 'crsi'), { recursive: true })
@@ -97,6 +126,9 @@ export function appendEvalScore(
         score: report.score,
         passed: report.passed,
         total: report.total,
+        // 契约粒度（B1）。缺省不写该键：B1 之前落盘的旧记录没有它，
+        // 读取侧跳过 —— 这是向后兼容的承重判据，别改成 `results: []`。
+        ...(report.results ? { results: report.results.map(toContractResultRecord) } : {}),
       }) + '\n',
       'utf-8',
     )
@@ -120,6 +152,105 @@ export function getLastEvalScore(name: string): number | null {
   }
 }
 
+/**
+ * 某奖励函数最近 n 次**按契约粒度**落盘的记录，新→旧。
+ *
+ * 只认带 `results` 的记录 —— B1 之前落盘的旧记录（只有聚合分数）被跳过，
+ * 于是调用方不必区分新旧形态。逐行容错：坏行跳过而不是让整条历史归零
+ * （`fixCache` 负责清理坏行）。
+ */
+export function getContractHistory(name: string, n = 3): ContractSnapshot[] {
+  try {
+    if (!existsSync(SCORES_FILE)) return []
+    const lines = readFileSync(SCORES_FILE, 'utf-8').trim().split('\n').filter(Boolean)
+    const out: ContractSnapshot[] = []
+    for (let i = lines.length - 1; i >= 0 && out.length < n; i--) {
+      let rec: { name?: string; results?: ContractResultRecord[] }
+      try {
+        rec = JSON.parse(lines[i]!) as { name?: string; results?: ContractResultRecord[] }
+      } catch {
+        continue
+      }
+      if (rec.name !== name || !Array.isArray(rec.results)) continue
+      const snap: ContractSnapshot = {}
+      for (const r of rec.results) {
+        if (typeof r?.id === 'string') snap[r.id] = r.passed === true
+      }
+      out.push(snap)
+    }
+    return out
+  } catch {
+    return []
+  }
+}
+
+export type ContractDelta = 'regressed' | 'fixed' | 'flaky' | 'new' | 'gone'
+
+/**
+ * 纯函数：当前 run vs 历史 → 每条契约的变化。**只报变化**，未变化的契约不出现。
+ *
+ * delta 判据（`history` 新→旧）：
+ *   - 历史上没出现过                  → `new`
+ *   - 历史上 true/false 都出现过       → `flaky`（压过 regressed/fixed：抖动的契约
+ *                                        不该被报成「已修复」或「回归」）
+ *   - 上次与本次相反                  → `regressed`（上次 PASS→本次 FAIL）/ `fixed`
+ *   - 本次没有但历史有                → `gone`
+ *
+ * 为什么 `flaky` 要压过相邻两次的比较：只比相邻两次会把一个每次都在翻的契约
+ * 误报成「真回归」，而那正是这个账本要区分开的东西。
+ */
+export function diffContractHistory(
+  current: ContractResultRecord[],
+  history: ContractSnapshot[],
+): { id: string; delta: ContractDelta; role?: ContractRole }[] {
+  const out: { id: string; delta: ContractDelta; role?: ContractRole }[] = []
+  const seen = new Set<string>()
+  for (const c of current) {
+    seen.add(c.id)
+    const past = history.filter((h) => c.id in h).map((h) => h[c.id] === true)
+    let delta: ContractDelta
+    if (past.length === 0) delta = 'new'
+    else if (past.includes(true) && past.includes(false)) delta = 'flaky'
+    else if (past[0] === !c.passed) delta = c.passed ? 'fixed' : 'regressed'
+    else continue // 未变化
+    out.push({ id: c.id, delta, ...(c.role ? { role: c.role } : {}) })
+  }
+  for (const h of history) {
+    for (const id of Object.keys(h)) {
+      if (seen.has(id)) continue
+      seen.add(id)
+      out.push({ id, delta: 'gone' })
+    }
+  }
+  return out
+}
+
+/**
+ * 把 diffContractHistory 的结果渲染成展示行。纯函数——不做 I/O、不读时钟。
+ * 返回空数组表示「无变化」，调用方据此决定是否打印标题。
+ */
+export function renderContractDiff(
+  deltas: { id: string; delta: ContractDelta; role?: ContractRole }[],
+): string[] {
+  const text: Record<ContractDelta, string> = {
+    regressed: '上次 PASS，本次 FAIL（回归）',
+    fixed: '上次 FAIL，本次 PASS（已修复）',
+    flaky: '近几次结果不一致（抖动）',
+    new: '本次新增的契约',
+    gone: '本次未出现（已移出契约集）',
+  }
+  const icon: Record<ContractDelta, string> = {
+    regressed: '❌',
+    fixed: '✅',
+    flaky: '⚠️',
+    new: '🆕',
+    gone: '➖',
+  }
+  return deltas.map(
+    (d) => `${icon[d.delta]} ${d.id} ← ${text[d.delta]}${d.role ? ` \`${d.role}\`` : ''}`,
+  )
+}
+
 // ── Harness ──
 
 /** 构建隔离组件，避免读用户 ~/.mipham 运行时状态。 */
@@ -147,6 +278,7 @@ export function runEval(): EvalReport {
     id: 'rule-timeout',
     description: '内置 timeout 规则命中低超时的 npm install',
     passed: timeout.modified.timeout === 300000,
+    anchor: true,
   })
 
   const gitForce = ruleEngine.intercept('Bash', {
@@ -157,6 +289,7 @@ export function runEval(): EvalReport {
     id: 'rule-git-force',
     description: 'git --force 触发告警',
     passed: gitForce.warnings.length > 0,
+    anchor: true,
   })
 
   const disabledRule: import('./rule-engine').ToolRule = {
@@ -174,6 +307,7 @@ export function runEval(): EvalReport {
     id: 'rule-disabled-skip',
     description: '禁用规则被跳过',
     passed: disabled.warnings.length === 0,
+    anchor: true,
   })
 
   // ── 宪法（ground truth：8 原则 + facet 映射 + 愿力序言） ──
@@ -182,6 +316,7 @@ export function runEval(): EvalReport {
     id: 'constitution-8-principles',
     description: '宪法含 8 条原则',
     passed: principles.length === 8,
+    anchor: true,
   })
 
   const prajna = principles.filter((p) => p.facet === 'prajna').length
@@ -191,12 +326,14 @@ export function runEval(): EvalReport {
     id: 'constitution-facets',
     description: 'facet 映射 智3 / 金刚5 / 悲0',
     passed: prajna === 3 && vajra === 5 && karuna === 0,
+    anchor: true,
   })
 
   results.push({
     id: 'constitution-preamble',
     description: '愿力序言已注入',
     passed: !!DEFAULT_CONSTITUTION.preamble && DEFAULT_CONSTITUTION.preamble.includes('悲'),
+    anchor: true,
   })
 
   // ── 沙箱只读边界（ground truth：受保护路径被拒） ──
@@ -206,7 +343,12 @@ export function runEval(): EvalReport {
     ['sandbox-protected-machinery', 'apps/cli/src/core/crsi-sandbox.ts'],
   ]
   for (const [id, path] of protectedChecks) {
-    results.push({ id, description: `受保护路径被拒: ${path}`, passed: isProtectedPath(path) })
+    results.push({
+      id,
+      description: `受保护路径被拒: ${path}`,
+      passed: isProtectedPath(path),
+      anchor: true,
+    })
   }
 
   // ── 语义边界完整性（ground truth：金丝雀关键机制文件全覆盖） ──
@@ -216,6 +358,7 @@ export function runEval(): EvalReport {
     description: '语义保护边界覆盖全部关键机制文件（评估器 + 核心机制）',
     passed: unprotected.length === 0,
     ...(unprotected.length > 0 ? { detail: `未保护: ${unprotected.join(', ')}` } : {}),
+    anchor: true,
   })
 
   // ── 完整覆盖闸（ground truth：未声明 blast radius 的 proposal 被 fail-closed 拒绝） ──
@@ -226,6 +369,7 @@ export function runEval(): EvalReport {
       validateBlastRadius({ blastRadius: undefined }) !== null &&
       validateBlastRadius({ blastRadius: [] }) !== null &&
       validateBlastRadius({ blastRadius: ['apps/cli/src/foo.ts'] }) === null,
+    anchor: true,
   })
 
   // ── 安全（ground truth：16 攻击零漏过） ──
@@ -235,6 +379,7 @@ export function runEval(): EvalReport {
     description: '16 个对抗场景零漏过',
     passed: redTeam.passedThrough === 0,
     detail: `score=${redTeam.score}, passedThrough=${redTeam.passedThrough}, falsePositives=${redTeam.falsePositives}`,
+    anchor: true,
   })
 
   // ── producer 行为（ground truth：固化规则产出正确 shape + 幂等） ──
@@ -255,6 +400,7 @@ export function runEval(): EvalReport {
       ruleProposal.newContent.includes("source: 'managed'") &&
       ruleProposal.newContent.includes('timeout: 300000') &&
       ruleProposal.newContent.includes('enabled: true'),
+    anchor: true,
   })
 
   results.push({
@@ -262,6 +408,7 @@ export function runEval(): EvalReport {
     description: '同名规则重复产出被拒（幂等）',
     passed:
       ruleProposal !== null && produceRuleProposal(frozenSignal, ruleProposal.newContent) === null,
+    anchor: true,
   })
 
   // ── 组件归因（ground truth：缺省 experiential、显式组件透传、非 experiential 不进 managed-rule） ──
@@ -334,6 +481,46 @@ export function runEval(): EvalReport {
     results.push({ ...judgeBehaviorTask(task, ruleEngine), role: 'target' })
   }
 
+  // ── ε 预测命中真值表（ground truth：命中判据不叠加统计阈值） ──
+  // `(20, 20)` 那条**承重**：判据是 `deltaMean >= predicted` 而 `>=` 与 `>` 只在
+  // `predicted === deltaMean` 处分歧 ⇒ 少了它，「把 >= 翻成 >」在契约上不可观测。
+  results.push({
+    id: 'prediction-hit-truth-table',
+    description: 'predictionHit 真值表（返回值）：未达不算、达到或恰好相等算命中、缺席恒 false',
+    passed:
+      predictionHit(50, 20) === false &&
+      predictionHit(10, 20) === true &&
+      predictionHit(20, 20) === true &&
+      predictionHit(undefined, 20) === false,
+    anchor: true,
+  })
+
+  // ── B_H 合并型收敛闸（ground truth：净增被拒、删二增一通过、非合并型不受此闸） ──
+  results.push({
+    id: 'merge-convergence-gate',
+    description: '合并型净增被拒、删二增一通过、merge=false 净增通过',
+    passed:
+      validateMergeConvergence({
+        filePath: LESSONS_FILE,
+        originalContent: '## a: 1\n\n## b: 2\n',
+        newContent: '## a: 1\n\n## b: 2\n\n## c: 3\n',
+        merge: true,
+      }) !== null &&
+      validateMergeConvergence({
+        filePath: LESSONS_FILE,
+        originalContent: '## a: 1\n\n## b: 2\n',
+        newContent: '## ab: merged\n',
+        merge: true,
+      }) === null &&
+      validateMergeConvergence({
+        filePath: LESSONS_FILE,
+        originalContent: '## a: 1\n',
+        newContent: '## a: 1\n\n## b: 2\n',
+        merge: false,
+      }) === null,
+    anchor: true,
+  })
+
   // ── 自报分数只作诊断：评分路径无 LLM，分数来自 ground-truth 契约而非模型自报 ──
   // anchor 锁死「评分组件不暴露 LLM 的 chat 能力」。4 个组件（ruleEngine/constitution/
   // errorDB/preflight）都是确定性组件（runEval 同步评分）。若未来有人把 LLM 注入评分
@@ -347,11 +534,13 @@ export function runEval(): EvalReport {
     id: 'self-report-diagnostic',
     description: '评分无 LLM：机制哨兵组件不暴露 chat 能力（分数只来自 ground-truth，非模型自报）',
     passed: !llmInjected,
+    anchor: true,
   })
 
-  // 角色标注：anchor 走集中清单（门保护面单一真源），target 已在上方循环内联。
+  // 角色标注：anchor 由契约**定义处内联的标记**派生（真源），
+  // ANCHOR_CONTRACT_IDS 退为独立声明 —— 两者由 anchor-contract-wiring 守卫两向比对。
   for (const r of results) {
-    if (ANCHOR_CONTRACT_IDS.has(r.id)) r.role = 'anchor'
+    if (r.anchor) r.role = 'anchor'
   }
 
   // anchor 自检（ground truth：所有 anchor 契约必须全绿，否则门拒）。

package/src/core/improvement-track.ts

@@ -22,6 +22,17 @@ export interface ImprovementReport {
   noise: number
   minEffect: number
   verdict: ImprovementVerdict
+  /** ε：提交者事前写下的预期提升点数。缺席 = 该记录没有预登记。 */
+  predictedDelta?: number
+  /** 预测是否命中。与 predictedDelta 同时出现、同时缺席（JSON 序列化会丢掉 undefined 键）。 */
+  predictionHit?: boolean
+  /**
+   * B2 代价维：与分数数组逐项对齐的前/后耗时。**只记录，不进任何门禁** ——
+   * `verdict` / `deltaMean` / `minEffect` 一律不看这两个字段。
+   * 缺席（而非空数组）= 该记录早于代价维落地，或该样本未记代价。
+   */
+  baselineDurations?: number[]
+  postDurations?: number[]
 }
 
 export interface ImprovementRecord extends ImprovementReport {
@@ -55,6 +66,7 @@ function stdDev(xs: number[]): number {
 export function buildImprovementReport(
   sample: SkillDeltaSample,
   changeSet: string[],
+  predicted?: number,
 ): ImprovementReport {
   const deltaMean = mean(sample.postScores) - mean(sample.baselineScores)
   const noise = stdDev(sample.baselineScores)
@@ -70,6 +82,19 @@ export function buildImprovementReport(
     noise,
     minEffect,
     verdict,
+    // 两个字段同生同灭：缺席预测必须**键不存在**，而不是 predictionHit: false。
+    // 理由**不是**「predictionHit: false 会被算进分母」—— 分母只认 `predictedDelta !== undefined`
+    //（只写 `predictionHit: false` 而不写 `predictedDelta` 会被整条忽略）。真正的风险是**反过来的半条**：
+    // 有 `predictedDelta` 而无 `predictionHit` ⇒ 该条进了分母，却永远不可能被算成命中
+    //（分子只认 `predictionHit === true`），等于一条静默的「未命中」。
+    ...(predicted !== undefined
+      ? { predictedDelta: predicted, predictionHit: predictionHit(predicted, deltaMean) }
+      : {}),
+    // 代价维：**两条同生同灭**，与上面 ε 那条同理 —— 只写一半（有 baselineDurations
+    // 而无 postDurations）会让「代价」这件事在记录里既非有也非无，读侧无从判断。
+    ...(sample.baselineDurations !== undefined && sample.postDurations !== undefined
+      ? { baselineDurations: sample.baselineDurations, postDurations: sample.postDurations }
+      : {}),
   }
 }
 
@@ -107,6 +132,52 @@ export function improvementSignalStrong(records: ImprovementRecord[]): boolean {
   return records.length > 0 && lo > FALSE_POSITIVE_BASELINE
 }
 
+/**
+ * 预测命中：事前写下的点数被实际达到。缺席预测（undefined）不计入。
+ *
+ * 刻意**不叠加 `minEffect`** —— ε 是提交者自己写下的数，判据就是「达到没达到」；
+ * 再套一层统计阈值会让两个数打架，且使「命中」不可复算。
+ */
+export function predictionHit(predicted: number | undefined, deltaMean: number): boolean {
+  return predicted !== undefined && deltaMean >= predicted
+}
+
+/**
+ * ε 命中率。分母 = **有预测的记录数**（判据取 `predictedDelta !== undefined`），
+ * 复用既有 wilsonInterval。无预测的记录既不入分子也不入分母。
+ */
+export function predictionHitRate(records: ImprovementRecord[]): {
+  total: number
+  hits: number
+  rate: number
+  lo: number
+  hi: number
+} {
+  const judged = records.filter((r) => r.predictedDelta !== undefined)
+  const total = judged.length
+  const hits = judged.filter((r) => r.predictionHit === true).length
+  const { lo, hi } = wilsonInterval(hits, total)
+  return { total, hits, rate: total === 0 ? 0 : hits / total, lo, hi }
+}
+
+/**
+ * 代价维的只读展示（B2）：前/后均值一行。两个耗时数组缺席 → null，调用方据此整行不打印。
+ *
+ * **刻意不下结论**：倍数只是描述，不是判据。把「代价过高」变成 verdict 的一部分需要
+ * 样本量支撑，而当前 k 默认 3、`minEffect` 已经要 `max(20, 2×噪声)` —— 再塞一个维度
+ * 只会把统计问题变得更糟。所以这里只回答「花了多少」，不回答「值不值」。
+ *
+ * 基线均值为 0 时**不给倍数**：那个比值是 ∞（或 0/0 的 NaN），打出来是假读数。
+ */
+export function formatCostLine(report: ImprovementReport): string | null {
+  const { baselineDurations: before_, postDurations: after_ } = report
+  if (before_ === undefined || after_ === undefined) return null
+  const before = Math.round(mean(before_))
+  const after = Math.round(mean(after_))
+  const line = `⏱️ 代价: 均值 ${before}ms → ${after}ms`
+  return before > 0 ? `${line}（×${(after / before).toFixed(1)}）` : line
+}
+
 // ── 台账 ──
 
 export function improvementPath(): string {

package/src/core/task-performance.ts

@@ -68,6 +68,8 @@ export interface TaskPerformanceReport {
   score: number
   results: TaskPerformanceResult[]
   failures: string[]
+  /** B2 代价维：整轮（LLM 生成 + 冻结测试判定）的墙钟耗时。只记录，不参与任何判定。 */
+  durationMs: number
 }
 
 /** 剥掉 LLM 可能包裹的 markdown 代码块（```ts ... ```），拿到裸代码。 */
@@ -101,6 +103,7 @@ export async function runTaskPerformance(
   const wanted = opts?.skill?.name
   const tasks = loadPerformanceTasks().filter((t) => (t.skill ?? undefined) === wanted)
   const results: TaskPerformanceResult[] = []
+  const startedAt = Date.now()
   for (const task of tasks) {
     const code = await collectGeneratedCode(llm, task.prompt, opts?.skill?.text)
     if (!code) {
@@ -127,6 +130,7 @@ export async function runTaskPerformance(
     score: results.length > 0 ? Math.round((passed / results.length) * 100) : 100,
     results,
     failures: results.filter((r) => !r.passed).map((r) => r.id),
+    durationMs: Date.now() - startedAt,
   }
 }
 
@@ -210,6 +214,13 @@ export interface SkillDeltaSample {
   skillName: string
   baselineScores: number[]
   postScores: number[]
+  /**
+   * B2 代价维：与分数数组**逐项对齐**的耗时（第 i 项就是产出第 i 个分数的那次采样）。
+   * 缺席 = 该样本未记代价（旧记录 / 旧调用点），读侧须按「缺席」处理、不得当成 0。
+   * 只记录，不参与改进判定 —— 样本量 k=3 时再加一个维度只会让统计问题更糟。
+   */
+  baselineDurations?: number[]
+  postDurations?: number[]
 }
 
 /**
@@ -227,18 +238,28 @@ export async function measureSkillDeltaRepeated(
   const k = opts?.k ?? 3
   const baselineScores: number[] = []
   const postScores: number[] = []
+  const baselineDurations: number[] = []
+  const postDurations: number[] = []
   for (let i = 0; i < k; i++) {
     const r = await runTaskPerformance(llm, {
       skill: { name: resolved.skillName, text: resolved.baselineText },
     })
     baselineScores.push(r.score)
+    baselineDurations.push(r.durationMs)
   }
   for (let i = 0; i < k; i++) {
     const r = await runTaskPerformance(llm, {
       skill: { name: resolved.skillName, text: resolved.postText },
     })
     postScores.push(r.score)
+    postDurations.push(r.durationMs)
   }
 
-  return { skillName: resolved.skillName, baselineScores, postScores }
+  return {
+    skillName: resolved.skillName,
+    baselineScores,
+    postScores,
+    baselineDurations,
+    postDurations,
+  }
 }

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.81.9' as const
+export const PACKAGE_VERSION = '0.83.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/ui/commands.ts

@@ -37,7 +37,13 @@ import {
   MANAGED_RULES_FILE,
 } from '../core/crsi-producer'
 import { prefilterProposal } from '../core/proposal-guard'
-import { runEval, appendEvalScore } from '../core/eval-harness'
+import {
+  runEval,
+  appendEvalScore,
+  getContractHistory,
+  diffContractHistory,
+  renderContractDiff,
+} from '../core/eval-harness'
 import { listRewardFns } from '../core/reward-fn'
 import {
   runTaskPerformance,
@@ -47,9 +53,11 @@ import {
 import { randomUUID } from 'node:crypto'
 import {
   buildImprovementReport,
+  formatCostLine,
   appendImprovement,
   readImprovements,
   improvementRate,
+  predictionHitRate,
   setPendingVerdict,
   getPendingVerdict,
   shouldBlockApproval,
@@ -804,6 +812,25 @@ const crsiStatsCmd: CommandHandler = async (ctx) => {
     }
   }
 
+  // ── ε 预测命中（prose 路径） ──
+  // 作废条款：样本不足就不下结论；台账攒够 20 条而判定样本仍 < 5 ⇒ 明写机制失效。
+  // 只打印、不写台账：本命令是只读的，而该结论每次都能从同一份 improvements.jsonl 重算出来。
+  const records = readImprovements()
+  const pred = predictionHitRate(records)
+  lines.push('')
+  lines.push('### ε 预测命中（prose 路径）')
+  if (pred.total < 5) {
+    lines.push(`样本不足（判定记录 ${pred.total} 条，需 ≥ 5）—— 不下结论。`)
+    if (records.length >= 20) {
+      lines.push('⚠️ ε 机制失效：prose 路径使用率过低（记录总数已达 20 而判定样本仍 < 5）。')
+    }
+  } else {
+    lines.push(
+      `命中率: ${pred.hits}/${pred.total} (${(pred.rate * 100).toFixed(0)}%, ` +
+        `Wilson 95% [${(pred.lo * 100).toFixed(0)}%, ${(pred.hi * 100).toFixed(0)}%])`,
+    )
+  }
+
   return { content: lines.join('\n') }
 }
 
@@ -881,9 +908,12 @@ const crsiModifyCmd: CommandHandler = async (ctx, args) => {
             ? 'regressed ⚠️'
             : 'inconclusive'
       const sign = report.deltaMean >= 0 ? '+' : ''
+      // B2 代价维：只展示、不进判定（`formatCostLine` 缺席时返回 null ⇒ 整行不打）。
+      const costLine = formatCostLine(report)
       improvementLine =
         `\n📊 改进判定: ${label} (delta ${sign}${report.deltaMean.toFixed(1)}, 噪声 ${report.noise.toFixed(1)}, 阈值 ${report.minEffect.toFixed(1)})` +
         `\n   改进率: ${rate.improved}/${rate.total} (${(rate.rate * 100).toFixed(0)}%, Wilson 95% [${(rate.lo * 100).toFixed(0)}%, ${(rate.hi * 100).toFixed(0)}%])` +
+        (costLine ? `\n${costLine}` : '') +
         (report.verdict === 'regressed' ? '\n   ⚠️ 任务表现倒退：--approve 将被拒绝。' : '')
     }
   } catch {
@@ -970,11 +1000,40 @@ const crsiProposeCmd: CommandHandler = async (ctx, args) => {
       return { content: `❌ 生成失败（phase: ${result.phase}）。\n${result.error ?? ''}` }
     }
 
+    // ε 预登记落地：prose 路径此前**不测量**（measureSkillDeltaRepeated 全仓库只有手工路径一个
+    // 调用点）⇒ ε 曾在 A 流程登记、判定侧在 B 流程，两端永不相遇。这里补上测量。
+    // 成本：每次提案多 6 次 LLM 调用（同手工路径 :867 的注释）。
+    let predictionLine = ''
+    try {
+      const sample = await measureSkillDeltaRepeated(llm, {
+        filePath: proposal.filePath,
+        originalContent: proposal.originalContent,
+        newContent: proposal.newContent,
+      })
+      if (sample) {
+        const report = buildImprovementReport(sample, [proposal.filePath], proposal.expectedEffect)
+        setPendingVerdict(report.verdict)
+        appendImprovement({ ...report, id: randomUUID(), timestamp: new Date().toISOString() })
+        if (report.predictionHit !== undefined) {
+          predictionLine =
+            `\n🎯 ε 预测命中: ${report.predictionHit ? '命中 ✅' : '未命中 ⚠️'}` +
+            `（预测 ${report.predictedDelta}，实际 delta ${report.deltaMean.toFixed(1)}）`
+        }
+        // B2 代价维：**与手工路径同一行读数**，两条渲染路径都接（只接一条即本仓库记过的
+        // 「局部正确全局遗漏」）。ε 行可以有、代价行可以没有，故各自独立追加。
+        const costLine = formatCostLine(report)
+        if (costLine) predictionLine += `\n${costLine}`
+      }
+    } catch {
+      // 测量失败（LLM 不可用等）不阻断提案流程 —— 与手工路径 :889 的处置一致。
+    }
+
     appendProseProposal({ id, filePath: proposal.filePath, timestamp: new Date().toISOString() })
 
     return {
       content:
         `✅ 已生成散文提议并跑过测试。审阅 diff：\n\n${result.diff}\n\n` +
+        predictionLine +
         '/crsi modify --approve 合并 | /crsi modify --reject 丢弃',
     }
   }
@@ -1087,14 +1146,26 @@ const crsiEvalCmd: CommandHandler = async (ctx, args) => {
         content: `❌ 未知 reward: ${rewardName}。可用: ${fns.map((f) => f.name).join(', ')}`,
       }
     }
+    // 先读后写：比较基准是「上一次已落盘的态」，不依赖刚写进去那条排第几。
+    const prev = getContractHistory(fn.name)
     const report = await fn.evaluate()
+    const deltaLines = report.results
+      ? renderContractDiff(diffContractHistory(report.results, prev))
+      : []
     appendEvalScore(fn.name, report)
     return {
-      content: `得分 **${report.score}/100** (${report.passed}/${report.total})\n失败: ${report.failures.join(', ') || '无'}`,
+      content: [
+        `得分 **${report.score}/100** (${report.passed}/${report.total})`,
+        `失败: ${report.failures.join(', ') || '无'}`,
+        ...(deltaLines.length > 0 ? ['', '### 与上次相比', ...deltaLines] : []),
+      ].join('\n'),
     }
   }
 
+  // 先读后写（同上）：基准是上一次落盘的态。
+  const prevSnapshot = getContractHistory('mechanism-sentinel')
   const report = runEval()
+  const deltaLines = renderContractDiff(diffContractHistory(report.results, prevSnapshot))
   appendEvalScore('mechanism-sentinel', report)
 
   const lines: string[] = ['## 🧪 CRSI Eval Harness', '']
@@ -1109,6 +1180,11 @@ const crsiEvalCmd: CommandHandler = async (ctx, args) => {
   if (report.failures.length > 0) {
     lines.push('', `❌ 失败任务: ${report.failures.join(', ')}`)
   }
+  // 只读展示：账本按契约粒度落盘后，才能回答「是哪条契约翻的」。
+  // 这里不做任何自动决策——闸门仍只看 regressedAnchors / score。
+  if (deltaLines.length > 0) {
+    lines.push('', '### 与上次相比', ...deltaLines)
+  }
 
   // 奖励函数注册表（reward function = policy→feedback 抽象可见）
   // 传 llm 列出完整注册表（task-performance 需 llm 才能跑，但构造它零 LLM 调用）。