持续的克劳德

基于 Claude Code 构建的持久化、可学习的多智能体开发环境

持续的克劳德将 Claude Code 转变为一个持续学习的系统，它能够在会话之间保持上下文一致性，协调专业化的智能体，并通过智能代码分析避免不必要的 token 消耗。

目录

• 为什么是持续的克劳德？
• 设计原则
• 如何与克劳德交流
• 快速入门
• 架构
• 核心系统
  • 技能（109）
  • 智能体（32）
  • 钩子（30）
  • TLDR 代码分析
  • 记忆系统
  • 连续性系统
  • 数学系统
• 工作流
• 安装
• 更新
• 配置
• 贡献
• 许可证

---

为什么是持续的克劳德？

Claude Code 存在一个 压缩问题：当上下文填满时，系统会压缩你的对话，导致会话期间获得的细微理解与决策丢失。

持续的克劳德通过以下方式解决了这个问题：

问题	解决方案
压缩时上下文丢失	YAML 手动交接——更节省 token 的传递方式
每次会话都从头开始	记忆系统召回 + 守护进程自动提取学习成果
读取整个文件会消耗大量 token	5 层代码分析 + 语义索引
复杂任务需要协调	元技能编排智能体工作流
手动重复工作流	109 种技能，可通过自然语言触发

我们的信条：积累，而非压缩。 自动提取学习成果，然后以完整的上下文重新开始。

为什么叫“持续”？为什么叫“积累”？

这个名字是一个双关语。“持续”是因为克劳德能够在会话之间保持状态；“积累”则是因为每次会话都会让系统变得更聪明——学习成果像复利一样不断累积。

---

设计原则

一个智能体由五个要素组成：提示 + 工具 + 上下文 + 记忆 + 模型。

组件	我们优化的内容
提示	技能注入相关上下文；钩子添加系统提醒
工具	TLDR 减少 token 使用；智能体并行处理工作
上下文	不仅是克劳德知道什么，还有它是如何被提供的
记忆	守护进程提取学习成果；召回功能将其呈现出来
模型	当其他四个部分稳固时，模型可以灵活替换

反复杂性

我们抵制插件泛滥。你添加的每一个 MCP、订阅或工具都承诺带来改进，但同时也可能因冲突而破坏上下文、工具或提示。

我们的方法：

• 时间，而非金钱 — 无需付费服务。Perplexity 和 NIA 是可选的，但具有高性价比。
• 学习，而非堆积 — 一个能够学习的系统比收集插件的系统更能处理边缘情况。
• 左移验证 — 钩子在编辑后运行 pyright/ruff，提前捕获错误，无需等待测试。

复杂系统的故障模式在发生之前通常是不可见的。一个学习且上下文高效的系统并不能防止所有故障——但它能够恢复并不断改进。

---

如何与克劳德交流

你不需要记住任何斜杠命令。 只需用自然语言描述你的需求即可。

技能激活系统

当你发送消息时，一个钩子会注入上下文，告诉 克劳德 哪些技能和智能体是相关的。克劳德会根据规则系统推断出应该使用哪些工具。

> “修复 auth.py 中的登录 bug”

🎯 技能激活检查
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚠️ 关键技能（必需）：
  → create_handoff

📚 推荐技能：
  → fix
  → debug

🤖 推荐智能体（节省 token）：
  → debug-agent
  → scout

行动：在回复之前先使用技能工具
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

优先级级别

级别	含义
⚠️ 关键	必须使用（例如，在结束会话前进行交接）
📚 推荐	应该使用（例如，工作流技能）
💡 建议	可考虑使用（例如，优化工具）
📌 可选	如果有更好（例如，文档助手）

自然语言示例

你说什么	激活了什么
“修复损坏的登录”	/fix 工作流 → debug-agent、scout
“构建用户仪表盘”	/build 工作流 → plan-agent、kraken
“我想了解这个代码库”	/explore + scout 智能体
“这个计划可能会出现什么问题？”	/premortem
“帮我弄清楚我需要什么”	/discovery-interview
“今天就到这里吧”	create_handoff（关键）
“从我们上次中断的地方继续”	resume_handoff
“研究认证模式”	oracle 智能体 + perplexity
“查找这个 API 的所有用法”	scout 智能体 + ast-grep

为什么采用这种方法？

优点	如何实现
更容易发现	无需知道有哪些命令存在
上下文感知	系统知道你已经使用了 90% 的上下文
降低认知负荷	自然描述意图，即可获得精选建议
对高级用户友好	仍然支持直接使用 /fix、/build 等命令

技能 vs 工作流 vs 智能体

类型	目的	示例
技能	单一用途工具	commit、tldr-code、qlty-check
工作流	多步骤流程	/fix（sleuth → premortem → kraken → commit）
智能体	专门化的子会话	scout（探索）、oracle（研究）

查看详细的技能激活文档 →

---

快速入门

先决条件

• Python 3.11+
• uv 包管理器
• Docker（用于 PostgreSQL）
• Claude Code CLI

安装

# 克隆
git clone https://github.com/parcadei/Continuous-Claude-v3.git
cd Continuous-Claude-v3/opc

# 运行设置向导（12 步）
uv run python -m scripts.setup.wizard

注意： pyproject.toml 文件位于 opc/ 目录下。请始终在 opc/ 目录中运行 uv 命令。

向导执行的操作

