@miphamai/cli 0.68.0 → 0.69.0

package/package.json

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

package/src/core/crsi-modify.ts

@@ -15,7 +15,7 @@
 import { randomUUID } from 'node:crypto'
 import { CrsiSandbox, validateBlastRadius } from './crsi-sandbox'
 import type { CrsiModificationResult } from './crsi-sandbox'
-import { appendEvalScore, getLastEvalScore } from './eval-harness'
+import { appendEvalScore, getLastEvalScore, regressedAnchors } from './eval-harness'
 import { mechanismSentinel, type RewardFn } from './reward-fn'
 
 export interface CrsiProposal {
@@ -102,6 +102,15 @@ export async function runCrsiModification(
   // 默认机制哨兵；可插拔——调用方传 opts.rewardFn 换用其他奖励源（如任务表现）。
   const rewardFn = opts?.rewardFn ?? mechanismSentinel()
   const report = await rewardFn.evaluate()
+  // 细粒度防回退：anchor 契约（安全/机制不变量）任一翻转 PASS→FAIL 即拒，
+  // 即使总分因新增契约而上升也被拦（比「总分不退化」更严格）。
+  const anchors = regressedAnchors(report.results ?? [])
+  if (anchors.length > 0) {
+    sandbox.rollback()
+    applied.phase = 'failed'
+    applied.error = `Anchor regression: ${anchors.join(', ')}`
+    return applied
+  }
   const last = getLastEvalScore(rewardFn.name)
   if (last !== null && report.score < last) {
     sandbox.rollback()

package/src/core/crsi-producer.ts

@@ -20,6 +20,9 @@ import { homedir } from 'node:os'
 /** 教训文件（相对仓库根）。预建，沙箱只能改已存在文件。 */
 export const LESSONS_FILE = 'apps/cli/crsi-lessons.md'
 
+/** 组件归因（修复决策，非因果断言）：失败最可能被哪个记忆组件的局部干预修复。 */
+export type MemoryComponent = 'experiential' | 'working' | 'invocation' | 'checker'
+
 /** 归一化的教训信号（insight 与 meta-rule 的公共面）。 */
 export interface CrsiSignal {
   category: string
@@ -27,6 +30,12 @@ export interface CrsiSignal {
   severity?: string
   suggestion: string
   evidence: string[]
+  /**
+   * 组件归因：该失败最可能被哪个记忆组件的局部干预修复。
+   * 缺省 experiential（现状 = 教训/技能/受管理规则，全属 E）。
+   * working/invocation/checker 待 ②③ 落地后由对应信号源产出。
+   */
+  component?: MemoryComponent
 }
 
 const SEVERITY_RANK: Record<string, number> = { critical: 0, warning: 1, info: 2 }
@@ -76,6 +85,7 @@ export function buildLessonContent(
     `## ${signal.category}: ${signal.title}`,
     '',
     `- 建议: ${signal.suggestion}`,
+    `- 组件: ${signal.component ?? 'experiential'}`,
   ]
   if (signal.severity) lines.push(`- 严重度: ${signal.severity}`)
   lines.push(`- 生成时间: ${timestamp}`, `- 来源: ${source}`, '', '### 证据')
@@ -188,6 +198,9 @@ export function managedRuleId(signal: CrsiSignal): string {
  * 只支持 timeout / tool-params 两类确定性 category，其余返回 null。
  */
 export function renderManagedRuleSource(signal: CrsiSignal): string | null {
+  // managed-rule 是「行为固化」，只处理 experiential 组件（timeout/tool-params 本质是 E）。
+  // working/invocation/checker 的修复走各自组件路径，不进这里。
+  if ((signal.component ?? 'experiential') !== 'experiential') return null
   const id = managedRuleId(signal)
   const warning = signal.suggestion || `CRSI 自动固化: ${signal.title}`
 

package/src/core/engine.ts

@@ -29,6 +29,8 @@ import { CrsiProvenanceBridge } from '../agent/crsi-provenance-bridge.js'
 import { McpClient } from '../mcp/client.js'
 import { ErrorSignatureDB } from './error-signature-db.js'
 import { PreFlightChecker } from './preflight-checker.js'
+import { PostFlightChecker, createDefaultPostFlightChecker } from './post-flight-checker'
+import { recordToolEvidence } from './working-memory'
 import { AutoCorrector } from './auto-corrector.js'
 import { MetaRuleEngine } from './meta-rule-engine.js'
 import { DreamEngine } from './dream-engine.js'
@@ -83,6 +85,7 @@ export class QueryEngine {
   private _autoMemory?: AutoMemoryEngine
   private _errorSignatureDB?: ErrorSignatureDB
   private _preflightChecker?: PreFlightChecker
+  private _postFlightChecker?: PostFlightChecker
   private _autoCorrector?: AutoCorrector
   private _metaRuleEngine?: MetaRuleEngine
   private _dreamEngine?: DreamEngine
@@ -1243,6 +1246,23 @@ export class QueryEngine {
       // Accumulate graft token savings from "[graft] tokens saved ≈ N" footers
       accumulateGraftSavings(result.content)
 
+      // ── PostFlightChecker — 事后验证「观察是否支撑变更」（Recuris C 组件）──
+      // 默认 no-checker 静默、rejected 只记录不阻塞（第一阶段只产证据，不强制拦截）。
+      const decision = this.getPostFlightChecker().check(name, {
+        params: effectiveParams,
+        result,
+      })
+      // 证据账本：supported/rejected 回灌工作记忆（供 Task 完成门读取）
+      recordToolEvidence(name, decision)
+      if (decision.verdict !== 'no-checker') {
+        this.context.getLog()?.append({
+          type: 'checker/decision',
+          at: Date.now(),
+          toolName: name,
+          decision,
+        })
+      }
+
       return result
     } catch (err) {
       // P1-3: Trigger PostToolUseFailure hook on tool execution errors
@@ -1488,6 +1508,17 @@ export class QueryEngine {
     return this._preflightChecker
   }
 
+  /**
+   * Recuris C 组件：Lazily-initialized PostFlightChecker singleton。
+   * 事后验证「工具/env 观察是否支撑变更」，与 PreFlightChecker（事前拦截）互补。
+   */
+  getPostFlightChecker(): PostFlightChecker {
+    if (!this._postFlightChecker) {
+      this._postFlightChecker = createDefaultPostFlightChecker()
+    }
+    return this._postFlightChecker
+  }
+
   /**
    * SIS Phase 2: Lazily-initialized AutoCorrector singleton.
    * Analyzes failed tool calls and suggests corrections based on

package/src/core/eval-harness.ts

@@ -18,19 +18,31 @@ import { ExperienceRuleEngine } from './rule-engine'
 import { ConstitutionLoader, DEFAULT_CONSTITUTION } from './constitution-loader'
 import { ErrorSignatureDB } from './error-signature-db'
 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 { produceRuleProposal, MANAGED_RULES_FILE } from './crsi-producer'
+import {
+  produceRuleProposal,
+  MANAGED_RULES_FILE,
+  buildLessonContent,
+  renderManagedRuleSource,
+} from './crsi-producer'
 import type { CrsiSignal } from './crsi-producer'
 import { loadBehaviorTasks, judgeBehaviorTask } from './behavior-tasks'
 
 // ── Types ──
 
+/** 契约角色：anchor = 安全/机制不变量（门强制不许回退）；target = 缺口/覆盖（应被补）。 */
+export type ContractRole = 'anchor' | 'target' | 'neutral'
+
 export interface EvalResult {
   id: string
   description: string
   passed: boolean
   detail?: string
+  /** 契约角色。缺省 neutral。 */
+  role?: ContractRole
 }
 
 export interface EvalReport {
@@ -42,6 +54,29 @@ export interface EvalReport {
   failures: string[]
 }
 
+/** anchor 契约 id 集合：安全/机制不变量，绝不许回退。门（crsi-modify）强制此集合零回退。 */
+export const ANCHOR_CONTRACT_IDS: ReadonlySet<string> = new Set([
+  'rule-timeout',
+  'rule-git-force',
+  'rule-disabled-skip',
+  'constitution-8-principles',
+  'constitution-facets',
+  'constitution-preamble',
+  'sandbox-protected-constitution',
+  'sandbox-protected-tests',
+  'sandbox-protected-machinery',
+  'protection-completeness',
+  'blast-radius-gate',
+  'red-team-zero-gaps',
+  'producer-rule-shape',
+  'producer-rule-idempotent',
+])
+
+/** 细粒度防回退：返回 role==='anchor' 且已 FAIL 的契约 id。空 = 无 anchor 回退。 */
+export function regressedAnchors(results: EvalResult[]): string[] {
+  return results.filter((r) => r.role === 'anchor' && !r.passed).map((r) => r.id)
+}
+
 // ── Rewards log (path A Phase 1: 奖励信号持久化) ──
 
 const SCORES_FILE = join(homedir(), '.mipham', 'crsi', 'eval-scores.jsonl')
@@ -228,6 +263,48 @@ export function runEval(): EvalReport {
       ruleProposal !== null && produceRuleProposal(frozenSignal, ruleProposal.newContent) === null,
   })
 
+  // ── 组件归因（ground truth：缺省 experiential、显式组件透传、非 experiential 不进 managed-rule） ──
+  results.push({
+    id: 'producer-component-tag',
+    description: '组件归因：缺省 experiential、显式组件透传、非 experiential 不进 managed-rule',
+    passed:
+      buildLessonContent(frozenSignal, 't', 'src').includes('- 组件: experiential') &&
+      buildLessonContent({ ...frozenSignal, component: 'checker' }, 't', 'src').includes(
+        '- 组件: checker',
+      ) &&
+      renderManagedRuleSource({ ...frozenSignal, component: 'working' }) === null &&
+      renderManagedRuleSource(frozenSignal) !== null,
+  })
+
+  // ── 事后检查器（ground truth：exit 0 判 supported、exit 非 0 判 rejected） ──
+  const postFlight = createDefaultPostFlightChecker()
+  results.push({
+    id: 'postflight-bash-exit',
+    description: '事后检查器：bash exit 0 判 supported、exit 非 0 判 rejected',
+    passed:
+      postFlight.check('Bash', { params: {}, result: { success: true, content: '' } }).verdict ===
+        'supported' &&
+      postFlight.check('Bash', { params: {}, result: { success: false, content: '', error: 'x' } })
+        .verdict === 'rejected',
+  })
+
+  // ── 工作记忆证据接地（ground truth：done 只能由 supported 推进，模型自称不算） ──
+  const wm = new WorkingMemory()
+  wm.setGoal('install-deps', 'install dependencies')
+  wm.observe('install-deps', { verdict: 'no-checker' })
+  const pendingAfterNoChecker = wm.getGoal('install-deps')!.status === 'pending'
+  wm.observe('install-deps', { verdict: 'supported', checkerId: 'bash-exit' })
+  const doneAfterSupported = wm.getGoal('install-deps')!.status === 'done'
+  wm.setGoal('edit-file', 'edit the file')
+  wm.observe('edit-file', { verdict: 'rejected', checkerId: 'edit-applied', reason: 'x' })
+  const blockedAfterRejected = wm.getGoal('edit-file')!.status === 'blocked'
+  results.push({
+    id: 'working-memory-evidence-gated',
+    description:
+      '工作记忆：done 只能由 checker supported 推进，rejected 置 blocked，模型自称（no-checker）不算',
+    passed: pendingAfterNoChecker && doneAfterSupported && blockedAfterRejected,
+  })
+
   // ── 行为缺口（ground truth：当前无规则覆盖的确定性拦截，如实判 FAIL） ──
   // producer 固化 tool-params 规则后，这些缺口翻转 PASS → 分数上升 =「证明更好」。
   const behaviorGaps: Array<{ id: string; command: string }> = [
@@ -246,15 +323,30 @@ export function runEval(): EvalReport {
       id: gap.id,
       description: `行为缺口未覆盖: ${gap.command}`,
       passed: r.warnings.length > 0,
+      role: 'target',
     })
   }
 
   // ── 行为任务集（ground truth：约束行为效果，确定性无 LLM） ──
   const behaviorTasks = loadBehaviorTasks()
   for (const task of behaviorTasks) {
-    results.push(judgeBehaviorTask(task, ruleEngine))
+    results.push({ ...judgeBehaviorTask(task, ruleEngine), role: 'target' })
   }
 
+  // 角色标注：anchor 走集中清单（门保护面单一真源），target 已在上方循环内联。
+  for (const r of results) {
+    if (ANCHOR_CONTRACT_IDS.has(r.id)) r.role = 'anchor'
+  }
+
+  // anchor 自检（ground truth：所有 anchor 契约必须全绿，否则门拒）。
+  const anchorFailures = results.filter((r) => r.role === 'anchor' && !r.passed).map((r) => r.id)
+  results.push({
+    id: 'anchor-gate',
+    description: '所有 anchor 契约必须全绿（细粒度防回退闸）',
+    passed: anchorFailures.length === 0,
+    ...(anchorFailures.length > 0 ? { detail: `回退的 anchor: ${anchorFailures.join(', ')}` } : {}),
+  })
+
   const passed = results.filter((r) => r.passed).length
   return {
     total: results.length,

package/src/core/memory/memory-manager.ts

@@ -4,10 +4,11 @@ import {
   readFileSync,
   writeFileSync,
   unlinkSync,
+  renameSync,
   existsSync,
   statSync,
 } from 'node:fs'
-import { join, extname } from 'node:path'
+import { join, extname, basename } from 'node:path'
 import { similarities } from './tfidf'
 
 export interface MemoryMetadata {
@@ -28,10 +29,43 @@ export interface MemoryEntry {
 
 const INDEX_FILE = 'MEMORY.md'
 const LINKS_FILE = 'links.json'
+const RECALL_STATS_FILE = 'recall-stats.json'
+const AUTO_PREFIX = 'auto-'
+/** 「从没被召回 + 过期」的 auto-* 记忆归档阈值（60 天）。 */
+const GC_STALE_MS = 60 * 24 * 60 * 60 * 1000
+/** 会话记忆合并的 TF-IDF 余弦阈值（> 此值聚成一簇）。 */
+const CONSOLIDATE_THRESHOLD = 0.5
+/** 写时去重的 TF-IDF 余弦阈值（> 此值视为近重复，合并而非新增）。高于合并阈值，只拦近重复。 */
+const DEDUP_THRESHOLD = 0.65
+
+/** 确定性 hash（无 Date.now / Math.random，同输入同输出 → 幂等 lesson 名）。 */
+function stableHash(s: string): string {
+  let h = 0
+  for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) >>> 0
+  return h.toString(36)
+}
+
+/** 写时去重：找同 type 且内容近重复（余弦 > 阈值）的现有记忆。纯函数便于测。 */
+export function findNearDuplicate(
+  candidates: ReadonlyArray<MemoryEntry>,
+  content: string,
+  type: string,
+): MemoryEntry | null {
+  for (const entry of candidates) {
+    if (entry.metadata.type !== type) continue
+    // auto-*（会话记忆，归合并管）与 lesson-*（合并产物）不做写时去重，
+    // 否则合并阶段 write 的 lesson 会被尚存的 auto-* 吸收掉。
+    if (entry.name.startsWith(AUTO_PREFIX) || entry.name.startsWith('lesson-')) continue
+    const sim = similarities(content, [entry.content])[0] ?? 0
+    if (sim > DEDUP_THRESHOLD) return entry
+  }
+  return null
+}
 
 export class MemoryManager {
   private memories = new Map<string, MemoryEntry>()
   private linkGraph: Map<string, Set<string>> = new Map()
+  private recallStats = new Map<string, { recallCount: number; lastRecalledAt: string }>()
   private contextMaxTokens = 200_000
 
   constructor(private memoryDir: string) {
@@ -46,6 +80,7 @@ export class MemoryManager {
   loadAll(): void {
     this.memories.clear()
     this.linkGraph.clear()
+    this.recallStats.clear()
     if (!existsSync(this.memoryDir)) return
 
     let entries: string[] = []
@@ -73,28 +108,32 @@ export class MemoryManager {
     if (!this.loadLinkGraph()) {
       this.rebuildLinkGraph()
     }
+    this.loadRecallStats()
   }
 
   write(name: string, content: string, metadata: MemoryMetadata): void {
-    // Dedup: same name = update, don't create duplicate
-    const formattedBody = this.formatMemoryBody(metadata, content)
+    // 同名 update（replace 语义）
     const existing = this.memories.get(name)
     if (existing) {
-      existing.content = formattedBody
-      existing.metadata = metadata
-      existing.description = metadata.relevance.join(', ')
-      existing.updatedAt = new Date()
-      this.memories.set(name, existing)
-      const body = this.formatMemoryFile(name, metadata, content)
-      writeFileSync(existing.filePath, body, 'utf-8')
-      this.updateWikilinks(name, content)
-      this.updateIndex()
+      this.updateEntry(existing, content, metadata)
       return
     }
 
+    // 写时去重：不同名但同 type + 内容近重复 → 合并进现有（union relevance），不新增（治「越存越乱」）。
+    const nearDup = findNearDuplicate([...this.memories.values()], content, metadata.type)
+    if (nearDup) {
+      const mergedMetadata: MemoryMetadata = {
+        ...metadata,
+        relevance: [...new Set([...nearDup.metadata.relevance, ...metadata.relevance])],
+      }
+      this.updateEntry(nearDup, content, mergedMetadata)
+      return
+    }
+
+    // 新建
     const fileName = `${name}.md`
     const filePath = join(this.memoryDir, fileName)
-
+    const formattedBody = this.formatMemoryBody(metadata, content)
     const body = this.formatMemoryFile(name, metadata, content)
     writeFileSync(filePath, body, 'utf-8')
 
@@ -112,12 +151,27 @@ export class MemoryManager {
     this.updateIndex()
   }
 
-  recall(context: string, limit: number = 10): MemoryEntry[] {
-    const contextLower = context.toLowerCase()
+  /** 更新一条现有记忆（内容/元数据/文件/索引）。同名 update 与近重复合并共用。 */
+  private updateEntry(entry: MemoryEntry, content: string, metadata: MemoryMetadata): void {
+    entry.content = this.formatMemoryBody(metadata, content)
+    entry.metadata = metadata
+    entry.description = metadata.relevance.join(', ')
+    entry.updatedAt = new Date()
+    const body = this.formatMemoryFile(entry.name, metadata, content)
+    writeFileSync(entry.filePath, body, 'utf-8')
+    this.updateWikilinks(entry.name, content)
+    this.updateIndex()
+  }
+
+  recall(context: string, limit: number = 10, grounding?: string): MemoryEntry[] {
+    // 状态接地（治「前存后忘」）：把「当前还剩什么没做」拼进 query，让召回绑定到
+    // 已验证的当前状态，而不是只绑定到「刚说了什么」。历史越长，旧但相关的记忆越不被埋。
+    const query = grounding ? `${grounding}\n${context}` : context
+    const contextLower = query.toLowerCase()
     const entries = [...this.memories.values()]
     // TF-IDF cosine similarity (CJK-bigram aware) replaces the old word-overlap.
     const sims = similarities(
-      context,
+      query,
       entries.map((e) => e.content),
     )
     const scored: Array<{ entry: MemoryEntry; score: number }> = []
@@ -161,7 +215,9 @@ export class MemoryManager {
     }
 
     scored.sort((a, b) => b.score - a.score)
-    return scored.slice(0, limit).map((s) => s.entry)
+    const top = scored.slice(0, limit).map((s) => s.entry)
+    this.recordRecall(top.map((e) => e.name))
+    return top
   }
 
   getLinkedMemories(name: string): MemoryEntry[] {
@@ -190,11 +246,98 @@ export class MemoryManager {
     this.updateIndex()
   }
 
-  buildSystemReminder(context: string, maxTokens?: number): string {
+  /**
+   * 淘汰：归档「从没被召回 + 过期」的 auto-* 记忆；手写记忆只报告不自动动。
+   * auto-* 是 `distillFromSession` 的产物（每次会话各写一条），是可安全淘汰的膨胀源；
+   * 用户手写进 candidates 待人工确认。
+   */
+  gc(): { archived: string[]; candidates: string[] } {
+    const archived: string[] = []
+    const candidates: string[] = []
+    const now = Date.now()
+
+    for (const [name, entry] of this.memories) {
+      const recallCount = this.recallStats.get(name)?.recallCount ?? 0
+      const age = now - entry.updatedAt.getTime()
+      if (recallCount > 0 || age <= GC_STALE_MS) continue
+
+      if (name.startsWith(AUTO_PREFIX)) {
+        this.archive(name, entry)
+        archived.push(name)
+      } else {
+        candidates.push(name)
+      }
+    }
+
+    return { archived, candidates }
+  }
+
+  /** 把一条记忆移到 archive/ 子目录并从内存/索引移除。loadAll 不递归，故天然不再加载。 */
+  private archive(name: string, entry: MemoryEntry): void {
+    try {
+      mkdirSync(join(this.memoryDir, 'archive'), { recursive: true })
+      renameSync(entry.filePath, join(this.memoryDir, 'archive', basename(entry.filePath)))
+    } catch {
+      // best-effort：rename 失败（文件已不在等）也不阻塞淘汰
+    }
+    this.memories.delete(name)
+    this.linkGraph.delete(name)
+    this.recallStats.delete(name)
+    this.saveLinkGraph()
+    this.saveRecallStats()
+    this.updateIndex()
+  }
+
+  /**
+   * 会话记忆合并：把 auto-* 聚簇成持久化 lesson-*（重叠的合并、去重，删原 auto-*）。
+   * 手动触发（/memory consolidate），不后台自动跑。返回创建的 lesson 数与删除的 auto-* 数。
+   */
+  consolidateAutoMemories(): { merged: number; removed: number } {
+    const autoEntries = [...this.memories.values()].filter((e) => e.name.startsWith(AUTO_PREFIX))
+    if (autoEntries.length === 0) return { merged: 0, removed: 0 }
+
+    // 贪心聚簇：与簇代表（首条）余弦 > 阈值则归入，否则新开一簇。
+    const clusters: MemoryEntry[][] = []
+    for (const entry of autoEntries) {
+      let placed = false
+      for (const cluster of clusters) {
+        const sim = similarities(cluster[0]!.content, [entry.content])[0] ?? 0
+        if (sim > CONSOLIDATE_THRESHOLD) {
+          cluster.push(entry)
+          placed = true
+          break
+        }
+      }
+      if (!placed) clusters.push([entry])
+    }
+
+    let merged = 0
+    let removed = 0
+    for (const cluster of clusters) {
+      const name = `lesson-${stableHash(
+        cluster
+          .map((e) => e.name)
+          .sort()
+          .join('|'),
+      )}`
+      const content = cluster.map((e) => e.content).join('\n\n')
+      const relevance = [...new Set(cluster.flatMap((e) => e.metadata.relevance))].slice(0, 10)
+      this.write(name, content, { type: 'feedback', relevance })
+      merged++
+      for (const member of cluster) {
+        this.delete(member.name)
+        removed++
+      }
+    }
+
+    return { merged, removed }
+  }
+
+  buildSystemReminder(context: string, maxTokens?: number, grounding?: string): string {
     // Adaptive budget: 5% of context window, min 5000, max 75000
     const effectiveMaxTokens =
       maxTokens ?? Math.max(5000, Math.min(75000, Math.floor(this.contextMaxTokens * 0.05)))
-    const relevant = this.recall(context, 10)
+    const relevant = this.recall(context, 10, grounding)
     if (relevant.length === 0) return ''
 
     const lines: string[] = ['<system-reminder>', 'Relevant memories from previous sessions:']
@@ -390,6 +533,49 @@ export class MemoryManager {
     }
   }
 
+  /** 记录召回（质量信号）：被召回的条目 recallCount+1。写入 sidecar，不改记忆文件本身。 */
+  private recordRecall(names: string[]): void {
+    if (names.length === 0) return
+    const now = new Date().toISOString()
+    for (const name of names) {
+      const stats = this.recallStats.get(name)
+      if (stats) {
+        stats.recallCount++
+        stats.lastRecalledAt = now
+      } else {
+        this.recallStats.set(name, { recallCount: 1, lastRecalledAt: now })
+      }
+    }
+    this.saveRecallStats()
+  }
+
+  private saveRecallStats(): void {
+    const obj: Record<string, { recallCount: number; lastRecalledAt: string }> = {}
+    for (const [k, v] of this.recallStats) obj[k] = v
+    try {
+      writeFileSync(join(this.memoryDir, RECALL_STATS_FILE), JSON.stringify(obj, null, 2), 'utf-8')
+    } catch {
+      // best-effort — never block on stats write
+    }
+  }
+
+  private loadRecallStats(): void {
+    const path = join(this.memoryDir, RECALL_STATS_FILE)
+    if (!existsSync(path)) return
+    try {
+      const raw = JSON.parse(readFileSync(path, 'utf-8'))
+      for (const [k, v] of Object.entries(raw)) {
+        const rec = v as { recallCount?: number; lastRecalledAt?: string }
+        this.recallStats.set(k, {
+          recallCount: rec.recallCount ?? 0,
+          lastRecalledAt: rec.lastRecalledAt ?? '',
+        })
+      }
+    } catch {
+      // corrupt file — ignore
+    }
+  }
+
   private parseMemoryFile(raw: string, filePath: string): MemoryEntry | null {
     const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
     if (!match) return null

package/src/core/post-flight-checker.ts

@@ -0,0 +1,102 @@
+/**
+ * PostFlightChecker — 事后检查器（Recuris C 组件）。
+ *
+ * Recuris M=(E,W,ρ,C) 的 C：检查器。核心原则「调用技能/尝试工具 ≠ 完成证据；
+ * 只有工具/env 的观察结果支撑才算」。`PreFlightChecker` 是事前拦截（ErrorSignatureDB
+ * + RuleEngine），本模块是事后验证：把「完成谓词 (observation) => boolean」抽象出来，
+ * 对工具结果核对，决策写进会话轨迹（供 ① 组件归因 + eval 打分）。
+ *
+ * 设计约束：
+ *   - 默认 no-checker 静默、rejected 只记录不阻塞（第一阶段只产证据，不强制拦截）。
+ *   - 确定性、无 LLM、可单测。
+ */
+
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import type { ToolResult } from '../shared/types'
+
+/** 工具事后观察：工具实际用的参数 + 工具返回结果。 */
+export interface ToolObservation {
+  params: Record<string, unknown>
+  result: ToolResult
+}
+
+export type CheckerDecision =
+  | { verdict: 'supported'; checkerId: string }
+  | { verdict: 'rejected'; checkerId: string; reason: string }
+  | { verdict: 'no-checker' }
+
+/** 完成谓词：工具/env 观察是否支撑「该变更已生效」。绝不信任模型自称成功。 */
+export type Checker = (observation: ToolObservation) => boolean
+
+export class PostFlightChecker {
+  private checkers = new Map<string, { id: string; predicate: Checker }>()
+
+  register(checkerId: string, toolName: string, predicate: Checker): void {
+    this.checkers.set(toolName, { id: checkerId, predicate })
+  }
+
+  /** 事后核对一次工具结果。无匹配 checker 时返回 no-checker（不阻塞）。 */
+  check(toolName: string, observation: ToolObservation): CheckerDecision {
+    const entry = this.checkers.get(toolName)
+    if (!entry) return { verdict: 'no-checker' }
+    try {
+      return entry.predicate(observation)
+        ? { verdict: 'supported', checkerId: entry.id }
+        : {
+            verdict: 'rejected',
+            checkerId: entry.id,
+            reason: `post-condition failed (${entry.id})`,
+          }
+    } catch {
+      return { verdict: 'rejected', checkerId: entry.id, reason: `checker threw (${entry.id})` }
+    }
+  }
+}
+
+// ── 首批 checker（最小、确定性、可测） ──
+
+/** Bash → exit code 0（对齐 detectViolations 语义，不重复实现）。 */
+function bashExit(o: ToolObservation): boolean {
+  return o.result.success === true
+}
+
+/** Write → 文件存在且长度一致。 */
+function writeExists(o: ToolObservation): boolean {
+  if (!o.result.success) return false
+  const filePath = String(o.params.file_path ?? '')
+  if (!filePath) return false
+  try {
+    if (!existsSync(filePath)) return false
+    const expected = Buffer.byteLength(String(o.params.content ?? ''), 'utf-8')
+    return statSync(filePath).size === expected
+  } catch {
+    return false
+  }
+}
+
+/** Edit → 工具返回 applied 且 new_string 已生效（退化为「old_string 无残留」）。 */
+function editApplied(o: ToolObservation): boolean {
+  if (!o.result.success) return false
+  const filePath = String(o.params.file_path ?? '')
+  const newString = String(o.params.new_string ?? '')
+  const oldString = String(o.params.old_string ?? '')
+  if (!filePath) return false
+  try {
+    if (!existsSync(filePath)) return false
+    const text = readFileSync(filePath, 'utf-8')
+    if (newString) return text.includes(newString)
+    if (oldString) return !text.includes(oldString)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** 默认 checker：Bash/Write/Edit 三件套（工具作用域后置条件）。 */
+export function createDefaultPostFlightChecker(): PostFlightChecker {
+  const c = new PostFlightChecker()
+  c.register('bash-exit', 'Bash', bashExit)
+  c.register('write-exists', 'Write', writeExists)
+  c.register('edit-applied', 'Edit', editApplied)
+  return c
+}

package/src/core/reward-fn.ts

@@ -2,7 +2,7 @@
 // 统一「给一个 policy 打分」：机制哨兵（runEval）与任务表现（runTaskPerformance）
 // 都 conform 成 RewardFn，自改进环的 verify 阶段可对任意奖励源比分数、判退化。
 import type { Llm } from '../providers/llm'
-import { runEval } from './eval-harness'
+import { runEval, type EvalResult } from './eval-harness'
 import { runTaskPerformance } from './task-performance'
 
 /** 奖励函数统一输出的「分数」形状——所有 RewardFn 的 evaluate 都产出它。 */
@@ -11,6 +11,8 @@ export interface ScoreReport {
   passed: number
   score: number // 0-100
   failures: string[]
+  /** 逐契约结果（机制哨兵 runEval 天然携带；任务表现等 reward 可缺省）。 */
+  results?: EvalResult[]
 }
 
 /** 奖励函数（reward function = policy→feedback）：一个具名、可替换的打分器。 */

package/src/core/session-log.ts

@@ -2,6 +2,7 @@ import { appendFileSync, readFileSync, mkdirSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { createHash } from 'node:crypto'
 import type { Message, ToolUseContent, ToolResultContent, ToolResult } from '../shared/types'
+import type { CheckerDecision } from './post-flight-checker'
 
 export type SessionEvent =
   | {
@@ -20,6 +21,7 @@ export type SessionEvent =
   | { type: 'context/inject'; at: number; source: string; text: string }
   | { type: 'compaction/summary'; at: number; summary: string; replacedCount: number }
   | { type: 'compaction/rewrite'; at: number; messages: Message[] }
+  | { type: 'checker/decision'; at: number; toolName: string; decision: CheckerDecision }
 
 export function messageToEvents(msg: Message, at = 0): SessionEvent[] {
   if (msg.role === 'user') {
@@ -94,7 +96,7 @@ export function deriveMessages(events: SessionEvent[]): Message[] {
       // 快照替换：整个投影重建（微压缩/截断等结构性编辑的字节级复现）
       out = structuredClone(e.messages)
     }
-    // 'session/start' → 无消息
+    // 'session/start' / 'checker/decision' → 无消息（决策仅记录证据，不进投影，保字节级可逆）
   }
   return out
 }

package/src/core/working-memory.ts

@@ -0,0 +1,140 @@
+/**
+ * Working Memory — 用「已验证的当前任务状态」接地记忆召回（借鉴 Recuris 的 W，仅借概念）。
+ *
+ * 问题（治「前存后忘」）：MemoryManager.recall 用 TF-IDF 去和「刚说的 query」比，
+ * 历史越长，旧但相关的记忆越容易被埋掉。Recuris 的解法是把召回绑定到「当前还剩
+ * 什么没做」（pending/in_progress），而不是只绑定到「刚说了什么」。
+ *
+ * 本文件分两层：
+ *  - Phase 1（纯只读）：`renderWorkingState(tasks)` 把「现有任务追踪」的未完成任务
+ *    渲染成紧凑接地串，拼进 recall 的 query（状态接地召回）。
+ *  - Phase 2（证据接地状态机）：`WorkingMemory` 类复现 Recuris「w_t → ρ → E_t → (a,o)
+ *    → C → w_{t+1}」环——`done` 只能由 PostFlightChecker 的 `supported` 决策推进，
+ *    `blocked` 由 `rejected` 置位；**没有「模型自称 done」的入口**（不信任模型叙事，
+ *    只信任工具/env 观察）。
+ */
+
+import type { CheckerDecision } from './post-flight-checker'
+
+export interface WorkingGoal {
+  subject: string
+  status: string
+}
+
+/** 渲染「当前仍未完成」的任务主题为紧凑接地串；无未完成任务返回空串。 */
+export function renderWorkingState(tasks: ReadonlyArray<WorkingGoal>): string {
+  const open = tasks.filter((t) => t.status === 'pending' || t.status === 'in_progress')
+  if (open.length === 0) return ''
+  return open
+    .map((t) => t.subject.trim())
+    .filter(Boolean)
+    .join('\n')
+}
+
+// ── Phase 2：证据接地状态机 ──
+
+export type GoalStatus = 'pending' | 'done' | 'blocked'
+
+export interface GoalState {
+  id: string
+  content: string
+  status: GoalStatus
+  /** 推进/置位时固化的证据（checkerId + reason），供审计「谁证明了这个状态」。 */
+  evidence: string[]
+}
+
+/** 从现有任务追踪（Task 工具的 Task 列表）同步的最小结构，避免 import Task 造成循环依赖。 */
+export interface TaskLike {
+  id: string
+  subject: string
+  status: string
+}
+
+export class WorkingMemory {
+  private goals = new Map<string, GoalState>()
+
+  /** 注册一个待办目标（新目标默认 pending）。重复 id 只更新 content，不回退已验证的状态。 */
+  setGoal(id: string, content: string): void {
+    const existing = this.goals.get(id)
+    if (existing) {
+      existing.content = content
+    } else {
+      this.goals.set(id, { id, content, status: 'pending', evidence: [] })
+    }
+  }
+
+  /**
+   * 证据接地推进：`done` 只能由 checker `supported` 决策推进；`rejected` 置 `blocked`；
+   * `no-checker` 不改状态（模型自称不算）。已 `done` 的目标不再回退。
+   */
+  observe(goalId: string, decision: CheckerDecision): void {
+    const g = this.goals.get(goalId)
+    if (!g || g.status === 'done') return
+    if (decision.verdict === 'supported') {
+      g.status = 'done'
+      g.evidence.push(`supported:${decision.checkerId}`)
+    } else if (decision.verdict === 'rejected') {
+      g.status = 'blocked'
+      g.evidence.push(`rejected:${decision.checkerId}:${decision.reason}`)
+    }
+    // no-checker：证据不足，状态不变
+  }
+
+  getGoal(id: string): GoalState | undefined {
+    return this.goals.get(id)
+  }
+
+  /** 从现有任务追踪（Task 工具的 Task 列表）重建目标状态——TaskList 是唯一真源。
+   *  pending/in_progress → pending；completed → done；failed → blocked；deleted 跳过。 */
+  syncFromTasks(tasks: ReadonlyArray<TaskLike>): void {
+    this.goals.clear()
+    for (const t of tasks) {
+      if (t.status === 'deleted') continue
+      const status: GoalStatus =
+        t.status === 'completed' ? 'done' : t.status === 'failed' ? 'blocked' : 'pending'
+      this.goals.set(t.id, { id: t.id, content: t.subject, status, evidence: [] })
+    }
+  }
+
+  /** 紧凑三态块（检索/系统提示用）；无任何目标时返回空串。 */
+  renderWorkingState(): string {
+    if (this.goals.size === 0) return ''
+    const byStatus: Record<GoalStatus, string[]> = { pending: [], done: [], blocked: [] }
+    for (const g of this.goals.values()) {
+      byStatus[g.status].push(g.content.trim())
+    }
+    return (['pending', 'done', 'blocked'] as const)
+      .map((s) => {
+        const items = byStatus[s].filter(Boolean)
+        return `[WORKING] ${s}: ${items.length > 0 ? items.join(', ') : '(none)'}`
+      })
+      .join('\n')
+  }
+}
+
+// ── 证据账本（engine post-flight 后写入；Task 完成门读取） ──
+
+export interface ToolEvidence {
+  toolName: string
+  decision: CheckerDecision
+  at: number
+}
+
+/** 会话级证据账本（对齐 Task 工具的 module-level `tasks` Map，session 生命周期）。 */
+const evidenceLog: ToolEvidence[] = []
+
+/** 记录一次工具事后决策。no-checker 不产证据（忽略）。engine post-flight 后调用。 */
+export function recordToolEvidence(toolName: string, decision: CheckerDecision): void {
+  if (decision.verdict === 'no-checker') return
+  evidenceLog.push({ toolName, decision, at: Date.now() })
+}
+
+/** 某时间点之后是否有 supported 决策（用于任务完成证据门）。 */
+export function hasSupportedEvidenceSince(sinceAt: number): boolean {
+  return evidenceLog.some((e) => e.decision.verdict === 'supported' && e.at >= sinceAt)
+}
+
+/** 测试用：清空证据账本（避免跨测试污染）。 */
+export function clearEvidenceLog(): void {
+  evidenceLog.length = 0
+}

package/src/i18n-core/locales/en-US.json

@@ -407,7 +407,15 @@
       "error": "─ Memory ─\n\nCould not read memory directory.",
       "location": "Location: {path}",
       "total": "Total:    {count} memor{plural}",
-      "footer": "Memories are used by the AI to provide personalized context across sessions.\nEach file in ~/.mipham/memory/ represents one remembered fact or preference."
+      "footer": "Memories are used by the AI to provide personalized context across sessions.\nEach file in ~/.mipham/memory/ represents one remembered fact or preference.",
+      "gc_title": "─ Memory GC ─",
+      "gc_none": "Nothing to archive. All auto-* memories are recent or have been recalled.",
+      "gc_archived": "Archived ({count}):",
+      "gc_candidates": "Manual review candidates ({count}):",
+      "gc_done": "Done. Archived files moved to ~/.mipham/memory/archive/",
+      "consolidate_title": "─ Memory Consolidate ─",
+      "consolidate_none": "No auto-* memories to consolidate.",
+      "consolidate_result": "Consolidated: {removed} auto-* removed, {merged} lessons written."
     },
     "upgrade": {
       "uptodate": "── Upgrade Mipham Code ──\n\nCurrent version: v{current}\nLatest:          v{latest}\n\n✓ Already up to date.\n\nTo check manually: https://www.npmjs.com/package/@miphamai/cli",

package/src/i18n-core/locales/zh-CN.json

@@ -407,7 +407,15 @@
       "error": "─ 记忆 ─\n\n无法读取记忆目录。",
       "location": "位置: {path}",
       "total": "总计:    {count} 条记忆",
-      "footer": "AI 使用记忆提供跨会话的个性化上下文。\n~/.mipham/memory/ 中每个文件代表一条已记住的事实或偏好。"
+      "footer": "AI 使用记忆提供跨会话的个性化上下文。\n~/.mipham/memory/ 中每个文件代表一条已记住的事实或偏好。",
+      "gc_title": "─ 记忆 GC ─",
+      "gc_none": "无需归档。所有 auto-* 记忆要么较新、要么已被召回。",
+      "gc_archived": "已归档（{count} 条）:",
+      "gc_candidates": "待人工确认（{count} 条）:",
+      "gc_done": "完成。归档文件已移到 ~/.mipham/memory/archive/",
+      "consolidate_title": "─ 记忆合并 ─",
+      "consolidate_none": "没有需要合并的 auto-* 记忆。",
+      "consolidate_result": "合并完成：删除 {removed} 条 auto-*，写入 {merged} 条 lesson-*。"
     },
     "upgrade": {
       "uptodate": "── 升级 Mipham Code ──\n\n当前版本: v{current}\n最新版本:          v{latest}\n\n✓ 已是最新版本。\n\n手动检查: https://www.npmjs.com/package/@miphamai/cli",

package/src/shared/package-info.ts

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

package/src/tools/agent/memory.ts

@@ -3,6 +3,8 @@ import { join } from 'node:path'
 import { homedir } from 'node:os'
 import type { ToolDefinition } from '../../shared/index.ts'
 import { MemoryManager } from '../../core/memory/memory-manager'
+import { renderWorkingState } from '../../core/working-memory'
+import { getTasks } from '../exec/task'
 
 const MEMORY_DIR = join(homedir(), '.mipham', 'memory')
 
@@ -58,7 +60,9 @@ export const memoryTool: ToolDefinition = {
       if (!query) return { success: false, content: '', error: 'query is required' }
       const mm = new MemoryManager(MEMORY_DIR)
       mm.loadAll()
-      const results = mm.recall(query, 10)
+      // 状态接地（治「前存后忘」）：除了精确匹配 query，还带上「当前未完成任务」相关的记忆。
+      const grounding = renderWorkingState(getTasks())
+      const results = mm.recall(query, 10, grounding)
       if (results.length === 0) return { success: true, content: '(no matching memories)' }
       const lines = results.map((entry) => {
         const snippet = entry.content.replace(/\n+/g, ' ').trim().slice(0, 140)

package/src/tools/exec/task.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '../../shared/index.ts'
+import { hasSupportedEvidenceSince } from '../../core/working-memory'
 
 export interface Task {
   id: string
@@ -11,6 +12,8 @@ export interface Task {
   blockedBy: string[]
   owner?: string
   createdAt: string
+  /** 完成证据：completed 时是否有 supported 决策接地（软门，unverified 只标记不阻断）。 */
+  completionEvidence?: 'supported' | 'unverified'
   /** Background task output content (set when a background agent completes). */
   output?: string
   /** Background task error message (set when a background agent fails). */
@@ -218,6 +221,9 @@ export const taskTool: ToolDefinition = {
         `Status: ${task.status}`,
         `Description: ${task.description || '(none)'}`,
       ]
+      if (task.completionEvidence) {
+        lines.push(`Completion evidence: ${task.completionEvidence}`)
+      }
       if (task.activeForm) lines.push(`Active form: ${task.activeForm}`)
       if (task.owner) lines.push(`Owner: ${task.owner}`)
       if (task.blocks.length) lines.push(`Blocks: ${task.blocks.join(', ')}`)
@@ -255,7 +261,16 @@ export const taskTool: ToolDefinition = {
       if (params.subject !== undefined) task.subject = params.subject as string
       if (params.description !== undefined) task.description = params.description as string
       if (params.activeForm !== undefined) task.activeForm = params.activeForm as string
-      if (params.status !== undefined) task.status = params.status as Task['status']
+      if (params.status !== undefined) {
+        task.status = params.status as Task['status']
+        // 完成证据门（软门）：completed 时按「自任务创建以来是否有 supported 决策」标记。
+        // unverified 只标记不阻断（对齐 CRSI「最小干预」）。
+        if (params.status === 'completed') {
+          task.completionEvidence = hasSupportedEvidenceSince(new Date(task.createdAt).getTime())
+            ? 'supported'
+            : 'unverified'
+        }
+      }
       if (params.owner !== undefined) task.owner = params.owner as string
 
       // Merge dependency arrays
@@ -281,10 +296,14 @@ export const taskTool: ToolDefinition = {
       const blockedNote = isBlocked(task)
         ? ` (blocked — waiting on: ${getBlockingIds(task).join(', ')})`
         : ''
+      const unverifiedNote =
+        task.status === 'completed' && task.completionEvidence === 'unverified'
+          ? '\n⚠ completed without verified evidence (no supported tool decision since task start)'
+          : ''
 
       return {
         success: true,
-        content: `Task #${taskId} updated.\n${formatTask(task)}${blockedNote}`,
+        content: `Task #${taskId} updated.\n${formatTask(task)}${blockedNote}${unverifiedNote}`,
       }
     }
 

package/src/ui/commands.ts

@@ -46,6 +46,7 @@ import {
 import { NPM_UPDATE_COMMAND, PACKAGE_VERSION, COAUTHOR_TRAILER } from '../shared/index.ts'
 import { getPreference } from '../config/preferences'
 import { loadCrossSessionConfig } from '../config/loader'
+import { getMemoryManager } from '../core/memory/memory-loader'
 import { stripIndent } from './strip-indent.js'
 import { createT } from '../i18n-core/t'
 import type { TranslationMap } from '../i18n-core/types'
@@ -3766,7 +3767,7 @@ const saveCmd: CommandHandler = (ctx, args) => {
 // Memory Management
 // ═══════════════════════════════════════════════════════════════
 
-const memoryCmd: CommandHandler = async (ctx) => {
+const memoryCmd: CommandHandler = async (ctx, args) => {
   const t = resolveT(ctx)
   const { existsSync, readdirSync, readFileSync, statSync } = await import('node:fs')
   const { join } = await import('node:path')
@@ -3774,6 +3775,47 @@ const memoryCmd: CommandHandler = async (ctx) => {
   const home = process.env.HOME || '~'
   const memoryDir = join(home, '.mipham', 'memory')
 
+  // /memory gc — 记忆卫生：归档「0 召回 + 过期」的 auto-* 记忆（手写只报告）
+  if (args[0]?.toLowerCase() === 'gc') {
+    const mm = getMemoryManager()
+    const { archived, candidates } = mm.gc()
+    const lines: string[] = [t('commands.memories.gc_title'), '']
+    if (archived.length === 0 && candidates.length === 0) {
+      lines.push(t('commands.memories.gc_none'))
+    } else {
+      if (archived.length > 0) {
+        lines.push(t('commands.memories.gc_archived', { count: String(archived.length) }))
+        lines.push(...archived.map((n) => `  - ${n}`))
+        lines.push('')
+      }
+      if (candidates.length > 0) {
+        lines.push(t('commands.memories.gc_candidates', { count: String(candidates.length) }))
+        lines.push(...candidates.map((n) => `  - ${n}`))
+        lines.push('')
+      }
+      lines.push(t('commands.memories.gc_done'))
+    }
+    return { content: lines.join('\n') }
+  }
+
+  // /memory consolidate — 会话记忆合并：把 auto-* 聚簇成持久化 lesson-*
+  if (args[0]?.toLowerCase() === 'consolidate') {
+    const mm = getMemoryManager()
+    const { merged, removed } = mm.consolidateAutoMemories()
+    const lines: string[] = [t('commands.memories.consolidate_title'), '']
+    if (removed === 0) {
+      lines.push(t('commands.memories.consolidate_none'))
+    } else {
+      lines.push(
+        t('commands.memories.consolidate_result', {
+          removed: String(removed),
+          merged: String(merged),
+        }),
+      )
+    }
+    return { content: lines.join('\n') }
+  }
+
   if (!existsSync(memoryDir)) {
     return { content: t('commands.memories.no_memories') }
   }