name: compact description: 将当前会话内存压缩为结构化文本以支持会话恢复。支持自定义描述和标签。 argument-hint: “[–description="…"] [–tags=<tag1,tag2>] [–force]”

内存压缩命令 (/memory:compact)

1. 概述

memory:compact 命令将当前会话工作内存压缩为结构化文本，优化用于会话恢复，提取关键信息，并通过 MCP core_memory 工具保存到持久存储。

核心原则:

会话恢复优先: 捕获恢复工作所需的一切
最小化重复探索: 包含文件路径、决策和状态，避免冗余分析
保存思路: 保留复杂调试的笔记和假设
可操作状态: 记录最后操作结果和已知问题

2. 参数

--description: 自定义会话描述（可选）
- 示例: “完成核心内存模块”
- 示例: “调试 JWT 刷新 - 怀疑内存泄漏”
--tags: 逗号分隔的标签用于分类（可选）
--force: 跳过确认，直接保存

3. 结构化输出格式

## 会话 ID
[如果工作流会话活跃则为 WFS-ID，否则 (none)]

## 项目根目录
[项目根目录的绝对路径，例如 D:\Claude_dms3]

## 目标
[高级目标 - 本次会话的“北极星”]

## 执行计划
[关键: 嵌入最新计划的完整详细形式]

### 来源: [workflow | todo | user-stated | inferred]

<details>
<summary>完整执行计划（点击展开）</summary>

[保存完整计划原文 - 不总结]
- 所有阶段、任务、子任务
- 所有文件路径（绝对）
- 所有依赖项和先决条件
- 所有验收标准
- 所有状态标记 ([x] 完成, [ ] 待定)
- 所有笔记和上下文

示例:
## 阶段 1: 设置
- [x] 初始化项目结构
  - 创建 D:\Claude_dms3\src\core\index.ts
  - 添加依赖项: lodash, zod
- [ ] 配置 TypeScript
  - 更新 tsconfig.json 为严格模式

## 阶段 2: 实现
- [ ] 实现核心 API
  - 目标: D:\Claude_dms3\src\api\handler.ts
  - 依赖项: 阶段 1 完成
  - 验收: 所有测试通过

</details>

## 工作文件（已修改）
[主动修改文件的绝对路径]
- D:\Claude_dms3\src\file1.ts (角色: 主要实现)
- D:\Claude_dms3\tests\file1.test.ts (角色: 单元测试)

## 参考文件（只读）
[上下文文件的绝对路径 - 未修改但对理解至关重要]
- D:\Claude_dms3\.claude\CLAUDE.md (角色: 项目指令)
- D:\Claude_dms3\src\types\index.ts (角色: 类型定义)
- D:\Claude_dms3\package.json (角色: 依赖项)

## 最后操作
[最后重要操作及其结果/状态]

## 决策
- [决策]: [推理]
- [决策]: [推理]

## 约束
- [用户指定的限制或偏好]

## 依赖项
- [添加/更改的包或环境要求]

## 已知问题
- [延迟的错误或边缘情况]

## 已完成更改
- [完成的修改]

## 待处理
- [下一步] 或 (none)

## 笔记
[非结构化思考、假设、调试轨迹]

4. 字段定义

字段	目的	恢复价值
会话 ID	工作流会话标识符 (WFS-*)	将内存链接到特定状态任务执行
项目根目录	项目目录的绝对路径	在新会话中启用正确路径解析
目标	会话的最终目标	防止失去对更广泛功能的跟踪
执行计划	任何来源的完整计划（原文）	保存完整计划上下文，避免重新计划
工作文件	主动修改的文件（绝对路径）	立即识别工作发生的位置
参考文件	只读上下文文件（绝对路径）	消除对关键上下文的重复探索
最后操作	最终工具输出/状态	立即状态感知（成功/失败）
决策	架构选择 + 推理	防止重新讨论已定的决策
约束	用户施加的限制	维护个性化编码风格
依赖项	包/环境更改	防止缺失依赖项错误
已知问题	延迟的错误/边缘情况	确保问题不被遗忘
已完成更改	完成的修改	清晰的完成记录
待处理	下一步	立即行动项
笔记	假设、调试轨迹	保存“思路”