步骤	操作内容
1	备份现有的 .claude/ 配置文件（如果存在）
2	检查前置条件（Docker、Python、uv）
3-5	数据库与 API 密钥配置
6-7	启动 Docker 容器栈，执行数据库迁移
8	安装 Claude Code 集成（32 个智能体、109 项技能、30 个钩子）
9	数学功能（SymPy、Z3、Pint - 可选）
10	TLDR 代码分析工具
11-12	诊断工具 + Loogle（可选）

卸载方法：

cd Continuous-Claude-v3/opc
  uv run python -m scripts.setup.wizard --uninstall

操作内容

1. 归档当前设置 → 将 ~/.claude 移至 ~/.claude-v3.archived.<时间戳>
2. 恢复备份 → 查找最近的 ~/.claude.backup.*（安装时创建），并将其恢复
3. 保留用户数据 → 从归档中复制以下内容：

• history.jsonl（命令历史）
• mcp_config.json（MCP 服务器）
• .env（API 密钥）
• projects.json（项目配置）
• file-history/ 目录
• projects/ 目录

4. 移除 CC-v3 的新增内容 → 其他所有内容（钩子、技能、智能体、规则）

安全特性

• 当前设置会按时间戳归档，不会删除任何内容
• 向导会在继续操作前请求确认
• 会从安装时创建的备份中恢复
• 所有 Claude Code 设置将保持不变

远程数据库设置

默认情况下，CC-v3 通过 Docker 在本地运行 PostgreSQL。对于远程数据库设置：

1. 数据库准备

# 连接到您的远程 PostgreSQL 实例
psql -h 主机名 -U 用户 -d continuous_claude

# 启用 pgvector 扩展（需要超级用户或 rds_superuser）
CREATE EXTENSION IF NOT EXISTS vector;

# 应用模式（来自本地克隆）
psql -h 主机名 -U 用户 -d continuous_claude -f docker/init-schema.sql

托管 PostgreSQL 使用提示：

• AWS RDS：在数据库参数组中将 vector 添加到 shared_preload_libraries
• Supabase：通过数据库扩展页面启用
• Azure Database：使用扩展面板启用 pgvector

2. 连接配置

在 ~/.claude/settings.json 中设置 CONTINUOUS_CLAUDE_DB_URL：

{
  "env": {
    "CONTINUOUS_CLAUDE_DB_URL": "postgresql://用户:密码@主机名:5432/continuous_claude"
  }
}

或者在运行 Claude 之前导出环境变量：

export CONTINUOUS_CLAUDE_DB_URL="postgresql://用户:密码@主机名:5432/continuous_claude"
claude

请参阅 .env.example 文件以获取所有可用的环境变量。

第一次会话

# 启动 Claude Code
claude

# 尝试一个工作流
> /workflow

第一次会话常用命令

命令	功能
/workflow	基于目标的路由（研究/计划/构建/修复）
/fix bug <描述>	调查并修复错误
/build greenfield <功能>	从零开始构建新功能
/explore	理解代码库
/premortem	实施前的风险分析

---

架构

┌─────────────────────────────────────────────────────────────────────┐
│                        CONTINUOUS CLAUDE                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │
│  │   Skills    │    │   Agents    │    │    Hooks    │             │
│  │   (109)     │───▶│    (32)     │◀───│    (30)     │             │
│  └─────────────┘    └─────────────┘    └─────────────┘             │
│         │                  │                  │                     │
│         ▼                  ▼                  ▼                     │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                     TLDR 代码分析                       │   │
│  │   L1:AST → L2:CallGraph → L3:CFG → L4:DFG → L5:Slicing      │   │
│  │                    （节省 95% 的 token）                       │   │
│  └─────────────────────────────────────────────────────────────┘   │
│         │                  │                  │                     │
│         ▼                  ▼                  ▼                     │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │
│  │   Memory    │    │ Continuity  │    │ Coordination│             │
│  │   System    │    │   Ledgers   │    │    Layer    │             │
│  └─────────────┘    └─────────────┘    └─────────────┘             │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

数据流：会话生命周期

会话开始                    工作                      会话结束
    │                              │                             │
    ▼                              ▼                             ▼
┌─────────┐                  ┌─────────┐                   ┌─────────┐
│  加载   │                  │  跟踪  │                   │  保存   │
│ 上下文  │─────────────────▶│ 更改    │──────────────────▶│  状态  │
└─────────┘                  └─────────┘                   └─────────┘
    │                              │                             │
    ├── 连续性账本          ├── 文件声明               ├── 移交
    ├── 记忆回溯              ├── TLDR 索引              ├── 经验总结
    └── 符号索引               └── 黑板                 └── 结果
                                         │
                                         ▼
                                    ┌─────────┐
                                    │ /clear  │
                                    │ 清新    │
                                    │ 上下文  │
                                    └─────────┘

连续性循环（详细）

