@miphamai/cli 0.66.0 → 0.69.0

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/index.tsx

@@ -314,7 +314,7 @@ export async function runApp(options: RunOptions): Promise<void> {
   const { isEmptyProject } = await import('./core/project-scaffold')
   if (isEmptyProject(process.cwd())) {
     console.log(
-      '\n💡 空目录。运行 `mipham init` 生成规范项目文档（CLAUDE.md / MIPHAM.md / README.md），或直接开始对话。\n',
+      '\n💡 空目录。运行 `mipham init` 生成基础文档，或 `mipham init --full` 生成完整规范（八章 CLAUDE.md + 7 个 .md + .github 模板），或直接开始对话。\n',
     )
   }
 

package/src/security/fd.ts

@@ -0,0 +1,52 @@
+import { openSync, writeFileSync, closeSync, constants } from 'node:fs'
+
+/**
+ * O_NOFOLLOW is POSIX-only; on Windows it is undefined. Fall back to 0 (a
+ * no-op) — Windows symlinks are governed by different semantics, and
+ * `resolveSafe` still rejects UNC/device-namespace paths and workspace
+ * escapes before any file is opened.
+ */
+const O_NOFOLLOW = constants.O_NOFOLLOW ?? 0
+
+/**
+ * Open a file with O_NOFOLLOW so a symlink swapped in after path resolution
+ * (a TOCTOU race) fails with ELOOP instead of being silently followed.
+ *
+ * `resolveSafe` resolves symlinks at check time, but the returned canonical
+ * path is a *string*; re-opening it by path re-resolves the filesystem. If a
+ * concurrent process replaces the final component with a symlink between the
+ * check and the open, O_NOFOLLOW makes the open fail closed.
+ *
+ * Callers combine with their own flags (O_RDONLY / O_WRONLY / O_CREAT /
+ * O_TRUNC). Throws ELOOP when the path is a symlink.
+ */
+export function openNoFollow(path: string, flags: number, mode?: number): number {
+  return openSync(path, flags | O_NOFOLLOW, mode)
+}
+
+/** True if `err` is ELOOP — a symlink was encountered where O_NOFOLLOW forbade following it. */
+export function isSymlinkLoop(err: unknown): boolean {
+  return (err as NodeJS.ErrnoException)?.code === 'ELOOP'
+}
+
+/**
+ * Open a file O_WRONLY|O_NOFOLLOW, write `content`, and close. Used by Write
+ * and Edit so a symlink swapped in after `resolveSafe` is rejected rather than
+ * followed (writing through it would clobber an out-of-workspace target).
+ *
+ * `flags` should include O_WRONLY|O_TRUNC (and O_CREAT for Write). Throws
+ * ELOOP when the path is a symlink.
+ */
+export function writeFileNoFollow(
+  path: string,
+  content: string,
+  flags: number,
+  mode = 0o666,
+): void {
+  const fd = openSync(path, flags | O_NOFOLLOW, mode)
+  try {
+    writeFileSync(fd, content, 'utf-8')
+  } finally {
+    closeSync(fd)
+  }
+}

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.66.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/tools/file/edit.ts

@@ -1,6 +1,7 @@
-import { readFileSync, writeFileSync } from 'node:fs'
+import { readFileSync, closeSync, constants } from 'node:fs'
 import type { ToolDefinition } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
+import { openNoFollow, writeFileNoFollow, isSymlinkLoop } from '../../security/fd'
 
 /**
  * Characters considered part of an identifier in source code.
@@ -89,7 +90,22 @@ export const editTool: ToolDefinition = {
       }
     }
 
-    const content = readFileSync(filePath, 'utf-8')
+    // O_NOFOLLOW: fail closed on a symlink swapped in after resolveSafe (TOCTOU).
+    let rfd: number
+    try {
+      rfd = openNoFollow(filePath, constants.O_RDONLY)
+    } catch (err) {
+      if (isSymlinkLoop(err)) {
+        return { success: false, content: '', error: `Path is a symbolic link: ${filePath}` }
+      }
+      throw err
+    }
+    let content: string
+    try {
+      content = readFileSync(rfd, 'utf-8')
+    } finally {
+      closeSync(rfd)
+    }
 
     // ── Read tracking: mark as read before editing ──
     ctx.readFiles?.add(filePath)
@@ -114,28 +130,43 @@ export const editTool: ToolDefinition = {
       }
     }
 
+    let result: string
+    let count: number
     if (replaceAll) {
       // Build result by splicing at each match (in reverse so indices stay valid)
-      let result = content
+      result = content
       for (let i = matches.length - 1; i >= 0; i--) {
         const idx = matches[i]!
         result = result.slice(0, idx) + newStr + result.slice(idx + oldStr.length)
       }
-      writeFileSync(filePath, result, 'utf-8')
-      return { success: true, content: `Replaced ${matches.length} occurrences in ${filePath}` }
+      count = matches.length
+    } else {
+      if (matches.length > 1) {
+        return {
+          success: false,
+          content: '',
+          error: 'old_string is not unique in file. Use replace_all or make it more specific.',
+        }
+      }
+
+      const idx = matches[0]!
+      result = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length)
+      count = 1
     }
 
-    if (matches.length > 1) {
-      return {
-        success: false,
-        content: '',
-        error: 'old_string is not unique in file. Use replace_all or make it more specific.',
+    // O_NOFOLLOW: reject a symlink swapped in after the read (TOCTOU) instead of
+    // writing through it to an out-of-workspace target.
+    try {
+      writeFileNoFollow(filePath, result, constants.O_WRONLY | constants.O_TRUNC)
+    } catch (err) {
+      if (isSymlinkLoop(err)) {
+        return { success: false, content: '', error: `Path is a symbolic link: ${filePath}` }
       }
+      throw err
+    }
+    return {
+      success: true,
+      content: `Replaced ${count} occurrence${count === 1 ? '' : 's'} in ${filePath}`,
     }
-
-    const idx = matches[0]!
-    const updated = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length)
-    writeFileSync(filePath, updated, 'utf-8')
-    return { success: true, content: `Replaced 1 occurrence in ${filePath}` }
   },
 }

package/src/tools/file/grep.ts

@@ -90,8 +90,22 @@ export function createGrepTool(credentialConfig?: CredentialMaskingConfig): Tool
         // rg not installed → fall through to grep
       }
 
-      // 2. fallback to plain grep
-      const grepArgs = ['grep', '-rn', pattern, searchPath]
+      // 2. fallback: `find -type f -exec grep -Hn {} +`
+      //    `-type f` skips symlinks (file and dir) so the fallback can't follow
+      //    one out of the workspace — macOS BSD `grep -r` follows symlinks and
+      //    would leak target contents, unlike ripgrep's default no-follow.
+      const grepArgs = [
+        'find',
+        searchPath,
+        '-type',
+        'f',
+        '-exec',
+        'grep',
+        '-Hn',
+        pattern,
+        '{}',
+        '+',
+      ]
       try {
         const { stdout, timedOut, exitCode } = await runSearch(grepArgs, ctx.cwd, GREP_TIMEOUT_MS)
         if (timedOut) {

package/src/tools/file/read.ts

@@ -1,6 +1,7 @@
-import { readFileSync, existsSync, statSync } from 'node:fs'
+import { readFileSync, fstatSync, closeSync, constants } from 'node:fs'
 import type { ToolDefinition, CredentialMaskingConfig } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
+import { openNoFollow, isSymlinkLoop } from '../../security/fd'
 import type { Service } from '../../vajra'
 import { toolKey } from '../seam'
 import { withValidation } from '../validation'
@@ -23,25 +24,44 @@ export function createReadTool(credentialConfig?: CredentialMaskingConfig): Tool
     },
     async execute(params, ctx) {
       const filePath = resolveSafe(ctx.cwd, params.file_path as string)
-      if (!existsSync(filePath)) {
-        return { success: false, content: '', error: `File not found: ${filePath}` }
-      }
-      const stat = statSync(filePath)
-      if (stat.isDirectory()) {
-        return { success: false, content: '', error: `Path is a directory: ${filePath}` }
+
+      // O_NOFOLLOW: fail closed if the path was swapped to a symlink after
+      // resolveSafe (TOCTOU) — never follow it to read outside the workspace.
+      let fd: number
+      try {
+        fd = openNoFollow(filePath, constants.O_RDONLY)
+      } catch (err) {
+        if (isSymlinkLoop(err)) {
+          return { success: false, content: '', error: `Path is a symbolic link: ${filePath}` }
+        }
+        if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+          return { success: false, content: '', error: `File not found: ${filePath}` }
+        }
+        throw err
       }
-      // Prevent OOM on single-line files (e.g. 500MB JSON blob)
-      const MAX_FILE_SIZE = 50_000_000 // 50 MB
-      if (stat.size > MAX_FILE_SIZE) {
-        return {
-          success: false,
-          content: '',
-          error: `File too large (${(stat.size / 1e6).toFixed(1)} MB). Max: 50 MB. Use offset/limit for large files.`,
+
+      let content: string
+      try {
+        const stat = fstatSync(fd)
+        if (stat.isDirectory()) {
+          return { success: false, content: '', error: `Path is a directory: ${filePath}` }
+        }
+        // Prevent OOM on single-line files (e.g. 500MB JSON blob)
+        const MAX_FILE_SIZE = 50_000_000 // 50 MB
+        if (stat.size > MAX_FILE_SIZE) {
+          return {
+            success: false,
+            content: '',
+            error: `File too large (${(stat.size / 1e6).toFixed(1)} MB). Max: 50 MB. Use offset/limit for large files.`,
+          }
         }
+        content = readFileSync(fd, 'utf-8')
+      } finally {
+        closeSync(fd)
       }
+
       const offset = (params.offset as number) || 0
       const limit = (params.limit as number) || 2000
-      const content = readFileSync(filePath, 'utf-8')
 
       // ── Read tracking: mark file as read for Write tool safety ──
       ctx.readFiles?.add(filePath)

package/src/tools/file/write.ts

@@ -1,7 +1,8 @@
-import { writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { mkdirSync, existsSync, constants } from 'node:fs'
 import { dirname } from 'node:path'
 import type { ToolDefinition } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
+import { writeFileNoFollow, isSymlinkLoop } from '../../security/fd'
 
 export const writeTool: ToolDefinition = {
   name: 'Write',
@@ -42,7 +43,25 @@ export const writeTool: ToolDefinition = {
     }
 
     mkdirSync(dirname(filePath), { recursive: true })
-    writeFileSync(filePath, content, 'utf-8')
+
+    // O_NOFOLLOW: reject a symlink swapped in after resolveSafe (TOCTOU) —
+    // writing through it would clobber an out-of-workspace target.
+    try {
+      writeFileNoFollow(
+        filePath,
+        content,
+        constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC,
+      )
+    } catch (err) {
+      if (isSymlinkLoop(err)) {
+        return {
+          success: false,
+          content: '',
+          error: `Refusing to write through a symbolic link: ${filePath}`,
+        }
+      }
+      throw err
+    }
 
     // Track as read since we just wrote it (future writes allowed)
     ctx.readFiles?.add(filePath)

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') }
   }