@miphamai/cli 0.82.0 → 0.83.0

package/package.json

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

package/src/core/eval-harness.ts

@@ -97,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 })
@@ -112,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',
     )
@@ -135,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 运行时状态。 */

package/src/core/improvement-track.ts

@@ -26,6 +26,13 @@ export interface ImprovementReport {
   predictedDelta?: number
   /** 预测是否命中。与 predictedDelta 同时出现、同时缺席（JSON 序列化会丢掉 undefined 键）。 */
   predictionHit?: boolean
+  /**
+   * B2 代价维：与分数数组逐项对齐的前/后耗时。**只记录，不进任何门禁** ——
+   * `verdict` / `deltaMean` / `minEffect` 一律不看这两个字段。
+   * 缺席（而非空数组）= 该记录早于代价维落地，或该样本未记代价。
+   */
+  baselineDurations?: number[]
+  postDurations?: number[]
 }
 
 export interface ImprovementRecord extends ImprovementReport {
@@ -83,6 +90,11 @@ export function buildImprovementReport(
     ...(predicted !== undefined
       ? { predictedDelta: predicted, predictionHit: predictionHit(predicted, deltaMean) }
       : {}),
+    // 代价维：**两条同生同灭**，与上面 ε 那条同理 —— 只写一半（有 baselineDurations
+    // 而无 postDurations）会让「代价」这件事在记录里既非有也非无，读侧无从判断。
+    ...(sample.baselineDurations !== undefined && sample.postDurations !== undefined
+      ? { baselineDurations: sample.baselineDurations, postDurations: sample.postDurations }
+      : {}),
   }
 }
 
@@ -148,6 +160,24 @@ export function predictionHitRate(records: ImprovementRecord[]): {
   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.82.0' 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,6 +53,7 @@ import {
 import { randomUUID } from 'node:crypto'
 import {
   buildImprovementReport,
+  formatCostLine,
   appendImprovement,
   readImprovements,
   improvementRate,
@@ -901,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 {
@@ -1009,6 +1019,10 @@ const crsiProposeCmd: CommandHandler = async (ctx, args) => {
             `\n🎯 ε 预测命中: ${report.predictionHit ? '命中 ✅' : '未命中 ⚠️'}` +
             `（预测 ${report.predictedDelta}，实际 delta ${report.deltaMean.toFixed(1)}）`
         }
+        // B2 代价维：**与手工路径同一行读数**，两条渲染路径都接（只接一条即本仓库记过的
+        // 「局部正确全局遗漏」）。ε 行可以有、代价行可以没有，故各自独立追加。
+        const costLine = formatCostLine(report)
+        if (costLine) predictionLine += `\n${costLine}`
       }
     } catch {
       // 测量失败（LLM 不可用等）不阻断提案流程 —— 与手工路径 :889 的处置一致。
@@ -1132,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', '']
@@ -1154,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 调用）。