5. 执行流程

步骤 1: 分析当前会话

从对话历史中提取以下内容:

const sessionAnalysis = {
  sessionId: "",       // 如果工作流会话活跃则为 WFS-*，否则 null
  projectRoot: "",     // 绝对路径: D:\Claude_dms3
  objective: "",       // 高级目标（1-2句话）
  executionPlan: {
    source: "workflow" | "todo" | "user-stated" | "inferred",
    content: ""        // 完整计划内容 - 始终保存完整详细形式
  },
  workingFiles: [],    // {absolutePath, role} - 修改的文件
  referenceFiles: [],  // {absolutePath, role} - 只读上下文文件
  lastAction: "",      // 最后重要操作 + 结果
  decisions: [],       // {decision, reasoning}
  constraints: [],     // 用户指定的限制
  dependencies: [],    // 添加/更改的包
  knownIssues: [],     // 延迟的错误
  changesMade: [],     // 完成的修改
  pending: [],         // 下一步
  notes: ""            // 非结构化思考
}

步骤 2: 生成结构化文本

// 辅助: 生成执行计划部分
const generateExecutionPlan = (plan) => {
  const sourceLabels = {
    'workflow': 'workflow (IMPL_PLAN.md)',
    'todo': 'todo (TodoWrite)',
    'user-stated': 'user-stated',
    'inferred': 'inferred'
  };

  // 关键: 保存完整计划内容原文 - 不总结
  return `### 来源: ${sourceLabels[plan.source] || plan.source}

<details>
<summary>完整执行计划（点击展开）</summary>

${plan.content}

</details>`;
};

const structuredText = `## 会话 ID
${sessionAnalysis.sessionId || '(none)'}

## 项目根目录
${sessionAnalysis.projectRoot}

## 目标
${sessionAnalysis.objective}

## 执行计划
${generateExecutionPlan(sessionAnalysis.executionPlan)}

## 工作文件（已修改）
${sessionAnalysis.workingFiles.map(f => `- ${f.absolutePath} (角色: ${f.role})`).join('
') || '(none)'}

## 参考文件（只读）
${sessionAnalysis.referenceFiles.map(f => `- ${f.absolutePath} (角色: ${f.role})`).join('
') || '(none)'}

## 最后操作
${sessionAnalysis.lastAction}

## 决策
${sessionAnalysis.decisions.map(d => `- ${d.decision}: ${d.reasoning}`).join('
') || '(none)'}

## 约束
${sessionAnalysis.constraints.map(c => `- ${c}`).join('
') || '(none)'}

## 依赖项
${sessionAnalysis.dependencies.map(d => `- ${d}`).join('
') || '(none)'}

## 已知问题
${sessionAnalysis.knownIssues.map(i => `- ${i}`).join('
') || '(none)'}

## 已完成更改
${sessionAnalysis.changesMade.map(c => `- ${c}`).join('
') || '(none)'}

## 待处理
${sessionAnalysis.pending.length > 0
  ? sessionAnalysis.pending.map(p => `- ${p}`).join('
')
  : '(none)'}

## 笔记
${sessionAnalysis.notes || '(none)'}`

步骤 3: 通过 MCP 导入到核心内存

使用 MCP core_memory 工具保存结构化文本:

mcp__ccw-tools__core_memory({
  operation: "import",
  text: structuredText
})

或通过 CLI（将结构化文本管道导入）:

# 将结构化文本写入临时文件，然后导入
echo "$structuredText" | ccw core-memory import

# 或从文件导入
ccw core-memory import --file /path/to/session-memory.md

响应格式:

{
  "operation": "import",
  "id": "CMEM-YYYYMMDD-HHMMSS",
  "message": "创建内存: CMEM-YYYYMMDD-HHMMSS"
}

步骤 4: 报告恢复 ID

成功导入后，向用户清晰显示恢复 ID:

╔════════════════════════════════════════════════════════════════════════════╗
║  ✓ 会话内存已保存                                                    ║
║                                                                            ║
║  恢复 ID: CMEM-YYYYMMDD-HHMMSS                                         ║
║                                                                            ║
║  恢复方法: "请导入内存 <ID>"                                   ║
║  (MCP: core_memory export | CLI: ccw core-memory export --id <ID>)         ║
╚════════════════════════════════════════════════════════════════════════════╝