┌─────────────────────────────────────────────────────────────────────────────┐
│                            连续性循环                              │
└─────────────────────────────────────────────────────────────────────────────┘

  1. 会话开始                     2. 工作中
  ┌────────────────────┐               ┌────────────────────┐
  │                    │               │                    │
  │  分类账加载 ────┼──▶ 上下文    │  工具使用后 ──────┼──▶ 索引交接
  │  交接内容加载    │               │  用户提示 ───────┼──▶ 技能提示
  │  记忆调用        │               │  编辑跟踪 ────┼──▶ 脏标记++
  │  TLDR 缓存预热   │               │  子代理停止 ─────┼──▶ 代理汇报
  │                    │               │                    │
  └────────────────────┘               └────────────────────┘
           │                                    │
           │                                    ▼
           │                           ┌────────────────────┐
           │                           │ 3. 预压缩     │
           │                           │                    │
           │                           │  自动交接 ─────┼──▶ 思考/共享/
           │                           │  (YAML 格式)     │    交接/*.yaml
           │                           │  脏标记 > 20? ─────┼──▶ TLDR 重新索引
           │                           │                    │
           │                           └────────────────────┘
           │                                    │
           │                                    ▼
           │                           ┌────────────────────┐
           │                           │ 4. 会话结束     │
           │                           │                    │
           │                           │  过期心跳 ──┼──▶ 守护进程唤醒
           │                           │  守护进程启动 ────┼──▶ 无头Claude
           │                           │  思考阻塞 ──┼──▶ 归档内存
           │                           │                    │
           │                           └────────────────────┘
           │                                    │
           │                                    │
           └──────────────◀────── /clear ◀──────┘
                          新鲜上下文 + 状态保留

工作流链条

┌─────────────────────────────────────────────────────────────────────────────┐
│                           元技能工作流                              │
└─────────────────────────────────────────────────────────────────────────────┘

  /修复 bug                              /构建新项目
  ─────────                             ─────────────────
  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐
  │  探秘者  │─▶│  事前分析│            │发现阶段 │─▶│计划代理│
  │(诊断)    │  │  (风险)  │            │(澄清)    │  │ (设计)  │
  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘
                     │                                      │
                     ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  巨兽  │                          │ 验证阶段 │
              │  (修复)   │                          │ (检查)  │
              └────┬─────┘                          └────┬─────┘
                   │                                      │
                   ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  调解员 │                          │  巨兽  │
              │ (测试)   │                          │(实施│
              └────┬─────┘                          └────┬─────┘
                   │                                      │
                   ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  提交  │                          │  提交  │
              └──────────┘                          └──────────┘


  /测试驱动开发                                  /重构
  ────                                  ─────────
  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐
  │计划代理│─▶│  调解员 │            │ 凤凰重生 │─▶│  监管者  │
  │ (设计) │  │(测试 🔴)│            │(分析)    │  │ (评审)  │
  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘
                     │                                      │
                     ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  巨兽  │                          │  巨兽  │
              │(代码 🟢) │                          │(转换│
              └────┬─────┘                          └────┬─────┘
                   │                                      │
                   ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  调解员 │                          │  法官   │
              │(验证 ✓)│                          │ (评审) │
              └──────────┘                          └──────────┘

数据层架构

┌─────────────────────────────────────────────────────────────────────────────┐
│                           数据层架构                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  TLDR 5层代码分析              语义索引                     │
│  ┌────────────────────────┐              ┌────────────────────────┐         │
│  │ L1: 抽象语法树 (~500 词)     │              │ BGE-large-en-v1.5      │         │
│  │     └── 函数、     │              │ ├── 全部5层       │         │
│  │         类、签名  │              │ ├── 10行上下文   │         │
│  │                        │              │ └── FAISS索引        │         │
│  │ L2: 调用图 (+440)  │              │                        │         │
│  │     └── 跨文件     │──────────────│ 查询: "auth逻辑"    │         │
│  │         依赖关系   │              │ 返回: 排序后的函数  │         │
│  │                        │              └────────────────────────┘         │
│  │ L3: 控制流图 (+110 词)     │                                                 │
│  │     └── 控制流     │                                                 │
│  │                        │              内存 (PostgreSQL+pgvector)       │
│  │ L4: 数据流图 (+130 词)     │              ┌────────────────────────┐         │
│  │     └── 数据流     │              │ sessions (心跳)   │         │
│  │                        │              │ file_claims (锁)    │         │
│  │ L5: 程序依赖图 (+150 词)     │              │ archival_memory (BGE)  │         │
│  │     └── 切片        │              │ handoffs (嵌入)  │         │
│  └────────────────────────┘              └────────────────────────┘         │
│         ~1,200词                                                       │
│         vs 23,000原始                                                       │
│         = 95%节省                    文件系统                        │
│                                          ┌────────────────────────┐         │
│                                          │ thoughts/              │         │
│                                          │ ├── ledgers/           │         │
│                                          │ │   └── CONTINUITY_*.md│         │
│                                          │ └── shared/            │         │
│                                          │     ├── handoffs/*.yaml│         │
│                                          │     └── plans/*.md     │         │
│                                          │                        │         │
│                                          │ .tldr/                 │         │
│                                          │ └── (守护进程缓存)     │         │
│                                          └────────────────────────┘         │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

---

核心系统

技能系统

技能是通过自然语言触发的模块化能力。位于 .claude/skills/ 目录下。

元技能（工作流编排器）

元技能	链式流程	使用场景
/workflow	路由器 → 适当的工作流	不知道从何开始
/build	发现 → 计划 → 验证 → 实现 → 提交	构建功能
/fix	神探 → 事前分析 → 克拉肯 → 测试 → 提交	修复 bug
/tdd	计划 → 调解者（测试）→ 克拉肯（实现）→ 调解者	测试驱动开发
/refactor	凤凰 → 计划 → 克拉肯 → 审查者 → 调解者	安全的代码重构
/review	并行的专业评审 → 综合	代码审查
/explore	探路者（快速/深入/架构）	理解代码库
/security	漏洞扫描 → 验证	安全审计
/release	审计 → 端到端测试 → 审查 → 更改日志	发布版本

元技能参考

每个元技能支持模式、范围和标志。单独输入技能名称（如 /build）即可进入交互式问题流程。

/build <mode> [options] [description]

模式	链式流程	使用场景
greenfield	发现 → 计划 → 验证 → 实现 → 提交 → PR	从零开始的新功能
brownfield	上手 → 研究 → 计划 → 验证 → 实现	现有代码库中的功能
tdd	计划 → 测试先行 → 实现	测试驱动开发
refactor	影响分析 → 计划 → TDD → 实现	安全的重构

选项	效果
--skip-discovery	跳过访谈阶段（已有清晰规格）
--skip-validate	跳过计划验证
--skip-commit	不自动提交
--skip-pr	不创建 PR 描述
--parallel	并行运行研究代理

/fix <scope> [options] [description]

范围	链式流程	使用场景
bug	调试 → 实现 → 测试 → 提交	一般 bug 修复
hook	调试钩子 → 钩子开发者 → 实现 → 测试	钩子相关问题
deps	预检 → 占卜者 → 计划 → 实现 → 质量	依赖项错误
pr-comments	GitHub 搜索 → 研究 → 计划 → 实现 → 提交	PR 反馈

选项	效果
--no-test	跳过回归测试
--dry-run	仅诊断，不修复
--no-commit	不自动提交

/explore <depth> [options]

深度	时间	功能
quick	~1 分钟	TLDR 树 + 结构概览
deep	~5 分钟	上手 + TLDR + 研究 + 文档
architecture	~3 分钟	TLDR 架构 + 调用图 + 层次

选项	效果
--focus "area"	专注于特定区域（例如 --focus "auth"）
--output handoff	为实施创建交接文档
--output doc	创建文档文件
--entry "func"	从特定入口点开始

/tdd、/refactor、/review、/security、/release

这些技能遵循其定义的链式流程，无需模式标志。只需运行：

/tdd "implement retry logic"
/refactor "extract auth module"
/review                           # 审查当前更改
/security "authentication code"
/release v1.2.0

关键技能（高价值工具）

规划与风险

• premortem: TIGERS & ELEPHANTS 风险分析 - 在任何重大实施前使用
• discovery-interview: 将模糊想法转化为详细规格

上下文管理

• create_handoff: 捕捉会话状态以便传递
• resume_handoff: 从交接中恢复上下文
• continuity_ledger: 跟踪会话内的状态

代码分析（节省 95% 的 token）

• tldr-code: 调用图、CFG、DFG、切片
• ast-grep-find: 结构化代码搜索
• morph-search: 快速文本搜索（比 grep 快 20 倍）

研究

• perplexity-search: AI 驱动的网页搜索
• nia-docs: 库文档搜索
• github-search: 搜索 GitHub 代码/问题/PR

质量

• qlty-check: 70 多种 linter 和自动修复工具
• braintrust-analyze: 会话分析、回放以及调试失败会话

数学与形式证明

• math: 统一计算（SymPy、Z3、Pint）— 所有数学运算的统一入口
• prove: Lean4 定理证明，采用五阶段流程（研究 → 设计 → 测试 → 实施 → 验证）
• pint-compute: 支持单位的算术和转换
• shapely-compute: 计算几何

/prove 技能可在无需学习 Lean 语法的情况下实现机器验证的证明。曾用于创建 Sylvester-Gallai 定理的首个 Lean 形式化证明。

思考过程

我想做什么？
├── 不知道 → /workflow（引导式路由器）
├── 构建 → /build greenfield 或 brownfield
├── 修复 → /fix bug
├── 理解 → /explore
├── 规划 → 先进行事前分析，再使用计划代理
├── 研究 → 使用占卜者或 perplexity-search
├── 审查 → /review
├── 证明 → /prove（Lean4 形式验证）
├── 计算 → /math（SymPy、Z3、Pint）
└── 发布 → /release

查看详细的技能分解 →

---

代理系统

代理是通过任务工具生成的专用 AI 工作人员。位于 .claude/agents/ 目录下。

代理类别（32 个活跃）

注意: 代理数量可能过多——整合是 v4 版本的目标。请根据您的工作流程选择合适的代理。

编排者（2 个）

• maestro: 多代理协调，支持管道、蜂群、陪审团等模式
• kraken: TDD 实现代理，支持检查点和恢复功能

规划者（4 个）

• architect: 功能规划 + API 集成
• phoenix: 重构 + 框架迁移规划
• plan-agent: 轻量级规划，配备研究/MCP 工具
• validate-agent: 根据最佳实践验证计划

探索者（4 个）

• scout: 代码库探索（可替代 Explore 使用）
• oracle: 外部研究（网络、文档、API）
• pathfinder: 外部仓库分析
• research-codebase: 对现有代码库进行文档化

实施者（3 个）

• kraken: TDD 实施，严格遵循测试先行流程
• spark: 轻量级修复和快速调整
• agentica-agent: 使用 Agentica SDK 构建 Python 代理

调试者（3 个）

• sleuth: 通用 bug 调查及根因分析
• debug-agent: 通过日志/代码搜索调查问题
• profiler: 性能分析及竞态条件排查

验证者（2 个） - arbiter、atlas

审查者（6 个） - critic、judge、surveyor、liaison、plan-reviewer、review-agent

专业代理（8 个） - aegis、herald、scribe、chronicler、session-analyst、braintrust-analyst、memory-extractor、onboard

常见工作流程

工作流程	代理链
功能	architect → plan-reviewer → kraken → review-agent → arbiter
重构	phoenix → plan-reviewer → kraken → judge → arbiter
Bug 修复	sleuth → spark/kraken → arbiter → scribe

查看详细的代理指南 →

钩子系统

钩子在 Claude Code 的生命周期关键点进行拦截。钩子位于 .claude/hooks/ 目录下。

钩子事件（共 30 个钩子）

事件	关键钩子	用途
会话开始	session-start-continuity, session-register, braintrust-tracing	加载上下文，注册会话
工具使用前	tldr-read-enforcer, smart-search-router, tldr-context-inject, file-claims	节省 token，搜索路由
工具使用后	post-edit-diagnostics, handoff-index, post-edit-notify	验证、索引
压缩前	pre-compact-continuity	压缩前自动保存
用户提示提交	skill-activation-prompt, memory-awareness	技能提示，记忆召回
子代理停止	subagent-stop-continuity	保存子代理状态
会话结束	session-end-cleanup, session-outcome	清理，提取学习成果

关键钩子

钩子	用途
tldr-context-inject	将代码分析添加到代理提示中
smart-search-router	在适当情况下将 grep 路由到 AST-grep
post-edit-diagnostics	编辑后运行 pyright/ruff
memory-awareness	展示相关学习内容

查看全部 30 个钩子 →

---

TLDR 代码分析

TLDR 通过 5 层分析提供节省 token 的代码摘要。

五层堆栈

层	名称	提供的内容	Token 数量
L1	AST	函数、类、签名	~500 tokens
L2	调用图	谁调用了什么（跨文件）	+440 tokens
L3	CFG	控制流、复杂度	+110 tokens
L4	DFG	数据流、变量追踪	+130 tokens
L5	PDG	程序切片、影响分析	+150 tokens

总计：约 1,200 tokens 对比原始的 23,000 tokens = 节省 95%

CLI 命令

# 结构分析
tldr tree src/                      # 文件树
tldr structure src/ --lang python   # 代码结构（codemaps）

# 搜索与提取
tldr search "process_data" src/     # 查找代码
tldr context process_data --project src/ --depth 2  # LLM 可用的上下文

# 流分析
tldr cfg src/main.py main           # 控制流图
tldr dfg src/main.py main           # 数据流图
tldr slice src/main.py main 42      # 哪些内容影响第 42 行？

# 代码库分析
tldr impact process_data src/       # 哪些地方调用了这个函数？
tldr dead src/                      # 查找不可达代码
tldr arch src/                      # 检测架构层

# 语义搜索（自然语言）
tldr daemon semantic "find authentication logic"

语义索引

除了结构分析外，TLDR 还构建了代码库的 语义索引：

• 自然语言查询 — 可以问“错误处理在哪里？”而不是直接 grep
• 自动重建 — 使用脏标记钩子跟踪文件变化；每 N 次编辑后重建索引
• 选择性索引 — 使用 .tldrignore 控制哪些内容被索引

# .tldrignore 示例
__pycache__/
*.test.py
node_modules/
.venv/

语义索引使用所有 5 层以及每段代码周围的 10 行上下文——而不仅仅是文档字符串。

钩子集成

TLDR 通过钩子自动集成：

• tldr-read-enforcer：返回 L1+L2+L3 而不是完整文件读取
• smart-search-router：将 Grep 路由到 tldr search
• post-tool-use-tracker：当文件更改时更新索引

查看 TLDR 文档 →

---

内存系统

基于 PostgreSQL + pgvector 的跨会话学习功能。

工作原理

会话结束 → 数据库检测到心跳过期（超过 5 分钟）
            → 守护进程启动无头 Claude（Sonnet）
            → 分析会话中的思考块
            → 提取学习内容到 archival_memory
            → 下一个会话召回相关学习内容

关键洞察是：思考块包含了真正的推理过程——不仅是 Claude 做了什么，还有为什么这么做。守护进程会自动提取这些内容。

对话式界面

你说什么	发生什么
“记住认证使用 JWT”	存储带有上下文的学习内容
“回忆认证模式”	搜索内存，显示匹配结果
“我们对 X 达成了什么共识？”	通过 memory-awareness 钩子隐式召回

数据库表结构（4 张表）

表	用途
sessions	跨终端感知
file_claims	跨终端文件锁定
archival_memory	长期学习内容，附带 BGE 嵌入
handoffs	会话交接，附带嵌入

召回命令

# 召回学习内容（文本与向量混合搜索）
cd opc && uv run python scripts/core/recall_learnings.py \
    --query "authentication patterns"

# 显式存储学习内容
cd opc && uv run python scripts/core/store_learning.py \
    --session-id "my-session" \
    --type WORKING_SOLUTION \
    --content "我学到的内容" \
    --confidence high

自动记忆

memory-awareness 钩子会在你发送消息时自动展示相关学习内容。你会看到 MEMORY MATCH 标记——Claude 可以在你未要求的情况下使用这些内容。

---

连续性系统

在上下文清除和会话之间保持状态。

连续性账本

会话内状态跟踪。位置：thoughts/ledgers/CONTINUITY_<topic>.md

# 会话：feature-x
更新时间：2026-01-08

## 目标
实现 feature X，并加入适当的错误处理

## 已完成
- [x] 设计了 API 模式
- [x] 实现了核心逻辑

## 进行中
- [ ] 添加错误处理

## 阻碍因素
- 需要澄清重试策略

交接

会话之间的知识传递。位置：thoughts/shared/handoffs/<session>/

---
date: 2026-01-08T15:26:01+0000
session_name: feature-x
status: complete
---

# 交接：Feature X 实现

## 任务
| 任务 | 状态 |
|------|--------|
| 设计 API | 完成 |
| 实现核心 | 完成 |
| 错误处理 | 待定 |

## 后续步骤
1. 在 API 调用中加入重试逻辑
2. 编写集成测试

命令

命令	效果
“保存状态”	更新连续性账本
“今天就到这里” / /handoff	创建交接文档
“继续工作”	加载最新的交接内容

---

数学系统

具备两种能力：计算（SymPy、Z3、Pint）和形式化验证（Lean4 + Mathlib）。

技术栈

工具	用途	示例
SymPy	符号计算	求解方程、积分、矩阵运算
Z3	约束求解	证明不等式、SAT问题
Pint	单位换算	将英里转换为千米、量纲分析
Lean4	形式化证明	机器验证的定理
Mathlib	10万+ 定理	预先形式化的引理，可供进一步构建
Loogle	类型感知搜索	根据签名查找 Mathlib 引理

两个入口点

技能	使用场景
/math	计算、求解、数值运算
/prove	形式化验证、机器检查的证明

/math 示例

# 解方程
"Solve x² - 4 = 0"  →  x = ±2

# 计算特征值
"Eigenvalues of [[2,1],[1,2]]"  →  {1: 1, 3: 1}

# 证明不等式
"Is x² + y² ≥ 2xy always true?"  →  PROVED (equals (x-y)²)

# 单位换算
"26.2 miles to km"  →  42.16 km

/prove - 形式化验证

机器验证证明的五阶段流程：

📚 研究 → 🏗️ 设计 → 🧪 测试 → ⚙️ 实现 → ✅ 验证

1. 研究：使用 Loogle 搜索 Mathlib，找到证明策略。
2. 设计：创建带有 sorry 占位符的框架。
3. 测试：在证明之前寻找反例。
4. 实现：在编译器反馈循环中填补 sorry。
5. 验证：审计公理，确认没有 sorry。

/prove every group homomorphism preserves identity
/prove continuous functions on compact sets are uniformly continuous

成就：用于创建 Sylvester-Gallai 定理的第一个 Lean 形式化证明。

先决条件（可选）

数学功能需要通过向导第9步安装：

# 向导自动安装
uv pip install sympy z3-solver pint shapely

# Lean4（用于 /prove）
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh

---

工作流

/workflow - 基于目标的路由

> /workflow

? 你的目标是什么？
  ○ Research - 理解代码库/文档
  ○ Plan - 设计实现方案
  ○ Build - 实现功能
  ○ Fix - 调查并解决问题

/fix - Bug 修复

/fix bug "login fails silently"

链路： sleuth → [checkpoint] → [premortem] → kraken → test → commit

范围	作用
bug	一般性 Bug 调查
hook	钩子特定调试
deps	依赖问题
pr-comments	处理 PR 反馈

/build - 功能开发

/build greenfield "user dashboard"

链路： discovery → plan → validate → implement → commit → PR

模式	作用
greenfield	从零开始的新功能
brownfield	修改现有代码库
tdd	测试驱动开发
refactor	安全的代码重构

/premortem - 风险分析

/premortem deep thoughts/shared/plans/feature-x.md

输出：

• TIGERS：明确的威胁（高/中/低严重性）
• ELEPHANTS：未言明的担忧

对于高严重性的风险，需用户接受或缓解后方可继续。

---

安装

完整安装（推荐）

# 克隆
git clone https://github.com/parcadei/continuous-claude.git
cd continuous-claude/opc

# 运行设置向导
uv run python -m scripts.setup.wizard

向导会以交互方式引导您完成所有配置选项。

更新

拉取最新更改并同步您的安装：

cd continuous-claude/opc
uv run python -m scripts.setup.update

这将：

• 从 GitHub 拉取最新代码
• 更新钩子、技能、规则、代理
• 如果已安装，则升级 TLDR
• 如果 TypeScript 钩子发生更改，则重新构建

安装内容

组件	位置
代理（32个）	~/.claude/agents/
技能（109个）	~/.claude/skills/
钩子（30个）	~/.claude/hooks/
规则	~/.claude/rules/
脚本	~/.claude/scripts/
PostgreSQL	Docker 容器

安装模式：复制 vs 符号链接

向导提供两种安装模式：

模式	工作原理	适用场景
Copy（默认）	将文件从仓库复制到 ~/.claude/	最终用户、稳定设置
Symlink	创建指向仓库文件的符号链接	贡献者、开发环境

复制模式（默认）

文件从 continuous-claude/.claude/ 复制到 ~/.claude/。您在 ~/.claude/ 中所做的更改是本地仅有的，并在下次更新时被覆盖。

continuous-claude/.claude/  ──COPY──>  ~/.claude/
     (source)                          (user config)

优点： 稳定，与仓库更改隔离
缺点： 更新时本地更改丢失，需手动同步

符号链接模式（推荐给贡献者）

创建符号链接，使 ~/.claude/ 直接指向仓库文件。无论在哪一侧进行更改，都会影响相同的文件。

~/.claude/rules  ──SYMLINK──>  continuous-claude/.claude/rules
~/.claude/skills ──SYMLINK──>  continuous-claude/.claude/skills
~/.claude/hooks  ──SYMLINK──>  continuous-claude/.claude/hooks
~/.claude/agents ──SYMLINK──>  continuous-claude/.claude/agents

优点：

• 更改会自动同步到仓库（可提交改进）
• 不需要在 git pull 后重新安装
• 轻松贡献回社区

缺点：

• 仓库中的重大变更会立即影响您的设置
• 需要管理 Git 工作流

切换到符号链接模式

如果您以复制模式安装并希望切换：

# 备份当前配置
mkdir -p ~/.claude/backups/$(date +%Y%m%d)
cp -r ~/.claude/{rules,skills,hooks,agents} ~/.claude/backups/$(date +%Y%m%d)/

# 在继续操作前确认备份成功
ls -la ~/.claude/backups/$(date +%Y%m%d)/

# 移除副本（仅在确认上述备份后）
rm -rf ~/.claude/{rules,skills,hooks,agents}

# 创建符号链接（请根据您的仓库路径调整）
REPO="$HOME/continuous-claude"  # 或您克隆的位置
ln -s "$REPO/.claude/rules" ~/.claude/rules
ln -s "$REPO/.claude/skills" ~/.claude/skills
ln -s "$REPO/.claude/hooks" ~/.claude/hooks
ln -s "$REPO/.claude/agents" ~/.claude/agents

# 验证
ls -la ~/.claude | grep -E "rules|skills|hooks|agents"

Windows 用户： 使用 PowerShell（以管理员身份运行或启用开发者模式）：

# 首先启用开发者模式（设置 → 隐私与安全 → 开发者选项）
# 或以管理员身份运行 PowerShell

# 备份当前配置
$BackupDir = "$HOME\.claude\backups\$(Get-Date -Format 'yyyyMMdd')"
New-Item -ItemType Directory -Path $BackupDir -Force
Copy-Item -Recurse "$HOME\.claude\rules","$HOME\.claude\skills","$HOME\.claude\hooks","$HOME\.claude\agents" $BackupDir

# 在继续操作前确认备份成功
Get-ChildItem $BackupDir

# 移除副本（仅在确认备份后）
Remove-Item -Recurse "$HOME\.claude\rules","$HOME\.claude\skills","$HOME\.claude\hooks","$HOME\.claude\agents"

# 创建符号链接（请根据你的仓库位置调整路径）
$REPO = "$HOME\continuous-claude"  # 或者你克隆代码库的任何位置
New-Item -ItemType SymbolicLink -Path "$HOME\.claude\rules" -Target "$REPO\.claude\rules"
New-Item -ItemType SymbolicLink -Path "$HOME\.claude\skills" -Target "$REPO\.claude\skills"
New-Item -ItemType SymbolicLink -Path "$HOME\.claude\hooks" -Target "$REPO\.claude\hooks"
New-Item -ItemType SymbolicLink -Path "$HOME\.claude\agents" -Target "$REPO\.claude\agents"

# 验证
Get-ChildItem "$HOME\.claude" | Where-Object { $_.LinkType -eq "SymbolicLink" }

对于已有项目

安装完成后，启动 Claude 并运行：

> /onboard

这将分析代码库并创建初始的连续性账本。

---

配置

.claude/settings.json

用于配置钩子、工具和工作流的中心化配置文件。

{
  "hooks": {
    "SessionStart": [...],
    "PreToolUse": [...],
    "PostToolUse": [...],
    "UserPromptSubmit": [...]
  }
}

.claude/skills/skill-rules.json

技能激活触发条件。

{
  "rules": [
    {
      "skill": "fix",
      "keywords": ["fix this", "broken", "not working"],
      "intentPatterns": ["fix.*(bug|issue|error)"]
    }
  ]
}

环境变量

变量	用途	是否必需
DATABASE_URL	PostgreSQL 连接字符串	是
BRAINTRUST_API_KEY	会话追踪	否
PERPLEXITY_API_KEY	网络搜索	否
NIA_API_KEY	文档搜索	否
CLAUDE_OPC_DIR	CC 的 opc/ 目录路径（由向导设置）	自动
CLAUDE_PROJECT_DIR	当前项目目录（由 SessionStart 钩子设置）	自动

即使没有 API 密钥，以下服务仍然可以正常工作：

• 连续性系统（账本、交接）
• TLDR 代码分析
• 本地 Git 操作
• TDD 工作流

---

目录结构

continuous-claude/
├── .claude/
│   ├── agents/           # 32 个专业化的 AI 代理
│   ├── hooks/            # 30 个生命周期钩子
│   │   ├── src/          # TypeScript 源代码
│   │   └── dist/         # 编译后的 JavaScript
│   ├── skills/           # 109 个模块化能力
│   ├── rules/            # 系统策略
│   ├── scripts/          # Python 工具脚本
│   └── settings.json     # 钩子配置
├── opc/
│   ├── packages/
│   │   └── tldr-code/    # 5 层代码分析
│   ├── scripts/
│   │   ├── setup/        # 向导、Docker、集成
│   │   └── core/         # recall_learnings, store_learning
│   └── docker/
│       └── init-schema.sql  # 4 表的 PostgreSQL 模式
├── thoughts/
│   ├── ledgers/          # 连续性账本（CONTINUITY_*.md）
│   └── shared/
│       ├── handoffs/     # 会话交接（*.yaml）
│       └── plans/        # 实施计划
└── docs/                 # 文档

---

贡献

请参阅 CONTRIBUTING.md，了解关于以下方面的指南：

• 添加新技能
• 创建代理
• 开发钩子
• 扩展 TLDR

---

致谢

模式与架构

• @numman-ali - 连续性账本模式
• Anthropic - Claude Code 和“带有 MCP 的代码执行”
• obra/superpowers - 代理编排模式
• EveryInc/compound-engineering-plugin - 复合工程工作流
• yoloshii/mcp-code-execution-enhanced - 增强的 MCP 执行
• HumanLayer - 代理模式

工具与服务

• uv - Python 打包
• tree-sitter - 代码解析
• Braintrust - LLM 评估、日志记录和会话追踪
• qlty - 通用代码质量 CLI（70 多种 linter）
• ast-grep - 基于 AST 的代码搜索和重构
• Nia - 库文档搜索
• Morph - WarpGrep 快速代码搜索
• Firecrawl - 网页抓取 API
• RepoPrompt - 高效的代码库映射

---

星标历史

---

许可证

MIT - 可自由使用，并欢迎贡献回社区。

---

Continuous Claude：不仅仅是一个编码助手——它是一个持久、可学习的多代理开发环境，每次会话都会变得更加智能。

Continuous-Claude-v3 快速上手指南

Continuous-Claude-v3 是一个基于 Claude Code 构建的持久化、可学习、多智能体开发环境。它通过自动提取会话记忆、协调专用智能体以及智能代码分析，解决了传统 AI 编程中上下文丢失和 Token 浪费的问题，让 Claude 具备跨会话的“复合增长”能力。

环境准备

在开始之前，请确保您的系统满足以下要求：

• 操作系统: Linux, macOS 或 Windows (WSL2 推荐)
• Python: 版本 3.11 或更高
• 包管理器: uv (高性能 Python 包安装器)
• 容器引擎: Docker (用于运行本地 PostgreSQL 数据库)
• 核心工具: 已安装并配置好 Claude Code CLI

提示: 国内用户若遇到 uv 或 git clone 速度慢的问题，可配置国内镜像源或使用加速代理。

安装步骤

1. 克隆项目

首先将仓库克隆到本地，并进入核心目录 opc（注意：所有后续命令均需在此目录下执行）。

git clone https://github.com/parcadei/Continuous-Claude-v3.git
cd Continuous-Claude-v3/opc

2. 运行安装向导

使用 uv 运行设置向导，该脚本将自动完成依赖检查、数据库配置及 Claude Code 集成。整个过程包含 12 个步骤。

uv run python -m scripts.setup.wizard

向导主要执行操作：

1. 备份现有的 .claude/ 配置（如有）。
2. 检查前置依赖（Docker, Python, uv）。
3. 配置数据库及 API 密钥。
4. 启动 Docker 栈并运行数据库迁移。
5. 安装核心组件：32 个智能体 (Agents)、109 项技能 (Skills) 和 30 个钩子 (Hooks)。
6. （可选）安装数学功能模块及代码分析工具。

3. 远程数据库配置（可选）

默认情况下，系统通过 Docker 在本地运行 PostgreSQL。若需连接远程数据库（如 AWS RDS, Supabase 等）：

1. 在远程数据库中启用 pgvector 扩展并导入 schema：

   psql -h hostname -U user -d continuous_claude -f docker/init-schema.sql
   

2. 在 ~/.claude/settings.json 中配置连接字符串，或导出环境变量：

   export CONTINUOUS_CLAUDE_DB_URL="postgresql://user:password@hostname:5432/continuous_claude"
   

卸载方法

如需移除该系统并恢复原始配置：

cd Continuous-Claude-v3/opc
uv run python -m scripts.setup.wizard --uninstall

基本使用

安装完成后，无需记忆复杂的斜杠命令，只需用自然语言描述需求，系统会自动激活相应的技能和智能体。

启动会话

claude

常用工作流示例

进入交互界面后，您可以直接尝试以下指令：

您的需求	输入指令	系统行为
修复 Bug	/fix bug <描述>	自动调用调试智能体进行定位和修复
新功能开发	/build greenfield <功能名>	启动规划与构建工作流
理解代码库	/explore	调用 Scout 智能体探索代码结构
风险评估	/premortem	在实施前进行潜在风险分析
通用任务	直接描述 (如 "优化登录逻辑")	系统自动匹配最佳技能组合

关键操作提示

• 结束会话: 当完成当前任务时，务必告诉 Claude "Done for today" 或手动触发 create_handoff。这将把当前会话的关键学习成果提取并保存到记忆中，供下次会话使用。
• 恢复上下文: 新会话开始时，说 "Resume where we left off" 或触发 resume_handoff，系统将加载之前的上下文和记忆。
• 技能优先级: 系统会根据上下文提示技能优先级（⚠️ 必须使用、📚 推荐使用、💡 建议使用），请留意终端输出的激活检查信息。

通过以上步骤，您即可拥有一个能够持续学习、跨会话保持上下文的增强型 AI 开发环境。