@miphamai/cli 0.66.0 → 0.69.0

package/bin/mipham.ts

@@ -1070,7 +1070,14 @@ async function runInitCLI(): Promise<boolean> {
   const targetDir = rawTarget ? resolve(rawTarget.replace(/^~/, homedir())) : process.cwd()
 
   const gitInit = !args.includes('--no-git')
-  const result = scaffoldProject(targetDir, { gitInit })
+  const full = args.includes('--full')
+  const licenseArg = args.find((a) => a.startsWith('--license='))
+  const licenseVal = licenseArg?.split('=')[1]
+  const license =
+    licenseVal === 'mit' || licenseVal === 'apache' || licenseVal === 'proprietary'
+      ? licenseVal
+      : undefined
+  const result = scaffoldProject(targetDir, { gitInit, full, license })
 
   const lines: string[] = ['', `✅ Mipham Code 项目已初始化：${targetDir}`, '']
   if (result.created.length > 0) {
@@ -1160,6 +1167,9 @@ async function main() {
 Usage:
   mipham                     Launch interactive CLI
   mipham init [dir]          Scaffold a project (CLAUDE.md/MIPHAM.md/README.md)
+    --full                     Full scaffold: 8-section CLAUDE.md + 7 .md + .github templates
+    --license=<type>           mit | apache | proprietary (default: proprietary)
+    --no-git                   Skip git init
   mipham update              Update to the latest version
   mipham upgrade             Same as 'mipham update'
   mipham daemon <cmd>        Daemon lifecycle (start, stop, status, restart)

package/package.json

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

package/src/core/credential-masker/search.ts

@@ -1,7 +1,22 @@
+import { realpathSync } from 'node:fs'
 import type { CredentialMaskingConfig } from '../../shared/index.ts'
 import { matchCredentialFile } from './matcher'
 import { CREDENTIAL_SENTINEL } from './types'
 
+/**
+ * Resolve a path through symlinks before deny-rule matching, so a symlink whose
+ * name is innocuous but whose target is a sensitive file is still masked —
+ * mirroring Read, which matches on the canonical path. Falls back to the raw
+ * path when the target doesn't exist (e.g. synthetic paths in tests).
+ */
+function resolveForMatch(p: string): string {
+  try {
+    return realpathSync(p)
+  } catch {
+    return p
+  }
+}
+
 /**
  * Mask grep/search output: any match line that belongs to a credential file
  * (e.g. `.env`, `.aws/credentials`) has its content replaced with the
@@ -31,7 +46,9 @@ export function maskSearchOutput(
       const m = line.match(/^(.+?):(\d+):(.*)$/)
       if (m) {
         out.push(
-          matchCredentialFile(m[1]!, config) ? `${m[1]}:${m[2]}:${CREDENTIAL_SENTINEL}` : line,
+          matchCredentialFile(resolveForMatch(m[1]!), config)
+            ? `${m[1]}:${m[2]}:${CREDENTIAL_SENTINEL}`
+            : line,
         )
       } else {
         out.push(line)
@@ -49,7 +66,7 @@ export function maskSearchOutput(
       out.push(line) // blank separator — pass through, keep current file
       continue
     }
-    currentMasked = !!matchCredentialFile(line, config)
+    currentMasked = !!matchCredentialFile(resolveForMatch(line), config)
     out.push(line)
   }
 
@@ -68,6 +85,6 @@ export function maskGlobOutput(paths: string, config?: CredentialMaskingConfig):
   if (!config?.enabled) return paths
   return paths
     .split('\n')
-    .map((p) => (matchCredentialFile(p, config) ? CREDENTIAL_SENTINEL : p))
+    .map((p) => (matchCredentialFile(resolveForMatch(p), config) ? CREDENTIAL_SENTINEL : p))
     .join('\n')
 }

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