6. 质量检查清单

生成前:

[ ] 如果工作流会话活跃，捕获会话 ID (WFS-*)
[ ] 项目根目录是绝对路径（例如 D:\Claude_dms3）
[ ] 目标清晰说明“北极星”目标
[ ] 执行计划: 保存完整计划原文（不总结）
[ ] 计划来源: 清晰标识 (workflow | todo | user-stated | inferred)
[ ] 计划详情: 包含所有阶段、任务、文件路径、依赖项、状态标记
[ ] 所有文件路径是绝对的（非相对）
[ ] 工作文件: 3-8 个修改文件带角色
[ ] 参考文件: 关键上下文文件 (CLAUDE.md, 类型, 配置)
[ ] 最后操作捕获最终状态（成功/失败）
[ ] 决策包括推理，不仅仅是选择
[ ] 已知问题分离延迟错误与遗忘错误
[ ] 笔记保存调试假设（如果有）

7. 路径解析规则

项目根目录检测

检查环境中的当前工作目录
查找项目标记: .git/, package.json, .claude/
使用包含这些标记的最顶层目录

绝对路径转换

// 转换相对路径为绝对路径
const toAbsolutePath = (relativePath, projectRoot) => {
  if (path.isAbsolute(relativePath)) return relativePath;
  return path.join(projectRoot, relativePath);
};

// 示例: "src/api/auth.ts" → "D:\Claude_dms3\src\api\auth.ts"

参考文件类别

类别	示例	优先级
项目配置	`.claude/CLAUDE.md`, `package.json`, `tsconfig.json`	高
类型定义	`src/types/.ts`, `.d.ts`	高
相关模块	具有共享接口的父/兄弟模块	中
测试文件	修改代码对应的测试文件	中
文档	`README.md`, `ARCHITECTURE.md`	低

8. 计划检测（优先级顺序）

优先级 1: 工作流会话 (IMPL_PLAN.md)

// 检查活跃工作流会话
const manifest = await mcp__ccw-tools__session_manager({
  operation: "list",
  location: "active"
});

if (manifest.sessions?.length > 0) {
  const session = manifest.sessions[0];
  const plan = await mcp__ccw-tools__session_manager({
    operation: "read",
    session_id: session.id,
    content_type: "plan"
  });
  sessionAnalysis.sessionId = session.id;
  sessionAnalysis.executionPlan.source = "workflow";
  sessionAnalysis.executionPlan.content = plan.content;
}

优先级 2: TodoWrite（当前会话待办事项）

// 从对话中提取 - 查找 TodoWrite 工具调用
// 保存完整待办事项列表及所有详情
const todos = extractTodosFromConversation();
if (todos.length > 0) {
  sessionAnalysis.executionPlan.source = "todo";
  // 格式化待办事项，带完整上下文 - 保存状态标记
  sessionAnalysis.executionPlan.content = todos.map(t =>
    `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '>' : ' '}] ${t.content}`
  ).join('
');
}

优先级 3: 用户陈述的计划

// 在用户消息中查找明确计划陈述:
// - "这是我的计划: 1. ... 2. ... 3. ..."
// - "我想: 首先..., 然后..., 最后..."
// - 描述步骤的编号或项目符号列表
const userPlan = extractUserStatedPlan();
if (userPlan) {
  sessionAnalysis.executionPlan.source = "user-stated";
  sessionAnalysis.executionPlan.content = userPlan;
}

优先级 4: 推断的计划

// 如果没有明确计划，从以下推断:
// - 任务描述和分解讨论
// - 采取的操作序列
// - 提及的未完成工作
const inferredPlan = inferPlanFromDiscussion();
if (inferredPlan) {
  sessionAnalysis.executionPlan.source = "inferred";
  sessionAnalysis.executionPlan.content = inferredPlan;
}

9. 备注

时机: 在任务完成时或上下文切换前执行
频率: 每个独立任务或里程碑一次
恢复: 新会话可立即以完整上下文继续
知识图: 自动提取实体关系用于可视化
绝对路径: 在不同机器上的跨会话恢复至关重要