@miphamai/cli 0.81.9 → 0.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.81.9",
+  "version": "0.82.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',
 ])
 
@@ -147,6 +162,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 +173,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 +191,7 @@ export function runEval(): EvalReport {
     id: 'rule-disabled-skip',
     description: '禁用规则被跳过',
     passed: disabled.warnings.length === 0,
+    anchor: true,
   })
 
   // ── 宪法（ground truth：8 原则 + facet 映射 + 愿力序言） ──
@@ -182,6 +200,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 +210,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 +227,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 +242,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 +253,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 +263,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 +284,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 +292,7 @@ export function runEval(): EvalReport {
     description: '同名规则重复产出被拒（幂等）',
     passed:
       ruleProposal !== null && produceRuleProposal(frozenSignal, ruleProposal.newContent) === null,
+    anchor: true,
   })
 
   // ── 组件归因（ground truth：缺省 experiential、显式组件透传、非 experiential 不进 managed-rule） ──
@@ -334,6 +365,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 +418,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,10 @@ export interface ImprovementReport {
   noise: number
   minEffect: number
   verdict: ImprovementVerdict
+  /** ε：提交者事前写下的预期提升点数。缺席 = 该记录没有预登记。 */
+  predictedDelta?: number
+  /** 预测是否命中。与 predictedDelta 同时出现、同时缺席（JSON 序列化会丢掉 undefined 键）。 */
+  predictionHit?: boolean
 }
 
 export interface ImprovementRecord extends ImprovementReport {
@@ -55,6 +59,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 +75,14 @@ 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) }
+      : {}),
   }
 }
 
@@ -107,6 +120,34 @@ 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 }
+}
+
 // ── 台账 ──
 
 export function improvementPath(): string {

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.82.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/ui/commands.ts

@@ -50,6 +50,7 @@ import {
   appendImprovement,
   readImprovements,
   improvementRate,
+  predictionHitRate,
   setPendingVerdict,
   getPendingVerdict,
   shouldBlockApproval,
@@ -804,6 +805,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') }
 }
 
@@ -970,11 +990,36 @@ 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)}）`
+        }
+      }
+    } 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 丢弃',
     }
   }