[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-parcadei--Continuous-Claude-v3":3,"tool-parcadei--Continuous-Claude-v3":62},[4,18,26,36,46,54],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":17},4358,"openclaw","openclaw\u002Fopenclaw","OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。\n\n这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。\n\nOpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你",349277,3,"2026-04-06T06:32:30",[13,14,15,16],"Agent","开发框架","图像","数据工具","ready",{"id":19,"name":20,"github_repo":21,"description_zh":22,"stars":23,"difficulty_score":10,"last_commit_at":24,"category_tags":25,"status":17},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,"2026-04-05T11:01:52",[14,15,13],{"id":27,"name":28,"github_repo":29,"description_zh":30,"stars":31,"difficulty_score":32,"last_commit_at":33,"category_tags":34,"status":17},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",160411,2,"2026-04-18T23:33:24",[14,13,35],"语言模型",{"id":37,"name":38,"github_repo":39,"description_zh":40,"stars":41,"difficulty_score":42,"last_commit_at":43,"category_tags":44,"status":17},8272,"opencode","anomalyco\u002Fopencode","OpenCode 是一款开源的 AI 编程助手（Coding Agent），旨在像一位智能搭档一样融入您的开发流程。它不仅仅是一个代码补全插件，而是一个能够理解项目上下文、自主规划任务并执行复杂编码操作的智能体。无论是生成全新功能、重构现有代码，还是排查难以定位的 Bug，OpenCode 都能通过自然语言交互高效完成，显著减少开发者在重复性劳动和上下文切换上的时间消耗。\n\n这款工具专为软件开发者、工程师及技术研究人员设计，特别适合希望利用大模型能力来提升编码效率、加速原型开发或处理遗留代码维护的专业人群。其核心亮点在于完全开源的架构，这意味着用户可以审查代码逻辑、自定义行为策略，甚至私有化部署以保障数据安全，彻底打破了传统闭源 AI 助手的“黑盒”限制。\n\n在技术体验上，OpenCode 提供了灵活的终端界面（Terminal UI）和正在测试中的桌面应用程序，支持 macOS、Windows 及 Linux 全平台。它兼容多种包管理工具，安装便捷，并能无缝集成到现有的开发环境中。无论您是追求极致控制权的资深极客，还是渴望提升产出的独立开发者，OpenCode 都提供了一个透明、可信",144296,1,"2026-04-16T14:50:03",[13,45],"插件",{"id":47,"name":48,"github_repo":49,"description_zh":50,"stars":51,"difficulty_score":32,"last_commit_at":52,"category_tags":53,"status":17},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",109154,"2026-04-18T11:18:24",[14,15,13],{"id":55,"name":56,"github_repo":57,"description_zh":58,"stars":59,"difficulty_score":32,"last_commit_at":60,"category_tags":61,"status":17},6121,"gemini-cli","google-gemini\u002Fgemini-cli","gemini-cli 是一款由谷歌推出的开源 AI 命令行工具，它将强大的 Gemini 大模型能力直接集成到用户的终端环境中。对于习惯在命令行工作的开发者而言，它提供了一条从输入提示词到获取模型响应的最短路径，无需切换窗口即可享受智能辅助。\n\n这款工具主要解决了开发过程中频繁上下文切换的痛点，让用户能在熟悉的终端界面内直接完成代码理解、生成、调试以及自动化运维任务。无论是查询大型代码库、根据草图生成应用，还是执行复杂的 Git 操作，gemini-cli 都能通过自然语言指令高效处理。\n\n它特别适合广大软件工程师、DevOps 人员及技术研究人员使用。其核心亮点包括支持高达 100 万 token 的超长上下文窗口，具备出色的逻辑推理能力；内置 Google 搜索、文件操作及 Shell 命令执行等实用工具；更独特的是，它支持 MCP（模型上下文协议），允许用户灵活扩展自定义集成，连接如图像生成等外部能力。此外，个人谷歌账号即可享受免费的额度支持，且项目基于 Apache 2.0 协议完全开源，是提升终端工作效率的理想助手。",100752,"2026-04-10T01:20:03",[45,13,15,14],{"id":63,"github_repo":64,"name":65,"description_en":66,"description_zh":67,"ai_summary_zh":67,"readme_en":68,"readme_zh":69,"quickstart_zh":70,"use_case_zh":71,"hero_image_url":72,"owner_login":73,"owner_name":73,"owner_avatar_url":74,"owner_bio":75,"owner_company":75,"owner_location":75,"owner_email":75,"owner_twitter":75,"owner_website":75,"owner_url":76,"languages":77,"stars":97,"forks":98,"last_commit_at":99,"license":100,"difficulty_score":101,"env_os":102,"env_gpu":102,"env_ram":102,"env_deps":103,"category_tags":116,"github_topics":117,"view_count":32,"oss_zip_url":75,"oss_zip_packed_at":75,"status":17,"created_at":127,"updated_at":128,"faqs":129,"releases":158},9393,"parcadei\u002FContinuous-Claude-v3","Continuous-Claude-v3","Context management for Claude Code. Hooks maintain state via ledgers and handoffs. MCP execution without context pollution. Agent orchestration with isolated context windows.","Continuous-Claude-v3 是一款专为 Claude Code 打造的增强型开发环境，旨在让 AI 编程具备“持续学习”与“记忆传承”的能力。它主要解决了原生 Claude Code 在会话上下文填满时被迫压缩信息，导致关键决策细节丢失、每次新会话都需重新建立背景的痛点。\n\n通过引入独特的“账本（Ledgers）”和“交接（Handoffs）”机制，Continuous-Claude-v3 能在会话间持久化保存状态，将过往经验像复利一样积累，而非简单丢弃。其核心亮点包括：内置 109 项技能与 32 个专用智能体，可自动协调复杂工作流；采用五层代码分析与语义索引技术，大幅减少读取文件时的 Token 消耗；利用钩子（Hooks）系统在代码编辑后即时执行静态检查，实现错误左移。此外，它支持自然语言交互，用户无需记忆复杂指令即可触发相应功能。\n\n该工具特别适合需要长期维护复杂项目、追求高效上下文管理的软件开发者及技术团队。它帮助开发者摆脱重复解释背景的负担，让 AI 助手随着项目推进越用越聪明，从而构建出更加连贯、智能且节省成本的自动化开发流程。","# Continuous Claude\n\n> A persistent, learning, multi-agent development environment built on Claude Code\n\n[![License: MIT](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FLicense-MIT-blue.svg)](LICENSE)\n[![Claude Code](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FClaude-Code-orange.svg)](https:\u002F\u002Fclaude.ai\u002Fcode)\n[![Skills](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FSkills-109-green.svg)](#skills-system)\n[![Agents](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FAgents-32-purple.svg)](#agents-system)\n[![Hooks](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FHooks-30-blue.svg)](#hooks-system)\n\n**Continuous Claude** transforms Claude Code into a continuously learning system that maintains context across sessions, orchestrates specialized agents, and eliminates wasting tokens through intelligent code analysis.\n\n## Table of Contents\n\n- [Why Continuous Claude?](#why-continuous-claude)\n- [Design Principles](#design-principles)\n- [How to Talk to Claude](#how-to-talk-to-claude)\n- [Quick Start](#quick-start)\n- [Architecture](#architecture)\n- [Core Systems](#core-systems)\n  - [Skills (109)](#skills-system)\n  - [Agents (32)](#agents-system)\n  - [Hooks (30)](#hooks-system)\n  - [TLDR Code Analysis](#tldr-code-analysis)\n  - [Memory System](#memory-system)\n  - [Continuity System](#continuity-system)\n  - [Math System](#math-system)\n- [Workflows](#workflows)\n- [Installation](#installation)\n- [Updating](#updating)\n- [Configuration](#configuration)\n- [Contributing](#contributing)\n- [License](#license)\n\n---\n\n## Why Continuous Claude?\n\nClaude Code has a **compaction problem**: when context fills up, the system compacts your conversation, losing nuanced understanding and decisions made during the session.\n\n**Continuous Claude solves this with:**\n\n| Problem | Solution |\n|---------|----------|\n| Context loss on compaction | YAML handoffs - more token-efficient transfer |\n| Starting fresh each session | Memory system recalls + daemon auto-extracts learnings |\n| Reading entire files burns tokens | 5-layer code analysis + semantic index |\n| Complex tasks need coordination | Meta-skills orchestrate agent workflows |\n| Repeating workflows manually | 109 skills with natural language triggers |\n\n**The mantra: Compound, don't compact.** Extract learnings automatically, then start fresh with full context.\n\n### Why \"Continuous\"? Why \"Compounding\"?\n\nThe name is a pun. **Continuous** because Claude maintains state across sessions. **Compounding** because each session makes the system smarter—learnings accumulate like compound interest.\n\n---\n\n## Design Principles\n\nAn agent is five things: **Prompt + Tools + Context + Memory + Model**.\n\n| Component | What We Optimize |\n|-----------|------------------|\n| **Prompt** | Skills inject relevant context; hooks add system reminders |\n| **Tools** | TLDR reduces tokens; agents parallelize work |\n| **Context** | Not just *what* Claude knows, but *how* it's provided |\n| **Memory** | Daemon extracts learnings; recall surfaces them |\n| **Model** | Becomes swappable when the other four are solid |\n\n### Anti-Complexity\n\nWe resist plugin sprawl. Every MCP, subscription, and tool you add promises improvement but risks breaking context, tools, or prompts through clashes.\n\n**Our approach:**\n- **Time, not money** — No required paid services. Perplexity and NIA are optional, high-value-per-token.\n- **Learn, don't accumulate** — A system that learns handles edge cases better than one that collects plugins.\n- **Shift-left validation** — Hooks run pyright\u002Fruff after edits, catching errors before tests.\n\nThe failure modes of complex systems are structurally invisible until they happen. A learning, context-efficient system doesn't prevent all failures—but it recovers and improves.\n\n---\n\n## How to Talk to Claude\n\n**You don't need to memorize slash commands.** Just describe what you want naturally.\n\n### The Skill Activation System\n\nWhen you send a message, a hook injects context that tells **Claude** which skills and agents are relevant. Claude infers from a rule-based system and decides which tools to use.\n\n```\n> \"Fix the login bug in auth.py\"\n\n🎯 SKILL ACTIVATION CHECK\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n⚠️ CRITICAL SKILLS (REQUIRED):\n  → create_handoff\n\n📚 RECOMMENDED SKILLS:\n  → fix\n  → debug\n\n🤖 RECOMMENDED AGENTS (token-efficient):\n  → debug-agent\n  → scout\n\nACTION: Use Skill tool BEFORE responding\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n```\n\n### Priority Levels\n\n| Level | Meaning |\n|-------|---------|\n| ⚠️ **CRITICAL** | Must use (e.g., handoffs before ending session) |\n| 📚 **RECOMMENDED** | Should use (e.g., workflow skills) |\n| 💡 **SUGGESTED** | Consider using (e.g., optimization tools) |\n| 📌 **OPTIONAL** | Nice to have (e.g., documentation helpers) |\n\n### Natural Language Examples\n\n| What You Say | What Activates |\n|--------------|----------------|\n| \"Fix the broken login\" | `\u002Ffix` workflow → debug-agent, scout |\n| \"Build a user dashboard\" | `\u002Fbuild` workflow → plan-agent, kraken |\n| \"I want to understand this codebase\" | `\u002Fexplore` + scout agent |\n| \"What could go wrong with this plan?\" | `\u002Fpremortem` |\n| \"Help me figure out what I need\" | `\u002Fdiscovery-interview` |\n| \"Done for today\" | `create_handoff` (critical) |\n| \"Resume where we left off\" | `resume_handoff` |\n| \"Research auth patterns\" | oracle agent + perplexity |\n| \"Find all usages of this API\" | scout agent + ast-grep |\n\n### Why This Approach?\n\n| Benefit | How |\n|---------|-----|\n| **More Discoverable** | Don't need to know commands exist |\n| **Context-Aware** | System knows when you're 90% through context |\n| **Reduces Cognitive Load** | Describe intent naturally, get curated suggestions |\n| **Power User Friendly** | Still supports \u002Ffix, \u002Fbuild, etc. directly |\n\n### Skill vs Workflow vs Agent\n\n| Type | Purpose | Example |\n|------|---------|---------|\n| **Skill** | Single-purpose tool | `commit`, `tldr-code`, `qlty-check` |\n| **Workflow** | Multi-step process | `\u002Ffix` (sleuth → premortem → kraken → commit) |\n| **Agent** | Specialized sub-session | scout (exploration), oracle (research) |\n\n[See detailed skill activation docs →](docs\u002Fskill-activation.md)\n\n---\n\n## Quick Start\n\n### Prerequisites\n\n- Python 3.11+\n- [uv](https:\u002F\u002Fgithub.com\u002Fastral-sh\u002Fuv) package manager\n- Docker (for PostgreSQL)\n- Claude Code CLI\n\n### Installation\n\n```bash\n# Clone\ngit clone https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3.git\ncd Continuous-Claude-v3\u002Fopc\n\n# Run setup wizard (12 steps)\nuv run python -m scripts.setup.wizard\n```\n\n> **Note:** The `pyproject.toml` is in `opc\u002F`. Always run `uv` commands from the `opc\u002F` directory.\n\n### What the Wizard Does\n\n| Step | What It Does |\n|------|--------------|\n| 1 | Backup existing .claude\u002F config (if present) |\n| 2 | Check prerequisites (Docker, Python, uv) |\n| 3-5 | Database + API key configuration |\n| 6-7 | Start Docker stack, run migrations |\n| 8 | Install Claude Code integration (32 agents, 109 skills, 30 hooks) |\n| 9 | Math features (SymPy, Z3, Pint - optional) |\n| 10 | TLDR code analysis tool |\n| 11-12 | Diagnostics tools + Loogle (optional) |\n\n\n#### To Uninstall:\n\n```\ncd Continuous-Claude-v3\u002Fopc\n  uv run python -m scripts.setup.wizard --uninstall\n```\n\n**What it does**\n\n1. Archives your current setup → Moves ~\u002F.claude to ~\u002F.claude-v3.archived.\u003Ctimestamp>\n2. Restores your backup → Finds the most recent ~\u002F.claude.backup.* (created during install) and restores it\n3. Preserves user data → Copies these back from the archive:\n\n  - history.jsonl (your command history)\n  - mcp_config.json (MCP servers)\n  - .env (API keys)\n  - projects.json (project configs)\n  - file-history\u002F directory\n  - projects\u002F directory\n4. Removes CC-v3 additions → Everything else (hooks, skills, agents, rules)\n\n\n**Safety Features**\n\n- Your current setup is archived with timestamp - nothing gets deleted\n- The wizard asks for confirmation before proceeding\n- It restores from the backup that was made during installation\n- All your Claude Code settings stay intact\n\n\n### Remote Database Setup\n\nBy default, CC-v3 runs PostgreSQL locally via Docker. For remote database setups:\n\n#### 1. Database Preparation\n\n```bash\n# Connect to your remote PostgreSQL instance\npsql -h hostname -U user -d continuous_claude\n\n# Enable pgvector extension (requires superuser or rds_superuser)\nCREATE EXTENSION IF NOT EXISTS vector;\n\n# Apply the schema (from your local clone)\npsql -h hostname -U user -d continuous_claude -f docker\u002Finit-schema.sql\n```\n\n> **Managed PostgreSQL tips:**\n> - **AWS RDS**: Add `vector` to `shared_preload_libraries` in DB Parameter Group\n> - **Supabase**: Enable via Database Extensions page\n> - **Azure Database**: Use Extensions pane to enable pgvector\n\n#### 2. Connection Configuration\n\nSet `CONTINUOUS_CLAUDE_DB_URL` in `~\u002F.claude\u002Fsettings.json`:\n\n```json\n{\n  \"env\": {\n    \"CONTINUOUS_CLAUDE_DB_URL\": \"postgresql:\u002F\u002Fuser:password@hostname:5432\u002Fcontinuous_claude\"\n  }\n}\n```\n\nOr export before running Claude:\n\n```bash\nexport CONTINUOUS_CLAUDE_DB_URL=\"postgresql:\u002F\u002Fuser:password@hostname:5432\u002Fcontinuous_claude\"\nclaude\n```\n\nSee `.env.example` for all available environment variables.\n\n### First Session\n\n```bash\n# Start Claude Code\nclaude\n\n# Try a workflow\n> \u002Fworkflow\n```\n\n### First Session Commands\n\n| Command | What it does |\n|---------|--------------|\n| `\u002Fworkflow` | Goal-based routing (Research\u002FPlan\u002FBuild\u002FFix) |\n| `\u002Ffix bug \u003Cdescription>` | Investigate and fix a bug |\n| `\u002Fbuild greenfield \u003Cfeature>` | Build a new feature from scratch |\n| `\u002Fexplore` | Understand the codebase |\n| `\u002Fpremortem` | Risk analysis before implementation |\n\n---\n\n## Architecture\n\n```\n┌─────────────────────────────────────────────────────────────────────┐\n│                        CONTINUOUS CLAUDE                            │\n├─────────────────────────────────────────────────────────────────────┤\n│                                                                     │\n│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │\n│  │   Skills    │    │   Agents    │    │    Hooks    │             │\n│  │   (109)     │───▶│    (32)     │◀───│    (30)     │             │\n│  └─────────────┘    └─────────────┘    └─────────────┘             │\n│         │                  │                  │                     │\n│         ▼                  ▼                  ▼                     │\n│  ┌─────────────────────────────────────────────────────────────┐   │\n│  │                     TLDR Code Analysis                       │   │\n│  │   L1:AST → L2:CallGraph → L3:CFG → L4:DFG → L5:Slicing      │   │\n│  │                    (95% token savings)                       │   │\n│  └─────────────────────────────────────────────────────────────┘   │\n│         │                  │                  │                     │\n│         ▼                  ▼                  ▼                     │\n│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │\n│  │   Memory    │    │ Continuity  │    │ Coordination│             │\n│  │   System    │    │   Ledgers   │    │    Layer    │             │\n│  └─────────────┘    └─────────────┘    └─────────────┘             │\n│                                                                     │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n### Data Flow: Session Lifecycle\n\n```\nSessionStart                    Working                      SessionEnd\n    │                              │                             │\n    ▼                              ▼                             ▼\n┌─────────┐                  ┌─────────┐                   ┌─────────┐\n│  Load   │                  │  Track  │                   │  Save   │\n│ context │─────────────────▶│ changes │──────────────────▶│  state  │\n└─────────┘                  └─────────┘                   └─────────┘\n    │                              │                             │\n    ├── Continuity ledger          ├── File claims               ├── Handoff\n    ├── Memory recall              ├── TLDR indexing             ├── Learnings\n    └── Symbol index               └── Blackboard                └── Outcome\n                                         │\n                                         ▼\n                                    ┌─────────┐\n                                    │ \u002Fclear  │\n                                    │ Fresh   │\n                                    │ context │\n                                    └─────────┘\n```\n\n### The Continuity Loop (Detailed)\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                            THE CONTINUITY LOOP                              │\n└─────────────────────────────────────────────────────────────────────────────┘\n\n  1. SESSION START                     2. WORKING\n  ┌────────────────────┐               ┌────────────────────┐\n  │                    │               │                    │\n  │  Ledger loaded ────┼──▶ Context    │  PostToolUse ──────┼──▶ Index handoffs\n  │  Handoff loaded    │               │  UserPrompt ───────┼──▶ Skill hints\n  │  Memory recalled   │               │  Edit tracking ────┼──▶ Dirty flag++\n  │  TLDR cache warmed │               │  SubagentStop ─────┼──▶ Agent reports\n  │                    │               │                    │\n  └────────────────────┘               └────────────────────┘\n           │                                    │\n           │                                    ▼\n           │                           ┌────────────────────┐\n           │                           │ 3. PRE-COMPACT     │\n           │                           │                    │\n           │                           │  Auto-handoff ─────┼──▶ thoughts\u002Fshared\u002F\n           │                           │  (YAML format)     │    handoffs\u002F*.yaml\n           │                           │  Dirty > 20? ──────┼──▶ TLDR re-index\n           │                           │                    │\n           │                           └────────────────────┘\n           │                                    │\n           │                                    ▼\n           │                           ┌────────────────────┐\n           │                           │ 4. SESSION END     │\n           │                           │                    │\n           │                           │  Stale heartbeat ──┼──▶ Daemon wakes\n           │                           │  Daemon spawns ────┼──▶ Headless Claude\n           │                           │  Thinking blocks ──┼──▶ archival_memory\n           │                           │                    │\n           │                           └────────────────────┘\n           │                                    │\n           │                                    │\n           └──────────────◀────── \u002Fclear ◀──────┘\n                          Fresh context + state preserved\n```\n\n### Workflow Chains\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                           META-SKILL WORKFLOWS                              │\n└─────────────────────────────────────────────────────────────────────────────┘\n\n  \u002Ffix bug                              \u002Fbuild greenfield\n  ─────────                             ─────────────────\n  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐\n  │  sleuth  │─▶│ premortem│            │discovery │─▶│plan-agent│\n  │(diagnose)│  │  (risk)  │            │(clarify) │  │ (design) │\n  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘\n                     │                                      │\n                     ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  kraken  │                          │ validate │\n              │  (fix)   │                          │ (check)  │\n              └────┬─────┘                          └────┬─────┘\n                   │                                      │\n                   ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  arbiter │                          │  kraken  │\n              │ (test)   │                          │(implement│\n              └────┬─────┘                          └────┬─────┘\n                   │                                      │\n                   ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  commit  │                          │  commit  │\n              └──────────┘                          └──────────┘\n\n\n  \u002Ftdd                                  \u002Frefactor\n  ────                                  ─────────\n  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐\n  │plan-agent│─▶│  arbiter │            │ phoenix  │─▶│  warden  │\n  │ (design) │  │(tests 🔴)│            │(analyze) │  │ (review) │\n  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘\n                     │                                      │\n                     ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  kraken  │                          │  kraken  │\n              │(code 🟢) │                          │(transform│\n              └────┬─────┘                          └────┬─────┘\n                   │                                      │\n                   ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  arbiter │                          │  judge   │\n              │(verify ✓)│                          │ (review) │\n              └──────────┘                          └──────────┘\n```\n\n### Data Layer Architecture\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                           DATA LAYER ARCHITECTURE                           │\n├─────────────────────────────────────────────────────────────────────────────┤\n│                                                                             │\n│  TLDR 5-LAYER CODE ANALYSIS              SEMANTIC INDEX                     │\n│  ┌────────────────────────┐              ┌────────────────────────┐         │\n│  │ L1: AST (~500 tok)     │              │ BGE-large-en-v1.5      │         │\n│  │     └── Functions,     │              │ ├── All 5 layers       │         │\n│  │         classes, sigs  │              │ ├── 10 lines context   │         │\n│  │                        │              │ └── FAISS index        │         │\n│  │ L2: Call Graph (+440)  │              │                        │         │\n│  │     └── Cross-file     │──────────────│ Query: \"auth logic\"    │         │\n│  │         dependencies   │              │ Returns: ranked funcs  │         │\n│  │                        │              └────────────────────────┘         │\n│  │ L3: CFG (+110 tok)     │                                                 │\n│  │     └── Control flow   │                                                 │\n│  │                        │              MEMORY (PostgreSQL+pgvector)       │\n│  │ L4: DFG (+130 tok)     │              ┌────────────────────────┐         │\n│  │     └── Data flow      │              │ sessions (heartbeat)   │         │\n│  │                        │              │ file_claims (locks)    │         │\n│  │ L5: PDG (+150 tok)     │              │ archival_memory (BGE)  │         │\n│  │     └── Slicing        │              │ handoffs (embeddings)  │         │\n│  └────────────────────────┘              └────────────────────────┘         │\n│         ~1,200 tokens                                                       │\n│         vs 23,000 raw                                                       │\n│         = 95% savings                    FILE SYSTEM                        │\n│                                          ┌────────────────────────┐         │\n│                                          │ thoughts\u002F              │         │\n│                                          │ ├── ledgers\u002F           │         │\n│                                          │ │   └── CONTINUITY_*.md│         │\n│                                          │ └── shared\u002F            │         │\n│                                          │     ├── handoffs\u002F*.yaml│         │\n│                                          │     └── plans\u002F*.md     │         │\n│                                          │                        │         │\n│                                          │ .tldr\u002F                 │         │\n│                                          │ └── (daemon cache)     │         │\n│                                          └────────────────────────┘         │\n│                                                                             │\n└─────────────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Core Systems\n\n### Skills System\n\nSkills are modular capabilities triggered by natural language. Located in `.claude\u002Fskills\u002F`.\n\n#### Meta-Skills (Workflow Orchestrators)\n\n| Meta-Skill | Chain | Use When |\n|------------|-------|----------|\n| `\u002Fworkflow` | Router → appropriate workflow | Don't know where to start |\n| `\u002Fbuild` | discovery → plan → validate → implement → commit | Building features |\n| `\u002Ffix` | sleuth → premortem → kraken → test → commit | Fixing bugs |\n| `\u002Ftdd` | plan → arbiter (tests) → kraken (implement) → arbiter | Test-first development |\n| `\u002Frefactor` | phoenix → plan → kraken → reviewer → arbiter | Safe code transformation |\n| `\u002Freview` | parallel specialized reviews → synthesis | Code review |\n| `\u002Fexplore` | scout (quick\u002Fdeep\u002Farchitecture) | Understand codebase |\n| `\u002Fsecurity` | vulnerability scan → verification | Security audits |\n| `\u002Frelease` | audit → E2E → review → changelog | Ship releases |\n\n#### Meta-Skill Reference\n\nEach meta-skill supports modes, scopes, and flags. Type the skill alone (e.g., `\u002Fbuild`) to get an interactive question flow.\n\n**`\u002Fbuild \u003Cmode> [options] [description]`**\n\n| Mode | Chain | Use For |\n|------|-------|---------|\n| `greenfield` | discovery → plan → validate → implement → commit → PR | New feature from scratch |\n| `brownfield` | onboard → research → plan → validate → implement | Feature in existing codebase |\n| `tdd` | plan → test-first → implement | Test-driven development |\n| `refactor` | impact analysis → plan → TDD → implement | Safe refactoring |\n\n| Option | Effect |\n|--------|--------|\n| `--skip-discovery` | Skip interview phase (have clear spec) |\n| `--skip-validate` | Skip plan validation |\n| `--skip-commit` | Don't auto-commit |\n| `--skip-pr` | Don't create PR description |\n| `--parallel` | Run research agents in parallel |\n\n**`\u002Ffix \u003Cscope> [options] [description]`**\n\n| Scope | Chain | Use For |\n|-------|-------|---------|\n| `bug` | debug → implement → test → commit | General bug fix |\n| `hook` | debug-hooks → hook-developer → implement → test | Hook issues |\n| `deps` | preflight → oracle → plan → implement → qlty | Dependency errors |\n| `pr-comments` | github-search → research → plan → implement → commit | PR feedback |\n\n| Option | Effect |\n|--------|--------|\n| `--no-test` | Skip regression test |\n| `--dry-run` | Diagnose only, don't fix |\n| `--no-commit` | Don't auto-commit |\n\n**`\u002Fexplore \u003Cdepth> [options]`**\n\n| Depth | Time | What It Does |\n|-------|------|--------------|\n| `quick` | ~1 min | tldr tree + structure overview |\n| `deep` | ~5 min | onboard + tldr + research + documentation |\n| `architecture` | ~3 min | tldr arch + call graph + layers |\n\n| Option | Effect |\n|--------|--------|\n| `--focus \"area\"` | Focus on specific area (e.g., `--focus \"auth\"`) |\n| `--output handoff` | Create handoff for implementation |\n| `--output doc` | Create documentation file |\n| `--entry \"func\"` | Start from specific entry point |\n\n**`\u002Ftdd`, `\u002Frefactor`, `\u002Freview`, `\u002Fsecurity`, `\u002Frelease`**\n\nThese follow their defined chains without mode flags. Just run:\n```\n\u002Ftdd \"implement retry logic\"\n\u002Frefactor \"extract auth module\"\n\u002Freview                           # reviews current changes\n\u002Fsecurity \"authentication code\"\n\u002Frelease v1.2.0\n```\n\n#### Key Skills (High-Value Tools)\n\n**Planning & Risk**\n- **premortem**: TIGERS & ELEPHANTS risk analysis - use before any significant implementation\n- **discovery-interview**: Transform vague ideas into detailed specs\n\n**Context Management**\n- **create_handoff**: Capture session state for transfer\n- **resume_handoff**: Resume from handoff with context\n- **continuity_ledger**: Track state within session\n\n**Code Analysis (95% Token Savings)**\n- **tldr-code**: Call graph, CFG, DFG, slicing\n- **ast-grep-find**: Structural code search\n- **morph-search**: Fast text search (20x faster than grep)\n\n**Research**\n- **perplexity-search**: AI-powered web search\n- **nia-docs**: Library documentation search\n- **github-search**: Search GitHub code\u002Fissues\u002FPRs\n\n**Quality**\n- **qlty-check**: 70+ linters, auto-fix\n- **braintrust-analyze**: Session analysis, replay, and debugging failed sessions\n\n**Math & Formal Proofs**\n- **math**: Unified computation (SymPy, Z3, Pint) — one entry point for all math\n- **prove**: Lean4 theorem proving with 5-phase workflow (Research → Design → Test → Implement → Verify)\n- **pint-compute**: Unit-aware arithmetic and conversions\n- **shapely-compute**: Computational geometry\n\nThe `\u002Fprove` skill enables machine-verified proofs without learning Lean syntax. Used to create the first Lean formalization of Sylvester-Gallai theorem.\n\n#### The Thought Process\n\n```\nWhat do I want to do?\n├── Don't know → \u002Fworkflow (guided router)\n├── Building → \u002Fbuild greenfield or brownfield\n├── Fixing → \u002Ffix bug\n├── Understanding → \u002Fexplore\n├── Planning → premortem first, then plan-agent\n├── Researching → oracle or perplexity-search\n├── Reviewing → \u002Freview\n├── Proving → \u002Fprove (Lean4 formal verification)\n├── Computing → \u002Fmath (SymPy, Z3, Pint)\n└── Shipping → \u002Frelease\n```\n\n[See detailed skills breakdown →](docs\u002Fskills\u002F)\n\n---\n\n### Agents System\n\nAgents are specialized AI workers spawned via the Task tool. Located in `.claude\u002Fagents\u002F`.\n\n#### Agent Categories (32 active)\n\n> **Note:** There are likely too many agents—consolidation is a v4 goal. Use what fits your workflow.\n\n**Orchestrators (2)**\n- **maestro**: Multi-agent coordination with patterns (Pipeline, Swarm, Jury)\n- **kraken**: TDD implementation agent with checkpoint\u002Fresume support\n\n**Planners (4)**\n- **architect**: Feature planning + API integration\n- **phoenix**: Refactoring + framework migration planning\n- **plan-agent**: Lightweight planning with research\u002FMCP tools\n- **validate-agent**: Validate plans against best practices\n\n**Explorers (4)**\n- **scout**: Codebase exploration (use instead of Explore)\n- **oracle**: External research (web, docs, APIs)\n- **pathfinder**: External repository analysis\n- **research-codebase**: Document codebase as-is\n\n**Implementers (3)**\n- **kraken**: TDD implementation with strict test-first workflow\n- **spark**: Lightweight fixes and quick tweaks\n- **agentica-agent**: Build Python agents using Agentica SDK\n\n**Debuggers (3)**\n- **sleuth**: General bug investigation and root cause\n- **debug-agent**: Issue investigation via logs\u002Fcode search\n- **profiler**: Performance profiling and race conditions\n\n**Validators (2)** - arbiter, atlas\n\n**Reviewers (6)** - critic, judge, surveyor, liaison, plan-reviewer, review-agent\n\n**Specialized (8)** - aegis, herald, scribe, chronicler, session-analyst, braintrust-analyst, memory-extractor, onboard\n\n#### Common Workflows\n\n| Workflow | Agent Chain |\n|----------|-------------|\n| Feature | architect → plan-reviewer → kraken → review-agent → arbiter |\n| Refactoring | phoenix → plan-reviewer → kraken → judge → arbiter |\n| Bug Fix | sleuth → spark\u002Fkraken → arbiter → scribe |\n\n[See detailed agent guide →](docs\u002Fagents\u002F)\n\n---\n\n### Hooks System\n\nHooks intercept Claude Code at lifecycle points. Located in `.claude\u002Fhooks\u002F`.\n\n#### Hook Events (30 hooks total)\n\n| Event | Key Hooks | Purpose |\n|-------|-----------|---------|\n| **SessionStart** | session-start-continuity, session-register, braintrust-tracing | Load context, register session |\n| **PreToolUse** | tldr-read-enforcer, smart-search-router, tldr-context-inject, file-claims | Token savings, search routing |\n| **PostToolUse** | post-edit-diagnostics, handoff-index, post-edit-notify | Validation, indexing |\n| **PreCompact** | pre-compact-continuity | Auto-save before compaction |\n| **UserPromptSubmit** | skill-activation-prompt, memory-awareness | Skill hints, memory recall |\n| **SubagentStop** | subagent-stop-continuity | Save agent state |\n| **SessionEnd** | session-end-cleanup, session-outcome | Cleanup, extract learnings |\n\n#### Key Hooks\n\n| Hook | Purpose |\n|------|---------|\n| **tldr-context-inject** | Adds code analysis to agent prompts |\n| **smart-search-router** | Routes grep to AST-grep when appropriate |\n| **post-edit-diagnostics** | Runs pyright\u002Fruff after edits |\n| **memory-awareness** | Surfaces relevant learnings |\n\n[See all 30 hooks →](docs\u002Fhooks\u002F)\n\n---\n\n### TLDR Code Analysis\n\nTLDR provides token-efficient code summaries through 5 analysis layers.\n\n#### The 5-Layer Stack\n\n| Layer | Name | What it provides | Tokens |\n|-------|------|------------------|--------|\n| **L1** | AST | Functions, classes, signatures | ~500 tokens |\n| **L2** | Call Graph | Who calls what (cross-file) | +440 tokens |\n| **L3** | CFG | Control flow, complexity | +110 tokens |\n| **L4** | DFG | Data flow, variable tracking | +130 tokens |\n| **L5** | PDG | Program slicing, impact analysis | +150 tokens |\n\n**Total: ~1,200 tokens vs 23,000 raw = 95% savings**\n\n#### CLI Commands\n\n```bash\n# Structure analysis\ntldr tree src\u002F                      # File tree\ntldr structure src\u002F --lang python   # Code structure (codemaps)\n\n# Search and extraction\ntldr search \"process_data\" src\u002F     # Find code\ntldr context process_data --project src\u002F --depth 2  # LLM-ready context\n\n# Flow analysis\ntldr cfg src\u002Fmain.py main           # Control flow graph\ntldr dfg src\u002Fmain.py main           # Data flow graph\ntldr slice src\u002Fmain.py main 42      # What affects line 42?\n\n# Codebase analysis\ntldr impact process_data src\u002F       # Who calls this function?\ntldr dead src\u002F                      # Find unreachable code\ntldr arch src\u002F                      # Detect architectural layers\n\n# Semantic search (natural language)\ntldr daemon semantic \"find authentication logic\"\n```\n\n#### Semantic Index\n\nBeyond structural analysis, TLDR builds a **semantic index** of your codebase:\n\n- **Natural language queries** — Ask \"where is error handling?\" instead of grepping\n- **Auto-rebuild** — Dirty flag hook tracks file changes; index rebuilds after N edits\n- **Selective indexing** — Use `.tldrignore` to control what gets indexed\n\n```bash\n# .tldrignore example\n__pycache__\u002F\n*.test.py\nnode_modules\u002F\n.venv\u002F\n```\n\nThe semantic index uses all 5 layers plus 10 lines of surrounding code context—not just docstrings.\n\n#### Hook Integration\n\nTLDR is automatically integrated via hooks:\n\n- **tldr-read-enforcer**: Returns L1+L2+L3 instead of full file reads\n- **smart-search-router**: Routes Grep to `tldr search`\n- **post-tool-use-tracker**: Updates indexes when files change\n\n[See TLDR documentation →](opc\u002Fpackages\u002Ftldr-code\u002F)\n\n---\n\n### Memory System\n\nCross-session learning powered by PostgreSQL + pgvector.\n\n#### How It Works\n\n```\nSession ends → Database detects stale heartbeat (>5 min)\n            → Daemon spawns headless Claude (Sonnet)\n            → Analyzes thinking blocks from session\n            → Extracts learnings to archival_memory\n            → Next session recalls relevant learnings\n```\n\nThe key insight: **thinking blocks contain the real reasoning**—not just what Claude did, but why. The daemon extracts this automatically.\n\n#### Conversational Interface\n\n| What You Say | What Happens |\n|--------------|--------------|\n| \"Remember that auth uses JWT\" | Stores learning with context |\n| \"Recall authentication patterns\" | Searches memory, surfaces matches |\n| \"What did we decide about X?\" | Implicit recall via memory-awareness hook |\n\n#### Database Schema (4 tables)\n\n| Table | Purpose |\n|-------|---------|\n| **sessions** | Cross-terminal awareness |\n| **file_claims** | Cross-terminal file locking |\n| **archival_memory** | Long-term learnings with BGE embeddings |\n| **handoffs** | Session handoffs with embeddings |\n\n#### Recall Commands\n\n```bash\n# Recall learnings (hybrid text + vector search)\ncd opc && uv run python scripts\u002Fcore\u002Frecall_learnings.py \\\n    --query \"authentication patterns\"\n\n# Store a learning explicitly\ncd opc && uv run python scripts\u002Fcore\u002Fstore_learning.py \\\n    --session-id \"my-session\" \\\n    --type WORKING_SOLUTION \\\n    --content \"What I learned\" \\\n    --confidence high\n```\n\n#### Automatic Memory\n\nThe **memory-awareness** hook surfaces relevant learnings when you send a message. You'll see `MEMORY MATCH` indicators—Claude can use these without you asking.\n\n---\n\n### Continuity System\n\nPreserve state across context clears and sessions.\n\n#### Continuity Ledger\n\nWithin-session state tracking. Location: `thoughts\u002Fledgers\u002FCONTINUITY_\u003Ctopic>.md`\n\n```markdown\n# Session: feature-x\nUpdated: 2026-01-08\n\n## Goal\nImplement feature X with proper error handling\n\n## Completed\n- [x] Designed API schema\n- [x] Implemented core logic\n\n## In Progress\n- [ ] Add error handling\n\n## Blockers\n- Need clarification on retry policy\n```\n\n#### Handoffs\n\nBetween-session knowledge transfer. Location: `thoughts\u002Fshared\u002Fhandoffs\u002F\u003Csession>\u002F`\n\n```yaml\n---\ndate: 2026-01-08T15:26:01+0000\nsession_name: feature-x\nstatus: complete\n---\n\n# Handoff: Feature X Implementation\n\n## Task(s)\n| Task | Status |\n|------|--------|\n| Design API | Completed |\n| Implement core | Completed |\n| Error handling | Pending |\n\n## Next Steps\n1. Add retry logic to API calls\n2. Write integration tests\n```\n\n#### Commands\n\n| Command | Effect |\n|---------|--------|\n| \"save state\" | Updates continuity ledger |\n| \"done for today\" \u002F `\u002Fhandoff` | Creates handoff document |\n| \"resume work\" | Loads latest handoff |\n\n---\n\n### Math System\n\nTwo capabilities: **computation** (SymPy, Z3, Pint) and **formal verification** (Lean4 + Mathlib).\n\n#### The Stack\n\n| Tool | Purpose | Example |\n|------|---------|---------|\n| **SymPy** | Symbolic math | Solve equations, integrals, matrix operations |\n| **Z3** | Constraint solving | Prove inequalities, SAT problems |\n| **Pint** | Unit conversion | Convert miles to km, dimensional analysis |\n| **Lean4** | Formal proofs | Machine-verified theorems |\n| **Mathlib** | 100K+ theorems | Pre-formalized lemmas to build on |\n| **Loogle** | Type-aware search | Find Mathlib lemmas by signature |\n\n#### Two Entry Points\n\n| Skill | Use When |\n|-------|----------|\n| `\u002Fmath` | Computing, solving, calculating |\n| `\u002Fprove` | Formal verification, machine-checked proofs |\n\n#### \u002Fmath Examples\n\n```bash\n# Solve equation\n\"Solve x² - 4 = 0\"  →  x = ±2\n\n# Compute eigenvalues\n\"Eigenvalues of [[2,1],[1,2]]\"  →  {1: 1, 3: 1}\n\n# Prove inequality\n\"Is x² + y² ≥ 2xy always true?\"  →  PROVED (equals (x-y)²)\n\n# Convert units\n\"26.2 miles to km\"  →  42.16 km\n```\n\n#### \u002Fprove - Formal Verification\n\n5-phase workflow for machine-verified proofs:\n\n```\n📚 RESEARCH → 🏗️ DESIGN → 🧪 TEST → ⚙️ IMPLEMENT → ✅ VERIFY\n```\n\n1. **Research**: Search Mathlib with Loogle, find proof strategy\n2. **Design**: Create skeleton with `sorry` placeholders\n3. **Test**: Search for counterexamples before proving\n4. **Implement**: Fill sorries with compiler-in-the-loop feedback\n5. **Verify**: Audit axioms, confirm zero sorries\n\n```\n\u002Fprove every group homomorphism preserves identity\n\u002Fprove continuous functions on compact sets are uniformly continuous\n```\n\n**Achievement**: Used to create the first Lean formalization of the Sylvester-Gallai theorem.\n\n#### Prerequisites (Optional)\n\nMath features require installation via wizard step 9:\n\n```bash\n# Installed automatically by wizard\nuv pip install sympy z3-solver pint shapely\n\n# Lean4 (for \u002Fprove)\ncurl https:\u002F\u002Fraw.githubusercontent.com\u002Fleanprover\u002Felan\u002Fmaster\u002Felan-init.sh -sSf | sh\n```\n\n---\n\n## Workflows\n\n### \u002Fworkflow - Goal-Based Router\n\n```\n> \u002Fworkflow\n\n? What's your goal?\n  ○ Research - Understand codebase\u002Fdocs\n  ○ Plan - Design implementation approach\n  ○ Build - Implement features\n  ○ Fix - Investigate and resolve issues\n```\n\n### \u002Ffix - Bug Resolution\n\n```bash\n\u002Ffix bug \"login fails silently\"\n```\n\n**Chain:** sleuth → [checkpoint] → [premortem] → kraken → test → commit\n\n| Scope | What it does |\n|-------|--------------|\n| `bug` | General bug investigation |\n| `hook` | Hook-specific debugging |\n| `deps` | Dependency issues |\n| `pr-comments` | Address PR feedback |\n\n### \u002Fbuild - Feature Development\n\n```bash\n\u002Fbuild greenfield \"user dashboard\"\n```\n\n**Chain:** discovery → plan → validate → implement → commit → PR\n\n| Mode | What it does |\n|------|--------------|\n| `greenfield` | New feature from scratch |\n| `brownfield` | Modify existing codebase |\n| `tdd` | Test-first development |\n| `refactor` | Safe code transformation |\n\n### \u002Fpremortem - Risk Analysis\n\n```bash\n\u002Fpremortem deep thoughts\u002Fshared\u002Fplans\u002Ffeature-x.md\n```\n\n**Output:**\n- **TIGERS**: Clear threats (HIGH\u002FMEDIUM\u002FLOW severity)\n- **ELEPHANTS**: Unspoken concerns\n\nBlocks on HIGH severity until user accepts\u002Fmitigates risks.\n\n---\n\n## Installation\n\n### Full Installation (Recommended)\n\n```bash\n# Clone\ngit clone https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fcontinuous-claude.git\ncd continuous-claude\u002Fopc\n\n# Run the setup wizard\nuv run python -m scripts.setup.wizard\n```\n\nThe wizard walks you through all configuration options interactively.\n\n## Updating\n\nPull latest changes and sync your installation:\n\n```bash\ncd continuous-claude\u002Fopc\nuv run python -m scripts.setup.update\n```\n\nThis will:\n- Pull latest from GitHub\n- Update hooks, skills, rules, agents\n- Upgrade TLDR if installed\n- Rebuild TypeScript hooks if changed\n\n### What Gets Installed\n\n| Component | Location |\n|-----------|----------|\n| Agents (32) | ~\u002F.claude\u002Fagents\u002F |\n| Skills (109) | ~\u002F.claude\u002Fskills\u002F |\n| Hooks (30) | ~\u002F.claude\u002Fhooks\u002F |\n| Rules | ~\u002F.claude\u002Frules\u002F |\n| Scripts | ~\u002F.claude\u002Fscripts\u002F |\n| PostgreSQL | Docker container |\n\n### Installation Mode: Copy vs Symlink\n\nThe wizard offers two installation modes:\n\n| Mode | How It Works | Best For |\n|------|--------------|----------|\n| **Copy** (default) | Copies files from repo to `~\u002F.claude\u002F` | End users, stable setup |\n| **Symlink** | Creates symlinks to repo files | Contributors, development |\n\n#### Copy Mode (Default)\n\nFiles are copied from `continuous-claude\u002F.claude\u002F` to `~\u002F.claude\u002F`. Changes you make in `~\u002F.claude\u002F` are **local only** and will be overwritten on next update.\n\n```text\ncontinuous-claude\u002F.claude\u002F  ──COPY──>  ~\u002F.claude\u002F\n     (source)                          (user config)\n```\n\n**Pros:** Stable, isolated from repo changes\n**Cons:** Local changes lost on update, manual sync needed\n\n#### Symlink Mode (Recommended for Contributors)\n\nCreates symlinks so `~\u002F.claude\u002F` points directly to repo files. Changes in either location affect the same files.\n\n```text\n~\u002F.claude\u002Frules  ──SYMLINK──>  continuous-claude\u002F.claude\u002Frules\n~\u002F.claude\u002Fskills ──SYMLINK──>  continuous-claude\u002F.claude\u002Fskills\n~\u002F.claude\u002Fhooks  ──SYMLINK──>  continuous-claude\u002F.claude\u002Fhooks\n~\u002F.claude\u002Fagents ──SYMLINK──>  continuous-claude\u002F.claude\u002Fagents\n```\n\n**Pros:**\n- Changes auto-sync to repo (can `git commit` improvements)\n- No re-installation needed after `git pull`\n- Contribute back easily\n\n**Cons:**\n- Breaking changes in repo affect your setup immediately\n- Need to manage git workflow\n\n#### Switching to Symlink Mode\n\nIf you installed with copy mode and want to switch:\n\n```bash\n# Backup current config\nmkdir -p ~\u002F.claude\u002Fbackups\u002F$(date +%Y%m%d)\ncp -r ~\u002F.claude\u002F{rules,skills,hooks,agents} ~\u002F.claude\u002Fbackups\u002F$(date +%Y%m%d)\u002F\n\n# Verify backup succeeded before proceeding\nls -la ~\u002F.claude\u002Fbackups\u002F$(date +%Y%m%d)\u002F\n\n# Remove copies (only after verifying backup above)\nrm -rf ~\u002F.claude\u002F{rules,skills,hooks,agents}\n\n# Create symlinks (adjust path to your repo location)\nREPO=\"$HOME\u002Fcontinuous-claude\"  # or wherever you cloned\nln -s \"$REPO\u002F.claude\u002Frules\" ~\u002F.claude\u002Frules\nln -s \"$REPO\u002F.claude\u002Fskills\" ~\u002F.claude\u002Fskills\nln -s \"$REPO\u002F.claude\u002Fhooks\" ~\u002F.claude\u002Fhooks\nln -s \"$REPO\u002F.claude\u002Fagents\" ~\u002F.claude\u002Fagents\n\n# Verify\nls -la ~\u002F.claude | grep -E \"rules|skills|hooks|agents\"\n```\n\n**Windows users:** Use PowerShell (as Administrator or with Developer Mode enabled):\n\n```powershell\n# Enable Developer Mode first (Settings → Privacy & security → For developers)\n# Or run PowerShell as Administrator\n\n# Backup current config\n$BackupDir = \"$HOME\\.claude\\backups\\$(Get-Date -Format 'yyyyMMdd')\"\nNew-Item -ItemType Directory -Path $BackupDir -Force\nCopy-Item -Recurse \"$HOME\\.claude\\rules\",\"$HOME\\.claude\\skills\",\"$HOME\\.claude\\hooks\",\"$HOME\\.claude\\agents\" $BackupDir\n\n# Verify backup succeeded before proceeding\nGet-ChildItem $BackupDir\n\n# Remove copies (only after verifying backup above)\nRemove-Item -Recurse \"$HOME\\.claude\\rules\",\"$HOME\\.claude\\skills\",\"$HOME\\.claude\\hooks\",\"$HOME\\.claude\\agents\"\n\n# Create symlinks (adjust path to your repo location)\n$REPO = \"$HOME\\continuous-claude\"  # or wherever you cloned\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\rules\" -Target \"$REPO\\.claude\\rules\"\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\skills\" -Target \"$REPO\\.claude\\skills\"\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\hooks\" -Target \"$REPO\\.claude\\hooks\"\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\agents\" -Target \"$REPO\\.claude\\agents\"\n\n# Verify\nGet-ChildItem \"$HOME\\.claude\" | Where-Object { $_.LinkType -eq \"SymbolicLink\" }\n```\n\n### For Brownfield Projects\n\nAfter installation, start Claude and run:\n```\n> \u002Fonboard\n```\n\nThis analyzes the codebase and creates an initial continuity ledger.\n\n---\n\n## Configuration\n\n### .claude\u002Fsettings.json\n\nCentral configuration for hooks, tools, and workflows.\n\n```json\n{\n  \"hooks\": {\n    \"SessionStart\": [...],\n    \"PreToolUse\": [...],\n    \"PostToolUse\": [...],\n    \"UserPromptSubmit\": [...]\n  }\n}\n```\n\n### .claude\u002Fskills\u002Fskill-rules.json\n\nSkill activation triggers.\n\n```json\n{\n  \"rules\": [\n    {\n      \"skill\": \"fix\",\n      \"keywords\": [\"fix this\", \"broken\", \"not working\"],\n      \"intentPatterns\": [\"fix.*(bug|issue|error)\"]\n    }\n  ]\n}\n```\n\n### Environment Variables\n\n| Variable | Purpose | Required |\n|----------|---------|----------|\n| `DATABASE_URL` | PostgreSQL connection string | Yes |\n| `BRAINTRUST_API_KEY` | Session tracing | No |\n| `PERPLEXITY_API_KEY` | Web search | No |\n| `NIA_API_KEY` | Documentation search | No |\n| `CLAUDE_OPC_DIR` | Path to CC's opc\u002F directory (set by wizard) | Auto |\n| `CLAUDE_PROJECT_DIR` | Current project directory (set by SessionStart hook) | Auto |\n\nServices without API keys still work:\n- Continuity system (ledgers, handoffs)\n- TLDR code analysis\n- Local git operations\n- TDD workflow\n\n---\n\n## Directory Structure\n\n```\ncontinuous-claude\u002F\n├── .claude\u002F\n│   ├── agents\u002F           # 32 specialized AI agents\n│   ├── hooks\u002F            # 30 lifecycle hooks\n│   │   ├── src\u002F          # TypeScript source\n│   │   └── dist\u002F         # Compiled JavaScript\n│   ├── skills\u002F           # 109 modular capabilities\n│   ├── rules\u002F            # System policies\n│   ├── scripts\u002F          # Python utilities\n│   └── settings.json     # Hook configuration\n├── opc\u002F\n│   ├── packages\u002F\n│   │   └── tldr-code\u002F    # 5-layer code analysis\n│   ├── scripts\u002F\n│   │   ├── setup\u002F        # Wizard, Docker, integration\n│   │   └── core\u002F         # recall_learnings, store_learning\n│   └── docker\u002F\n│       └── init-schema.sql  # 4-table PostgreSQL schema\n├── thoughts\u002F\n│   ├── ledgers\u002F          # Continuity ledgers (CONTINUITY_*.md)\n│   └── shared\u002F\n│       ├── handoffs\u002F     # Session handoffs (*.yaml)\n│       └── plans\u002F        # Implementation plans\n└── docs\u002F                 # Documentation\n```\n\n---\n\n## Contributing\n\nSee [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on:\n\n- Adding new skills\n- Creating agents\n- Developing hooks\n- Extending TLDR\n\n---\n\n## Acknowledgments\n\n### Patterns & Architecture\n- **[@numman-ali](https:\u002F\u002Fgithub.com\u002Fnumman-ali)** - Continuity ledger pattern\n- **[Anthropic](https:\u002F\u002Fanthropic.com)** - Claude Code and \"Code Execution with MCP\"\n- **[obra\u002Fsuperpowers](https:\u002F\u002Fgithub.com\u002Fobra\u002Fsuperpowers)** - Agent orchestration patterns\n- **[EveryInc\u002Fcompound-engineering-plugin](https:\u002F\u002Fgithub.com\u002FEveryInc\u002Fcompound-engineering-plugin)** - Compound engineering workflow\n- **[yoloshii\u002Fmcp-code-execution-enhanced](https:\u002F\u002Fgithub.com\u002Fyoloshii\u002Fmcp-code-execution-enhanced)** - Enhanced MCP execution\n- **[HumanLayer](https:\u002F\u002Fgithub.com\u002Fhumanlayer\u002Fhumanlayer)** - Agent patterns\n\n### Tools & Services\n- **[uv](https:\u002F\u002Fgithub.com\u002Fastral-sh\u002Fuv)** - Python packaging\n- **[tree-sitter](https:\u002F\u002Ftree-sitter.github.io\u002F)** - Code parsing\n- **[Braintrust](https:\u002F\u002Fbraintrust.dev)** - LLM evaluation, logging, and session tracing\n- **[qlty](https:\u002F\u002Fgithub.com\u002Fqltysh\u002Fqlty)** - Universal code quality CLI (70+ linters)\n- **[ast-grep](https:\u002F\u002Fgithub.com\u002Fast-grep\u002Fast-grep)** - AST-based code search and refactoring\n- **[Nia](https:\u002F\u002Ftrynia.ai)** - Library documentation search\n- **[Morph](https:\u002F\u002Fwww.morphllm.com)** - WarpGrep fast code search\n- **[Firecrawl](https:\u002F\u002Fwww.firecrawl.dev)** - Web scraping API\n- **[RepoPrompt](https:\u002F\u002Frepoprompt.com)** - Token-efficient codebase maps\n\n---\n\n## Star History\n\n[![Star History Chart](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fparcadei_Continuous-Claude-v3_readme_c118ae9679a8.png)](https:\u002F\u002Fstar-history.com\u002F#parcadei\u002FContinuous-Claude-v2&Date)\n\n---\n\n## License\n\n[MIT](LICENSE) - Use freely, contribute back.\n\n---\n\n**Continuous Claude**: Not just a coding assistant—a persistent, learning, multi-agent development environment that gets smarter with every session.\n","# 持续的克劳德\n\n> 基于 Claude Code 构建的持久化、可学习的多智能体开发环境\n\n[![许可证：MIT](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FLicense-MIT-blue.svg)](LICENSE)\n[![Claude Code](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FClaude-Code-orange.svg)](https:\u002F\u002Fclaude.ai\u002Fcode)\n[![技能（109）](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FSkills-109-green.svg)](#skills-system)\n[![智能体（32）](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FAgents-32-purple.svg)](#agents-system)\n[![钩子（30）](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FHooks-30-blue.svg)](#hooks-system)\n\n**持续的克劳德**将 Claude Code 转变为一个持续学习的系统，它能够在会话之间保持上下文一致性，协调专业化的智能体，并通过智能代码分析避免不必要的 token 消耗。\n\n## 目录\n\n- [为什么是持续的克劳德？](#why-continuous-claude)\n- [设计原则](#design-principles)\n- [如何与克劳德交流](#how-to-talk-to-claude)\n- [快速入门](#quick-start)\n- [架构](#architecture)\n- [核心系统](#core-systems)\n  - [技能（109）](#skills-system)\n  - [智能体（32）](#agents-system)\n  - [钩子（30）](#hooks-system)\n  - [TLDR 代码分析](#tldr-code-analysis)\n  - [记忆系统](#memory-system)\n  - [连续性系统](#continuity-system)\n  - [数学系统](#math-system)\n- [工作流](#workflows)\n- [安装](#installation)\n- [更新](#updating)\n- [配置](#configuration)\n- [贡献](#contributing)\n- [许可证](#license)\n\n---\n\n## 为什么是持续的克劳德？\n\nClaude Code 存在一个 **压缩问题**：当上下文填满时，系统会压缩你的对话，导致会话期间获得的细微理解与决策丢失。\n\n**持续的克劳德通过以下方式解决了这个问题：**\n\n| 问题 | 解决方案 |\n|---------|----------|\n| 压缩时上下文丢失 | YAML 手动交接——更节省 token 的传递方式 |\n| 每次会话都从头开始 | 记忆系统召回 + 守护进程自动提取学习成果 |\n| 读取整个文件会消耗大量 token | 5 层代码分析 + 语义索引 |\n| 复杂任务需要协调 | 元技能编排智能体工作流 |\n| 手动重复工作流 | 109 种技能，可通过自然语言触发 |\n\n**我们的信条：积累，而非压缩。** 自动提取学习成果，然后以完整的上下文重新开始。\n\n### 为什么叫“持续”？为什么叫“积累”？\n\n这个名字是一个双关语。“持续”是因为克劳德能够在会话之间保持状态；“积累”则是因为每次会话都会让系统变得更聪明——学习成果像复利一样不断累积。\n\n---\n\n## 设计原则\n\n一个智能体由五个要素组成：**提示 + 工具 + 上下文 + 记忆 + 模型**。\n\n| 组件 | 我们优化的内容 |\n|-----------|------------------|\n| **提示** | 技能注入相关上下文；钩子添加系统提醒 |\n| **工具** | TLDR 减少 token 使用；智能体并行处理工作 |\n| **上下文** | 不仅是克劳德知道什么，还有它是如何被提供的 |\n| **记忆** | 守护进程提取学习成果；召回功能将其呈现出来 |\n| **模型** | 当其他四个部分稳固时，模型可以灵活替换 |\n\n### 反复杂性\n\n我们抵制插件泛滥。你添加的每一个 MCP、订阅或工具都承诺带来改进，但同时也可能因冲突而破坏上下文、工具或提示。\n\n**我们的方法：**\n- **时间，而非金钱** — 无需付费服务。Perplexity 和 NIA 是可选的，但具有高性价比。\n- **学习，而非堆积** — 一个能够学习的系统比收集插件的系统更能处理边缘情况。\n- **左移验证** — 钩子在编辑后运行 pyright\u002Fruff，提前捕获错误，无需等待测试。\n\n复杂系统的故障模式在发生之前通常是不可见的。一个学习且上下文高效的系统并不能防止所有故障——但它能够恢复并不断改进。\n\n---\n\n## 如何与克劳德交流\n\n**你不需要记住任何斜杠命令。** 只需用自然语言描述你的需求即可。\n\n### 技能激活系统\n\n当你发送消息时，一个钩子会注入上下文，告诉 **克劳德** 哪些技能和智能体是相关的。克劳德会根据规则系统推断出应该使用哪些工具。\n\n```\n> “修复 auth.py 中的登录 bug”\n\n🎯 技能激活检查\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n⚠️ 关键技能（必需）：\n  → create_handoff\n\n📚 推荐技能：\n  → fix\n  → debug\n\n🤖 推荐智能体（节省 token）：\n  → debug-agent\n  → scout\n\n行动：在回复之前先使用技能工具\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n```\n\n### 优先级级别\n\n| 级别 | 含义 |\n|-------|---------|\n| ⚠️ **关键** | 必须使用（例如，在结束会话前进行交接） |\n| 📚 **推荐** | 应该使用（例如，工作流技能） |\n| 💡 **建议** | 可考虑使用（例如，优化工具） |\n| 📌 **可选** | 如果有更好（例如，文档助手） |\n\n### 自然语言示例\n\n| 你说什么 | 激活了什么 |\n|--------------|----------------|\n| “修复损坏的登录” | `\u002Ffix` 工作流 → debug-agent、scout |\n| “构建用户仪表盘” | `\u002Fbuild` 工作流 → plan-agent、kraken |\n| “我想了解这个代码库” | `\u002Fexplore` + scout 智能体 |\n| “这个计划可能会出现什么问题？” | `\u002Fpremortem` |\n| “帮我弄清楚我需要什么” | `\u002Fdiscovery-interview` |\n| “今天就到这里吧” | `create_handoff`（关键） |\n| “从我们上次中断的地方继续” | `resume_handoff` |\n| “研究认证模式” | oracle 智能体 + perplexity |\n| “查找这个 API 的所有用法” | scout 智能体 + ast-grep |\n\n### 为什么采用这种方法？\n\n| 优点 | 如何实现 |\n|---------|-----|\n| **更容易发现** | 无需知道有哪些命令存在 |\n| **上下文感知** | 系统知道你已经使用了 90% 的上下文 |\n| **降低认知负荷** | 自然描述意图，即可获得精选建议 |\n| **对高级用户友好** | 仍然支持直接使用 \u002Ffix、\u002Fbuild 等命令 |\n\n### 技能 vs 工作流 vs 智能体\n\n| 类型 | 目的 | 示例 |\n|------|---------|---------|\n| **技能** | 单一用途工具 | `commit`、`tldr-code`、`qlty-check` |\n| **工作流** | 多步骤流程 | `\u002Ffix`（sleuth → premortem → kraken → commit） |\n| **智能体** | 专门化的子会话 | scout（探索）、oracle（研究） |\n\n[查看详细的技能激活文档 →](docs\u002Fskill-activation.md)\n\n---\n\n## 快速入门\n\n### 先决条件\n\n- Python 3.11+\n- [uv](https:\u002F\u002Fgithub.com\u002Fastral-sh\u002Fuv) 包管理器\n- Docker（用于 PostgreSQL）\n- Claude Code CLI\n\n### 安装\n\n```bash\n# 克隆\ngit clone https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3.git\ncd Continuous-Claude-v3\u002Fopc\n\n# 运行设置向导（12 步）\nuv run python -m scripts.setup.wizard\n```\n\n> **注意：** `pyproject.toml` 文件位于 `opc\u002F` 目录下。请始终在 `opc\u002F` 目录中运行 `uv` 命令。\n\n### 向导执行的操作\n\n| 步骤 | 操作内容 |\n|------|----------|\n| 1 | 备份现有的 .claude\u002F 配置文件（如果存在） |\n| 2 | 检查前置条件（Docker、Python、uv） |\n| 3-5 | 数据库与 API 密钥配置 |\n| 6-7 | 启动 Docker 容器栈，执行数据库迁移 |\n| 8 | 安装 Claude Code 集成（32 个智能体、109 项技能、30 个钩子） |\n| 9 | 数学功能（SymPy、Z3、Pint - 可选） |\n| 10 | TLDR 代码分析工具 |\n| 11-12 | 诊断工具 + Loogle（可选） |\n\n\n#### 卸载方法：\n\n```\ncd Continuous-Claude-v3\u002Fopc\n  uv run python -m scripts.setup.wizard --uninstall\n```\n\n**操作内容**\n\n1. 归档当前设置 → 将 ~\u002F.claude 移至 ~\u002F.claude-v3.archived.\u003C时间戳>\n2. 恢复备份 → 查找最近的 ~\u002F.claude.backup.*（安装时创建），并将其恢复\n3. 保留用户数据 → 从归档中复制以下内容：\n\n  - history.jsonl（命令历史）\n  - mcp_config.json（MCP 服务器）\n  - .env（API 密钥）\n  - projects.json（项目配置）\n  - file-history\u002F 目录\n  - projects\u002F 目录\n4. 移除 CC-v3 的新增内容 → 其他所有内容（钩子、技能、智能体、规则）\n\n\n**安全特性**\n\n- 当前设置会按时间戳归档，不会删除任何内容\n- 向导会在继续操作前请求确认\n- 会从安装时创建的备份中恢复\n- 所有 Claude Code 设置将保持不变\n\n\n### 远程数据库设置\n\n默认情况下，CC-v3 通过 Docker 在本地运行 PostgreSQL。对于远程数据库设置：\n\n#### 1. 数据库准备\n\n```bash\n# 连接到您的远程 PostgreSQL 实例\npsql -h 主机名 -U 用户 -d continuous_claude\n\n# 启用 pgvector 扩展（需要超级用户或 rds_superuser）\nCREATE EXTENSION IF NOT EXISTS vector;\n\n# 应用模式（来自本地克隆）\npsql -h 主机名 -U 用户 -d continuous_claude -f docker\u002Finit-schema.sql\n```\n\n> **托管 PostgreSQL 使用提示：**\n> - **AWS RDS**：在数据库参数组中将 `vector` 添加到 `shared_preload_libraries`\n> - **Supabase**：通过数据库扩展页面启用\n> - **Azure Database**：使用扩展面板启用 pgvector\n\n#### 2. 连接配置\n\n在 `~\u002F.claude\u002Fsettings.json` 中设置 `CONTINUOUS_CLAUDE_DB_URL`：\n\n```json\n{\n  \"env\": {\n    \"CONTINUOUS_CLAUDE_DB_URL\": \"postgresql:\u002F\u002F用户:密码@主机名:5432\u002Fcontinuous_claude\"\n  }\n}\n```\n\n或者在运行 Claude 之前导出环境变量：\n\n```bash\nexport CONTINUOUS_CLAUDE_DB_URL=\"postgresql:\u002F\u002F用户:密码@主机名:5432\u002Fcontinuous_claude\"\nclaude\n```\n\n请参阅 `.env.example` 文件以获取所有可用的环境变量。\n\n### 第一次会话\n\n```bash\n# 启动 Claude Code\nclaude\n\n# 尝试一个工作流\n> \u002Fworkflow\n```\n\n### 第一次会话常用命令\n\n| 命令 | 功能 |\n|---------|--------------|\n| `\u002Fworkflow` | 基于目标的路由（研究\u002F计划\u002F构建\u002F修复） |\n| `\u002Ffix bug \u003C描述>` | 调查并修复错误 |\n| `\u002Fbuild greenfield \u003C功能>` | 从零开始构建新功能 |\n| `\u002Fexplore` | 理解代码库 |\n| `\u002Fpremortem` | 实施前的风险分析 |\n\n---\n\n## 架构\n\n```\n┌─────────────────────────────────────────────────────────────────────┐\n│                        CONTINUOUS CLAUDE                            │\n├─────────────────────────────────────────────────────────────────────┤\n│                                                                     │\n│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │\n│  │   Skills    │    │   Agents    │    │    Hooks    │             │\n│  │   (109)     │───▶│    (32)     │◀───│    (30)     │             │\n│  └─────────────┘    └─────────────┘    └─────────────┘             │\n│         │                  │                  │                     │\n│         ▼                  ▼                  ▼                     │\n│  ┌─────────────────────────────────────────────────────────────┐   │\n│  │                     TLDR 代码分析                       │   │\n│  │   L1:AST → L2:CallGraph → L3:CFG → L4:DFG → L5:Slicing      │   │\n│  │                    （节省 95% 的 token）                       │   │\n│  └─────────────────────────────────────────────────────────────┘   │\n│         │                  │                  │                     │\n│         ▼                  ▼                  ▼                     │\n│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │\n│  │   Memory    │    │ Continuity  │    │ Coordination│             │\n│  │   System    │    │   Ledgers   │    │    Layer    │             │\n│  └─────────────┘    └─────────────┘    └─────────────┘             │\n│                                                                     │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n### 数据流：会话生命周期\n\n```\n会话开始                    工作                      会话结束\n    │                              │                             │\n    ▼                              ▼                             ▼\n┌─────────┐                  ┌─────────┐                   ┌─────────┐\n│  加载   │                  │  跟踪  │                   │  保存   │\n│ 上下文  │─────────────────▶│ 更改    │──────────────────▶│  状态  │\n└─────────┘                  └─────────┘                   └─────────┘\n    │                              │                             │\n    ├── 连续性账本          ├── 文件声明               ├── 移交\n    ├── 记忆回溯              ├── TLDR 索引              ├── 经验总结\n    └── 符号索引               └── 黑板                 └── 结果\n                                         │\n                                         ▼\n                                    ┌─────────┐\n                                    │ \u002Fclear  │\n                                    │ 清新    │\n                                    │ 上下文  │\n                                    └─────────┘\n```\n\n### 连续性循环（详细）\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                            连续性循环                              │\n└─────────────────────────────────────────────────────────────────────────────┘\n\n  1. 会话开始                     2. 工作中\n  ┌────────────────────┐               ┌────────────────────┐\n  │                    │               │                    │\n  │  分类账加载 ────┼──▶ 上下文    │  工具使用后 ──────┼──▶ 索引交接\n  │  交接内容加载    │               │  用户提示 ───────┼──▶ 技能提示\n  │  记忆调用        │               │  编辑跟踪 ────┼──▶ 脏标记++\n  │  TLDR 缓存预热   │               │  子代理停止 ─────┼──▶ 代理汇报\n  │                    │               │                    │\n  └────────────────────┘               └────────────────────┘\n           │                                    │\n           │                                    ▼\n           │                           ┌────────────────────┐\n           │                           │ 3. 预压缩     │\n           │                           │                    │\n           │                           │  自动交接 ─────┼──▶ 思考\u002F共享\u002F\n           │                           │  (YAML 格式)     │    交接\u002F*.yaml\n           │                           │  脏标记 > 20? ─────┼──▶ TLDR 重新索引\n           │                           │                    │\n           │                           └────────────────────┘\n           │                                    │\n           │                                    ▼\n           │                           ┌────────────────────┐\n           │                           │ 4. 会话结束     │\n           │                           │                    │\n           │                           │  过期心跳 ──┼──▶ 守护进程唤醒\n           │                           │  守护进程启动 ────┼──▶ 无头Claude\n           │                           │  思考阻塞 ──┼──▶ 归档内存\n           │                           │                    │\n           │                           └────────────────────┘\n           │                                    │\n           │                                    │\n           └──────────────◀────── \u002Fclear ◀──────┘\n                          新鲜上下文 + 状态保留\n```\n\n### 工作流链条\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                           元技能工作流                              │\n└─────────────────────────────────────────────────────────────────────────────┘\n\n  \u002F修复 bug                              \u002F构建新项目\n  ─────────                             ─────────────────\n  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐\n  │  探秘者  │─▶│  事前分析│            │发现阶段 │─▶│计划代理│\n  │(诊断)    │  │  (风险)  │            │(澄清)    │  │ (设计)  │\n  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘\n                     │                                      │\n                     ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  巨兽  │                          │ 验证阶段 │\n              │  (修复)   │                          │ (检查)  │\n              └────┬─────┘                          └────┬─────┘\n                   │                                      │\n                   ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  调解员 │                          │  巨兽  │\n              │ (测试)   │                          │(实施│\n              └────┬─────┘                          └────┬─────┘\n                   │                                      │\n                   ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  提交  │                          │  提交  │\n              └──────────┘                          └──────────┘\n\n\n  \u002F测试驱动开发                                  \u002F重构\n  ────                                  ─────────\n  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐\n  │计划代理│─▶│  调解员 │            │ 凤凰重生 │─▶│  监管者  │\n  │ (设计) │  │(测试 🔴)│            │(分析)    │  │ (评审)  │\n  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘\n                     │                                      │\n                     ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  巨兽  │                          │  巨兽  │\n              │(代码 🟢) │                          │(转换│\n              └────┬─────┘                          └────┬─────┘\n                   │                                      │\n                   ▼                                      ▼\n              ┌──────────┐                          ┌──────────┐\n              │  调解员 │                          │  法官   │\n              │(验证 ✓)│                          │ (评审) │\n              └──────────┘                          └──────────┘\n```\n\n### 数据层架构\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                           数据层架构                            │\n├─────────────────────────────────────────────────────────────────────────────┤\n│                                                                             │\n│  TLDR 5层代码分析              语义索引                     │\n│  ┌────────────────────────┐              ┌────────────────────────┐         │\n│  │ L1: 抽象语法树 (~500 词)     │              │ BGE-large-en-v1.5      │         │\n│  │     └── 函数、     │              │ ├── 全部5层       │         │\n│  │         类、签名  │              │ ├── 10行上下文   │         │\n│  │                        │              │ └── FAISS索引        │         │\n│  │ L2: 调用图 (+440)  │              │                        │         │\n│  │     └── 跨文件     │──────────────│ 查询: \"auth逻辑\"    │         │\n│  │         依赖关系   │              │ 返回: 排序后的函数  │         │\n│  │                        │              └────────────────────────┘         │\n│  │ L3: 控制流图 (+110 词)     │                                                 │\n│  │     └── 控制流     │                                                 │\n│  │                        │              内存 (PostgreSQL+pgvector)       │\n│  │ L4: 数据流图 (+130 词)     │              ┌────────────────────────┐         │\n│  │     └── 数据流     │              │ sessions (心跳)   │         │\n│  │                        │              │ file_claims (锁)    │         │\n│  │ L5: 程序依赖图 (+150 词)     │              │ archival_memory (BGE)  │         │\n│  │     └── 切片        │              │ handoffs (嵌入)  │         │\n│  └────────────────────────┘              └────────────────────────┘         │\n│         ~1,200词                                                       │\n│         vs 23,000原始                                                       │\n│         = 95%节省                    文件系统                        │\n│                                          ┌────────────────────────┐         │\n│                                          │ thoughts\u002F              │         │\n│                                          │ ├── ledgers\u002F           │         │\n│                                          │ │   └── CONTINUITY_*.md│         │\n│                                          │ └── shared\u002F            │         │\n│                                          │     ├── handoffs\u002F*.yaml│         │\n│                                          │     └── plans\u002F*.md     │         │\n│                                          │                        │         │\n│                                          │ .tldr\u002F                 │         │\n│                                          │ └── (守护进程缓存)     │         │\n│                                          └────────────────────────┘         │\n│                                                                             │\n└─────────────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 核心系统\n\n### 技能系统\n\n技能是通过自然语言触发的模块化能力。位于 `.claude\u002Fskills\u002F` 目录下。\n\n#### 元技能（工作流编排器）\n\n| 元技能 | 链式流程 | 使用场景 |\n|----------|----------|----------|\n| `\u002Fworkflow` | 路由器 → 适当的工作流 | 不知道从何开始 |\n| `\u002Fbuild` | 发现 → 计划 → 验证 → 实现 → 提交 | 构建功能 |\n| `\u002Ffix` | 神探 → 事前分析 → 克拉肯 → 测试 → 提交 | 修复 bug |\n| `\u002Ftdd` | 计划 → 调解者（测试）→ 克拉肯（实现）→ 调解者 | 测试驱动开发 |\n| `\u002Frefactor` | 凤凰 → 计划 → 克拉肯 → 审查者 → 调解者 | 安全的代码重构 |\n| `\u002Freview` | 并行的专业评审 → 综合 | 代码审查 |\n| `\u002Fexplore` | 探路者（快速\u002F深入\u002F架构） | 理解代码库 |\n| `\u002Fsecurity` | 漏洞扫描 → 验证 | 安全审计 |\n| `\u002Frelease` | 审计 → 端到端测试 → 审查 → 更改日志 | 发布版本 |\n\n#### 元技能参考\n\n每个元技能支持模式、范围和标志。单独输入技能名称（如 `\u002Fbuild`）即可进入交互式问题流程。\n\n**`\u002Fbuild \u003Cmode> [options] [description]`**\n\n| 模式 | 链式流程 | 使用场景 |\n|------|----------|----------|\n| `greenfield` | 发现 → 计划 → 验证 → 实现 → 提交 → PR | 从零开始的新功能 |\n| `brownfield` | 上手 → 研究 → 计划 → 验证 → 实现 | 现有代码库中的功能 |\n| `tdd` | 计划 → 测试先行 → 实现 | 测试驱动开发 |\n| `refactor` | 影响分析 → 计划 → TDD → 实现 | 安全的重构 |\n\n| 选项 | 效果 |\n|--------|--------|\n| `--skip-discovery` | 跳过访谈阶段（已有清晰规格） |\n| `--skip-validate` | 跳过计划验证 |\n| `--skip-commit` | 不自动提交 |\n| `--skip-pr` | 不创建 PR 描述 |\n| `--parallel` | 并行运行研究代理 |\n\n**`\u002Ffix \u003Cscope> [options] [description]`**\n\n| 范围 | 链式流程 | 使用场景 |\n|-------|----------|---------|\n| `bug` | 调试 → 实现 → 测试 → 提交 | 一般 bug 修复 |\n| `hook` | 调试钩子 → 钩子开发者 → 实现 → 测试 | 钩子相关问题 |\n| `deps` | 预检 → 占卜者 → 计划 → 实现 → 质量 | 依赖项错误 |\n| `pr-comments` | GitHub 搜索 → 研究 → 计划 → 实现 → 提交 | PR 反馈 |\n\n| 选项 | 效果 |\n|--------|--------|\n| `--no-test` | 跳过回归测试 |\n| `--dry-run` | 仅诊断，不修复 |\n| `--no-commit` | 不自动提交 |\n\n**`\u002Fexplore \u003Cdepth> [options]`**\n\n| 深度 | 时间 | 功能 |\n|-------|------|--------------|\n| `quick` | ~1 分钟 | TLDR 树 + 结构概览 |\n| `deep` | ~5 分钟 | 上手 + TLDR + 研究 + 文档 |\n| `architecture` | ~3 分钟 | TLDR 架构 + 调用图 + 层次 |\n\n| 选项 | 效果 |\n|--------|--------|\n| `--focus \"area\"` | 专注于特定区域（例如 `--focus \"auth\"`） |\n| `--output handoff` | 为实施创建交接文档 |\n| `--output doc` | 创建文档文件 |\n| `--entry \"func\"` | 从特定入口点开始 |\n\n**`\u002Ftdd`、`\u002Frefactor`、`\u002Freview`、`\u002Fsecurity`、`\u002Frelease`**\n\n这些技能遵循其定义的链式流程，无需模式标志。只需运行：\n```\n\u002Ftdd \"implement retry logic\"\n\u002Frefactor \"extract auth module\"\n\u002Freview                           # 审查当前更改\n\u002Fsecurity \"authentication code\"\n\u002Frelease v1.2.0\n```\n\n#### 关键技能（高价值工具）\n\n**规划与风险**\n- **premortem**: TIGERS & ELEPHANTS 风险分析 - 在任何重大实施前使用\n- **discovery-interview**: 将模糊想法转化为详细规格\n\n**上下文管理**\n- **create_handoff**: 捕捉会话状态以便传递\n- **resume_handoff**: 从交接中恢复上下文\n- **continuity_ledger**: 跟踪会话内的状态\n\n**代码分析（节省 95% 的 token）**\n- **tldr-code**: 调用图、CFG、DFG、切片\n- **ast-grep-find**: 结构化代码搜索\n- **morph-search**: 快速文本搜索（比 grep 快 20 倍）\n\n**研究**\n- **perplexity-search**: AI 驱动的网页搜索\n- **nia-docs**: 库文档搜索\n- **github-search**: 搜索 GitHub 代码\u002F问题\u002FPR\n\n**质量**\n- **qlty-check**: 70 多种 linter 和自动修复工具\n- **braintrust-analyze**: 会话分析、回放以及调试失败会话\n\n**数学与形式证明**\n- **math**: 统一计算（SymPy、Z3、Pint）— 所有数学运算的统一入口\n- **prove**: Lean4 定理证明，采用五阶段流程（研究 → 设计 → 测试 → 实施 → 验证）\n- **pint-compute**: 支持单位的算术和转换\n- **shapely-compute**: 计算几何\n\n`\u002Fprove` 技能可在无需学习 Lean 语法的情况下实现机器验证的证明。曾用于创建 Sylvester-Gallai 定理的首个 Lean 形式化证明。\n\n#### 思考过程\n\n```\n我想做什么？\n├── 不知道 → \u002Fworkflow（引导式路由器）\n├── 构建 → \u002Fbuild greenfield 或 brownfield\n├── 修复 → \u002Ffix bug\n├── 理解 → \u002Fexplore\n├── 规划 → 先进行事前分析，再使用计划代理\n├── 研究 → 使用占卜者或 perplexity-search\n├── 审查 → \u002Freview\n├── 证明 → \u002Fprove（Lean4 形式验证）\n├── 计算 → \u002Fmath（SymPy、Z3、Pint）\n└── 发布 → \u002Frelease\n```\n\n[查看详细的技能分解 →](docs\u002Fskills\u002F)\n\n---\n\n### 代理系统\n\n代理是通过任务工具生成的专用 AI 工作人员。位于 `.claude\u002Fagents\u002F` 目录下。\n\n#### 代理类别（32 个活跃）\n\n> **注意:** 代理数量可能过多——整合是 v4 版本的目标。请根据您的工作流程选择合适的代理。\n\n**编排者（2 个）**\n- **maestro**: 多代理协调，支持管道、蜂群、陪审团等模式\n- **kraken**: TDD 实现代理，支持检查点和恢复功能\n\n**规划者（4 个）**\n- **architect**: 功能规划 + API 集成\n- **phoenix**: 重构 + 框架迁移规划\n- **plan-agent**: 轻量级规划，配备研究\u002FMCP 工具\n- **validate-agent**: 根据最佳实践验证计划\n\n**探索者（4 个）**\n- **scout**: 代码库探索（可替代 Explore 使用）\n- **oracle**: 外部研究（网络、文档、API）\n- **pathfinder**: 外部仓库分析\n- **research-codebase**: 对现有代码库进行文档化\n\n**实施者（3 个）**\n- **kraken**: TDD 实施，严格遵循测试先行流程\n- **spark**: 轻量级修复和快速调整\n- **agentica-agent**: 使用 Agentica SDK 构建 Python 代理\n\n**调试者（3 个）**\n- **sleuth**: 通用 bug 调查及根因分析\n- **debug-agent**: 通过日志\u002F代码搜索调查问题\n- **profiler**: 性能分析及竞态条件排查\n\n**验证者（2 个）** - arbiter、atlas\n\n**审查者（6 个）** - critic、judge、surveyor、liaison、plan-reviewer、review-agent\n\n**专业代理（8 个）** - aegis、herald、scribe、chronicler、session-analyst、braintrust-analyst、memory-extractor、onboard\n\n#### 常见工作流程\n\n| 工作流程 | 代理链 |\n|----------|-------------|\n| 功能 | architect → plan-reviewer → kraken → review-agent → arbiter |\n| 重构 | phoenix → plan-reviewer → kraken → judge → arbiter |\n| Bug 修复 | sleuth → spark\u002Fkraken → arbiter → scribe |\n\n[查看详细的代理指南 →](docs\u002Fagents\u002F)\n\n### 钩子系统\n\n钩子在 Claude Code 的生命周期关键点进行拦截。钩子位于 `.claude\u002Fhooks\u002F` 目录下。\n\n#### 钩子事件（共 30 个钩子）\n\n| 事件 | 关键钩子 | 用途 |\n|-------|-----------|---------|\n| **会话开始** | session-start-continuity, session-register, braintrust-tracing | 加载上下文，注册会话 |\n| **工具使用前** | tldr-read-enforcer, smart-search-router, tldr-context-inject, file-claims | 节省 token，搜索路由 |\n| **工具使用后** | post-edit-diagnostics, handoff-index, post-edit-notify | 验证、索引 |\n| **压缩前** | pre-compact-continuity | 压缩前自动保存 |\n| **用户提示提交** | skill-activation-prompt, memory-awareness | 技能提示，记忆召回 |\n| **子代理停止** | subagent-stop-continuity | 保存子代理状态 |\n| **会话结束** | session-end-cleanup, session-outcome | 清理，提取学习成果 |\n\n#### 关键钩子\n\n| 钩子 | 用途 |\n|------|---------|\n| **tldr-context-inject** | 将代码分析添加到代理提示中 |\n| **smart-search-router** | 在适当情况下将 grep 路由到 AST-grep |\n| **post-edit-diagnostics** | 编辑后运行 pyright\u002Fruff |\n| **memory-awareness** | 展示相关学习内容 |\n\n[查看全部 30 个钩子 →](docs\u002Fhooks\u002F)\n\n---\n\n### TLDR 代码分析\n\nTLDR 通过 5 层分析提供节省 token 的代码摘要。\n\n#### 五层堆栈\n\n| 层 | 名称 | 提供的内容 | Token 数量 |\n|-------|------|------------------|--------|\n| **L1** | AST | 函数、类、签名 | ~500 tokens |\n| **L2** | 调用图 | 谁调用了什么（跨文件） | +440 tokens |\n| **L3** | CFG | 控制流、复杂度 | +110 tokens |\n| **L4** | DFG | 数据流、变量追踪 | +130 tokens |\n| **L5** | PDG | 程序切片、影响分析 | +150 tokens |\n\n**总计：约 1,200 tokens 对比原始的 23,000 tokens = 节省 95%**\n\n#### CLI 命令\n\n```bash\n# 结构分析\ntldr tree src\u002F                      # 文件树\ntldr structure src\u002F --lang python   # 代码结构（codemaps）\n\n# 搜索与提取\ntldr search \"process_data\" src\u002F     # 查找代码\ntldr context process_data --project src\u002F --depth 2  # LLM 可用的上下文\n\n# 流分析\ntldr cfg src\u002Fmain.py main           # 控制流图\ntldr dfg src\u002Fmain.py main           # 数据流图\ntldr slice src\u002Fmain.py main 42      # 哪些内容影响第 42 行？\n\n# 代码库分析\ntldr impact process_data src\u002F       # 哪些地方调用了这个函数？\ntldr dead src\u002F                      # 查找不可达代码\ntldr arch src\u002F                      # 检测架构层\n\n# 语义搜索（自然语言）\ntldr daemon semantic \"find authentication logic\"\n```\n\n#### 语义索引\n\n除了结构分析外，TLDR 还构建了代码库的 **语义索引**：\n\n- **自然语言查询** — 可以问“错误处理在哪里？”而不是直接 grep\n- **自动重建** — 使用脏标记钩子跟踪文件变化；每 N 次编辑后重建索引\n- **选择性索引** — 使用 `.tldrignore` 控制哪些内容被索引\n\n```bash\n# .tldrignore 示例\n__pycache__\u002F\n*.test.py\nnode_modules\u002F\n.venv\u002F\n```\n\n语义索引使用所有 5 层以及每段代码周围的 10 行上下文——而不仅仅是文档字符串。\n\n#### 钩子集成\n\nTLDR 通过钩子自动集成：\n\n- **tldr-read-enforcer**：返回 L1+L2+L3 而不是完整文件读取\n- **smart-search-router**：将 Grep 路由到 `tldr search`\n- **post-tool-use-tracker**：当文件更改时更新索引\n\n[查看 TLDR 文档 →](opc\u002Fpackages\u002Ftldr-code\u002F)\n\n---\n\n### 内存系统\n\n基于 PostgreSQL + pgvector 的跨会话学习功能。\n\n#### 工作原理\n\n```\n会话结束 → 数据库检测到心跳过期（超过 5 分钟）\n            → 守护进程启动无头 Claude（Sonnet）\n            → 分析会话中的思考块\n            → 提取学习内容到 archival_memory\n            → 下一个会话召回相关学习内容\n```\n\n关键洞察是：**思考块包含了真正的推理过程**——不仅是 Claude 做了什么，还有为什么这么做。守护进程会自动提取这些内容。\n\n#### 对话式界面\n\n| 你说什么 | 发生什么 |\n|--------------|--------------|\n| “记住认证使用 JWT” | 存储带有上下文的学习内容 |\n| “回忆认证模式” | 搜索内存，显示匹配结果 |\n| “我们对 X 达成了什么共识？” | 通过 memory-awareness 钩子隐式召回 |\n\n#### 数据库表结构（4 张表）\n\n| 表 | 用途 |\n|-------|---------|\n| **sessions** | 跨终端感知 |\n| **file_claims** | 跨终端文件锁定 |\n| **archival_memory** | 长期学习内容，附带 BGE 嵌入 |\n| **handoffs** | 会话交接，附带嵌入 |\n\n#### 召回命令\n\n```bash\n# 召回学习内容（文本与向量混合搜索）\ncd opc && uv run python scripts\u002Fcore\u002Frecall_learnings.py \\\n    --query \"authentication patterns\"\n\n# 显式存储学习内容\ncd opc && uv run python scripts\u002Fcore\u002Fstore_learning.py \\\n    --session-id \"my-session\" \\\n    --type WORKING_SOLUTION \\\n    --content \"我学到的内容\" \\\n    --confidence high\n```\n\n#### 自动记忆\n\n**memory-awareness** 钩子会在你发送消息时自动展示相关学习内容。你会看到 `MEMORY MATCH` 标记——Claude 可以在你未要求的情况下使用这些内容。\n\n---\n\n### 连续性系统\n\n在上下文清除和会话之间保持状态。\n\n#### 连续性账本\n\n会话内状态跟踪。位置：`thoughts\u002Fledgers\u002FCONTINUITY_\u003Ctopic>.md`\n\n```markdown\n# 会话：feature-x\n更新时间：2026-01-08\n\n## 目标\n实现 feature X，并加入适当的错误处理\n\n## 已完成\n- [x] 设计了 API 模式\n- [x] 实现了核心逻辑\n\n## 进行中\n- [ ] 添加错误处理\n\n## 阻碍因素\n- 需要澄清重试策略\n```\n\n#### 交接\n\n会话之间的知识传递。位置：`thoughts\u002Fshared\u002Fhandoffs\u002F\u003Csession>\u002F`\n\n```yaml\n---\ndate: 2026-01-08T15:26:01+0000\nsession_name: feature-x\nstatus: complete\n---\n\n# 交接：Feature X 实现\n\n## 任务\n| 任务 | 状态 |\n|------|--------|\n| 设计 API | 完成 |\n| 实现核心 | 完成 |\n| 错误处理 | 待定 |\n\n## 后续步骤\n1. 在 API 调用中加入重试逻辑\n2. 编写集成测试\n```\n\n#### 命令\n\n| 命令 | 效果 |\n|---------|--------|\n| “保存状态” | 更新连续性账本 |\n| “今天就到这里” \u002F `\u002Fhandoff` | 创建交接文档 |\n| “继续工作” | 加载最新的交接内容 |\n\n---\n\n### 数学系统\n\n具备两种能力：**计算**（SymPy、Z3、Pint）和**形式化验证**（Lean4 + Mathlib）。\n\n#### 技术栈\n\n| 工具       | 用途               | 示例                                   |\n|------------|--------------------|----------------------------------------|\n| **SymPy**  | 符号计算           | 求解方程、积分、矩阵运算               |\n| **Z3**     | 约束求解           | 证明不等式、SAT问题                   |\n| **Pint**   | 单位换算           | 将英里转换为千米、量纲分析             |\n| **Lean4**  | 形式化证明         | 机器验证的定理                         |\n| **Mathlib**| 10万+ 定理         | 预先形式化的引理，可供进一步构建       |\n| **Loogle** | 类型感知搜索       | 根据签名查找 Mathlib 引理              |\n\n#### 两个入口点\n\n| 技能       | 使用场景           |\n|------------|--------------------|\n| `\u002Fmath`    | 计算、求解、数值运算 |\n| `\u002Fprove`   | 形式化验证、机器检查的证明 |\n\n#### `\u002Fmath` 示例\n\n```bash\n# 解方程\n\"Solve x² - 4 = 0\"  →  x = ±2\n\n# 计算特征值\n\"Eigenvalues of [[2,1],[1,2]]\"  →  {1: 1, 3: 1}\n\n# 证明不等式\n\"Is x² + y² ≥ 2xy always true?\"  →  PROVED (equals (x-y)²)\n\n# 单位换算\n\"26.2 miles to km\"  →  42.16 km\n```\n\n#### `\u002Fprove` - 形式化验证\n\n机器验证证明的五阶段流程：\n\n```\n📚 研究 → 🏗️ 设计 → 🧪 测试 → ⚙️ 实现 → ✅ 验证\n```\n\n1. **研究**：使用 Loogle 搜索 Mathlib，找到证明策略。\n2. **设计**：创建带有 `sorry` 占位符的框架。\n3. **测试**：在证明之前寻找反例。\n4. **实现**：在编译器反馈循环中填补 `sorry`。\n5. **验证**：审计公理，确认没有 `sorry`。\n\n```\n\u002Fprove every group homomorphism preserves identity\n\u002Fprove continuous functions on compact sets are uniformly continuous\n```\n\n**成就**：用于创建 Sylvester-Gallai 定理的第一个 Lean 形式化证明。\n\n#### 先决条件（可选）\n\n数学功能需要通过向导第9步安装：\n\n```bash\n# 向导自动安装\nuv pip install sympy z3-solver pint shapely\n\n# Lean4（用于 \u002Fprove）\ncurl https:\u002F\u002Fraw.githubusercontent.com\u002Fleanprover\u002Felan\u002Fmaster\u002Felan-init.sh -sSf | sh\n```\n\n---\n\n## 工作流\n\n### `\u002Fworkflow` - 基于目标的路由\n\n```\n> \u002Fworkflow\n\n? 你的目标是什么？\n  ○ Research - 理解代码库\u002F文档\n  ○ Plan - 设计实现方案\n  ○ Build - 实现功能\n  ○ Fix - 调查并解决问题\n```\n\n### `\u002Ffix` - Bug 修复\n\n```bash\n\u002Ffix bug \"login fails silently\"\n```\n\n**链路：** sleuth → [checkpoint] → [premortem] → kraken → test → commit\n\n| 范围       | 作用                 |\n|------------|----------------------|\n| `bug`      | 一般性 Bug 调查      |\n| `hook`     | 钩子特定调试         |\n| `deps`     | 依赖问题             |\n| `pr-comments` | 处理 PR 反馈        |\n\n### `\u002Fbuild` - 功能开发\n\n```bash\n\u002Fbuild greenfield \"user dashboard\"\n```\n\n**链路：** discovery → plan → validate → implement → commit → PR\n\n| 模式       | 作用                 |\n|------------|----------------------|\n| `greenfield` | 从零开始的新功能     |\n| `brownfield` | 修改现有代码库       |\n| `tdd`      | 测试驱动开发         |\n| `refactor` | 安全的代码重构       |\n\n### `\u002Fpremortem` - 风险分析\n\n```bash\n\u002Fpremortem deep thoughts\u002Fshared\u002Fplans\u002Ffeature-x.md\n```\n\n**输出：**\n- **TIGERS**：明确的威胁（高\u002F中\u002F低严重性）\n- **ELEPHANTS**：未言明的担忧\n\n对于高严重性的风险，需用户接受或缓解后方可继续。\n\n---\n\n## 安装\n\n### 完整安装（推荐）\n\n```bash\n# 克隆\ngit clone https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fcontinuous-claude.git\ncd continuous-claude\u002Fopc\n\n# 运行设置向导\nuv run python -m scripts.setup.wizard\n```\n\n向导会以交互方式引导您完成所有配置选项。\n\n## 更新\n\n拉取最新更改并同步您的安装：\n\n```bash\ncd continuous-claude\u002Fopc\nuv run python -m scripts.setup.update\n```\n\n这将：\n- 从 GitHub 拉取最新代码\n- 更新钩子、技能、规则、代理\n- 如果已安装，则升级 TLDR\n- 如果 TypeScript 钩子发生更改，则重新构建\n\n### 安装内容\n\n| 组件       | 位置                 |\n|------------|----------------------|\n| 代理（32个） | ~\u002F.claude\u002Fagents\u002F    |\n| 技能（109个） | ~\u002F.claude\u002Fskills\u002F    |\n| 钩子（30个） | ~\u002F.claude\u002Fhooks\u002F     |\n| 规则       | ~\u002F.claude\u002Frules\u002F     |\n| 脚本       | ~\u002F.claude\u002Fscripts\u002F   |\n| PostgreSQL | Docker 容器          |\n\n### 安装模式：复制 vs 符号链接\n\n向导提供两种安装模式：\n\n| 模式       | 工作原理             | 适用场景             |\n|------------|----------------------|----------------------|\n| **Copy**（默认） | 将文件从仓库复制到 `~\u002F.claude\u002F` | 最终用户、稳定设置   |\n| **Symlink** | 创建指向仓库文件的符号链接 | 贡献者、开发环境     |\n\n#### 复制模式（默认）\n\n文件从 `continuous-claude\u002F.claude\u002F` 复制到 `~\u002F.claude\u002F`。您在 `~\u002F.claude\u002F` 中所做的更改是**本地仅有的**，并在下次更新时被覆盖。\n\n```text\ncontinuous-claude\u002F.claude\u002F  ──COPY──>  ~\u002F.claude\u002F\n     (source)                          (user config)\n```\n\n**优点：** 稳定，与仓库更改隔离  \n**缺点：** 更新时本地更改丢失，需手动同步\n\n#### 符号链接模式（推荐给贡献者）\n\n创建符号链接，使 `~\u002F.claude\u002F` 直接指向仓库文件。无论在哪一侧进行更改，都会影响相同的文件。\n\n```bash\n~\u002F.claude\u002Frules  ──SYMLINK──>  continuous-claude\u002F.claude\u002Frules\n~\u002F.claude\u002Fskills ──SYMLINK──>  continuous-claude\u002F.claude\u002Fskills\n~\u002F.claude\u002Fhooks  ──SYMLINK──>  continuous-claude\u002F.claude\u002Fhooks\n~\u002F.claude\u002Fagents ──SYMLINK──>  continuous-claude\u002F.claude\u002Fagents\n```\n\n**优点：**\n- 更改会自动同步到仓库（可提交改进）\n- 不需要在 `git pull` 后重新安装\n- 轻松贡献回社区\n\n**缺点：**\n- 仓库中的重大变更会立即影响您的设置\n- 需要管理 Git 工作流\n\n#### 切换到符号链接模式\n\n如果您以复制模式安装并希望切换：\n\n```bash\n# 备份当前配置\nmkdir -p ~\u002F.claude\u002Fbackups\u002F$(date +%Y%m%d)\ncp -r ~\u002F.claude\u002F{rules,skills,hooks,agents} ~\u002F.claude\u002Fbackups\u002F$(date +%Y%m%d)\u002F\n\n# 在继续操作前确认备份成功\nls -la ~\u002F.claude\u002Fbackups\u002F$(date +%Y%m%d)\u002F\n\n# 移除副本（仅在确认上述备份后）\nrm -rf ~\u002F.claude\u002F{rules,skills,hooks,agents}\n\n# 创建符号链接（请根据您的仓库路径调整）\nREPO=\"$HOME\u002Fcontinuous-claude\"  # 或您克隆的位置\nln -s \"$REPO\u002F.claude\u002Frules\" ~\u002F.claude\u002Frules\nln -s \"$REPO\u002F.claude\u002Fskills\" ~\u002F.claude\u002Fskills\nln -s \"$REPO\u002F.claude\u002Fhooks\" ~\u002F.claude\u002Fhooks\nln -s \"$REPO\u002F.claude\u002Fagents\" ~\u002F.claude\u002Fagents\n\n# 验证\nls -la ~\u002F.claude | grep -E \"rules|skills|hooks|agents\"\n```\n\n**Windows 用户：** 使用 PowerShell（以管理员身份运行或启用开发者模式）：\n\n```powershell\n# 首先启用开发者模式（设置 → 隐私与安全 → 开发者选项）\n# 或以管理员身份运行 PowerShell\n\n# 备份当前配置\n$BackupDir = \"$HOME\\.claude\\backups\\$(Get-Date -Format 'yyyyMMdd')\"\nNew-Item -ItemType Directory -Path $BackupDir -Force\nCopy-Item -Recurse \"$HOME\\.claude\\rules\",\"$HOME\\.claude\\skills\",\"$HOME\\.claude\\hooks\",\"$HOME\\.claude\\agents\" $BackupDir\n\n# 在继续操作前确认备份成功\nGet-ChildItem $BackupDir\n\n# 移除副本（仅在确认备份后）\nRemove-Item -Recurse \"$HOME\\.claude\\rules\",\"$HOME\\.claude\\skills\",\"$HOME\\.claude\\hooks\",\"$HOME\\.claude\\agents\"\n\n# 创建符号链接（请根据你的仓库位置调整路径）\n$REPO = \"$HOME\\continuous-claude\"  # 或者你克隆代码库的任何位置\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\rules\" -Target \"$REPO\\.claude\\rules\"\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\skills\" -Target \"$REPO\\.claude\\skills\"\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\hooks\" -Target \"$REPO\\.claude\\hooks\"\nNew-Item -ItemType SymbolicLink -Path \"$HOME\\.claude\\agents\" -Target \"$REPO\\.claude\\agents\"\n\n# 验证\nGet-ChildItem \"$HOME\\.claude\" | Where-Object { $_.LinkType -eq \"SymbolicLink\" }\n```\n\n### 对于已有项目\n\n安装完成后，启动 Claude 并运行：\n```\n> \u002Fonboard\n```\n\n这将分析代码库并创建初始的连续性账本。\n\n---\n\n## 配置\n\n### .claude\u002Fsettings.json\n\n用于配置钩子、工具和工作流的中心化配置文件。\n\n```json\n{\n  \"hooks\": {\n    \"SessionStart\": [...],\n    \"PreToolUse\": [...],\n    \"PostToolUse\": [...],\n    \"UserPromptSubmit\": [...]\n  }\n}\n```\n\n### .claude\u002Fskills\u002Fskill-rules.json\n\n技能激活触发条件。\n\n```json\n{\n  \"rules\": [\n    {\n      \"skill\": \"fix\",\n      \"keywords\": [\"fix this\", \"broken\", \"not working\"],\n      \"intentPatterns\": [\"fix.*(bug|issue|error)\"]\n    }\n  ]\n}\n```\n\n### 环境变量\n\n| 变量 | 用途 | 是否必需 |\n|----------|---------|----------|\n| `DATABASE_URL` | PostgreSQL 连接字符串 | 是 |\n| `BRAINTRUST_API_KEY` | 会话追踪 | 否 |\n| `PERPLEXITY_API_KEY` | 网络搜索 | 否 |\n| `NIA_API_KEY` | 文档搜索 | 否 |\n| `CLAUDE_OPC_DIR` | CC 的 opc\u002F 目录路径（由向导设置） | 自动 |\n| `CLAUDE_PROJECT_DIR` | 当前项目目录（由 SessionStart 钩子设置） | 自动 |\n\n即使没有 API 密钥，以下服务仍然可以正常工作：\n- 连续性系统（账本、交接）\n- TLDR 代码分析\n- 本地 Git 操作\n- TDD 工作流\n\n---\n\n## 目录结构\n\n```\ncontinuous-claude\u002F\n├── .claude\u002F\n│   ├── agents\u002F           # 32 个专业化的 AI 代理\n│   ├── hooks\u002F            # 30 个生命周期钩子\n│   │   ├── src\u002F          # TypeScript 源代码\n│   │   └── dist\u002F         # 编译后的 JavaScript\n│   ├── skills\u002F           # 109 个模块化能力\n│   ├── rules\u002F            # 系统策略\n│   ├── scripts\u002F          # Python 工具脚本\n│   └── settings.json     # 钩子配置\n├── opc\u002F\n│   ├── packages\u002F\n│   │   └── tldr-code\u002F    # 5 层代码分析\n│   ├── scripts\u002F\n│   │   ├── setup\u002F        # 向导、Docker、集成\n│   │   └── core\u002F         # recall_learnings, store_learning\n│   └── docker\u002F\n│       └── init-schema.sql  # 4 表的 PostgreSQL 模式\n├── thoughts\u002F\n│   ├── ledgers\u002F          # 连续性账本（CONTINUITY_*.md）\n│   └── shared\u002F\n│       ├── handoffs\u002F     # 会话交接（*.yaml）\n│       └── plans\u002F        # 实施计划\n└── docs\u002F                 # 文档\n```\n\n---\n\n## 贡献\n\n请参阅 [CONTRIBUTING.md](CONTRIBUTING.md)，了解关于以下方面的指南：\n\n- 添加新技能\n- 创建代理\n- 开发钩子\n- 扩展 TLDR\n\n---\n\n## 致谢\n\n### 模式与架构\n- **[@numman-ali](https:\u002F\u002Fgithub.com\u002Fnumman-ali)** - 连续性账本模式\n- **[Anthropic](https:\u002F\u002Fanthropic.com)** - Claude Code 和“带有 MCP 的代码执行”\n- **[obra\u002Fsuperpowers](https:\u002F\u002Fgithub.com\u002Fobra\u002Fsuperpowers)** - 代理编排模式\n- **[EveryInc\u002Fcompound-engineering-plugin](https:\u002F\u002Fgithub.com\u002FEveryInc\u002Fcompound-engineering-plugin)** - 复合工程工作流\n- **[yoloshii\u002Fmcp-code-execution-enhanced](https:\u002F\u002Fgithub.com\u002Fyoloshii\u002Fmcp-code-execution-enhanced)** - 增强的 MCP 执行\n- **[HumanLayer](https:\u002F\u002Fgithub.com\u002Fhumanlayer\u002Fhumanlayer)** - 代理模式\n\n### 工具与服务\n- **[uv](https:\u002F\u002Fgithub.com\u002Fastral-sh\u002Fuv)** - Python 打包\n- **[tree-sitter](https:\u002F\u002Ftree-sitter.github.io\u002F)** - 代码解析\n- **[Braintrust](https:\u002F\u002Fbraintrust.dev)** - LLM 评估、日志记录和会话追踪\n- **[qlty](https:\u002F\u002Fgithub.com\u002Fqltysh\u002Fqlty)** - 通用代码质量 CLI（70 多种 linter）\n- **[ast-grep](https:\u002F\u002Fgithub.com\u002Fast-grep\u002Fast-grep)** - 基于 AST 的代码搜索和重构\n- **[Nia](https:\u002F\u002Ftrynia.ai)** - 库文档搜索\n- **[Morph](https:\u002F\u002Fwww.morphllm.com)** - WarpGrep 快速代码搜索\n- **[Firecrawl](https:\u002F\u002Fwww.firecrawl.dev)** - 网页抓取 API\n- **[RepoPrompt](https:\u002F\u002Frepoprompt.com)** - 高效的代码库映射\n\n---\n\n## 星标历史\n\n[![星标历史图](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fparcadei_Continuous-Claude-v3_readme_c118ae9679a8.png)](https:\u002F\u002Fstar-history.com\u002F#parcadei\u002FContinuous-Claude-v2&Date)\n\n---\n\n## 许可证\n\n[MIT](LICENSE) - 可自由使用，并欢迎贡献回社区。\n\n---\n\n**Continuous Claude**：不仅仅是一个编码助手——它是一个持久、可学习的多代理开发环境，每次会话都会变得更加智能。","# Continuous-Claude-v3 快速上手指南\n\nContinuous-Claude-v3 是一个基于 Claude Code 构建的持久化、可学习、多智能体开发环境。它通过自动提取会话记忆、协调专用智能体以及智能代码分析，解决了传统 AI 编程中上下文丢失和 Token 浪费的问题，让 Claude 具备跨会话的“复合增长”能力。\n\n## 环境准备\n\n在开始之前，请确保您的系统满足以下要求：\n\n*   **操作系统**: Linux, macOS 或 Windows (WSL2 推荐)\n*   **Python**: 版本 3.11 或更高\n*   **包管理器**: [uv](https:\u002F\u002Fgithub.com\u002Fastral-sh\u002Fuv) (高性能 Python 包安装器)\n*   **容器引擎**: Docker (用于运行本地 PostgreSQL 数据库)\n*   **核心工具**: 已安装并配置好 [Claude Code CLI](https:\u002F\u002Fclaude.ai\u002Fcode)\n\n> **提示**: 国内用户若遇到 `uv` 或 `git clone` 速度慢的问题，可配置国内镜像源或使用加速代理。\n\n## 安装步骤\n\n### 1. 克隆项目\n首先将仓库克隆到本地，并进入核心目录 `opc`（注意：所有后续命令均需在此目录下执行）。\n\n```bash\ngit clone https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3.git\ncd Continuous-Claude-v3\u002Fopc\n```\n\n### 2. 运行安装向导\n使用 `uv` 运行设置向导，该脚本将自动完成依赖检查、数据库配置及 Claude Code 集成。整个过程包含 12 个步骤。\n\n```bash\nuv run python -m scripts.setup.wizard\n```\n\n**向导主要执行操作：**\n1.  备份现有的 `.claude\u002F` 配置（如有）。\n2.  检查前置依赖（Docker, Python, uv）。\n3.  配置数据库及 API 密钥。\n4.  启动 Docker 栈并运行数据库迁移。\n5.  安装核心组件：32 个智能体 (Agents)、109 项技能 (Skills) 和 30 个钩子 (Hooks)。\n6.  （可选）安装数学功能模块及代码分析工具。\n\n### 3. 远程数据库配置（可选）\n默认情况下，系统通过 Docker 在本地运行 PostgreSQL。若需连接远程数据库（如 AWS RDS, Supabase 等）：\n\n1.  在远程数据库中启用 `pgvector` 扩展并导入 schema：\n    ```bash\n    psql -h hostname -U user -d continuous_claude -f docker\u002Finit-schema.sql\n    ```\n2.  在 `~\u002F.claude\u002Fsettings.json` 中配置连接字符串，或导出环境变量：\n    ```bash\n    export CONTINUOUS_CLAUDE_DB_URL=\"postgresql:\u002F\u002Fuser:password@hostname:5432\u002Fcontinuous_claude\"\n    ```\n\n### 卸载方法\n如需移除该系统并恢复原始配置：\n```bash\ncd Continuous-Claude-v3\u002Fopc\nuv run python -m scripts.setup.wizard --uninstall\n```\n\n## 基本使用\n\n安装完成后，无需记忆复杂的斜杠命令，只需用自然语言描述需求，系统会自动激活相应的技能和智能体。\n\n### 启动会话\n```bash\nclaude\n```\n\n### 常用工作流示例\n\n进入交互界面后，您可以直接尝试以下指令：\n\n| 您的需求 | 输入指令 | 系统行为 |\n| :--- | :--- | :--- |\n| **修复 Bug** | `\u002Ffix bug \u003C描述>` | 自动调用调试智能体进行定位和修复 |\n| **新功能开发** | `\u002Fbuild greenfield \u003C功能名>` | 启动规划与构建工作流 |\n| **理解代码库** | `\u002Fexplore` | 调用 Scout 智能体探索代码结构 |\n| **风险评估** | `\u002Fpremortem` | 在实施前进行潜在风险分析 |\n| **通用任务** | 直接描述 (如 \"优化登录逻辑\") | 系统自动匹配最佳技能组合 |\n\n### 关键操作提示\n\n*   **结束会话**: 当完成当前任务时，务必告诉 Claude **\"Done for today\"** 或手动触发 `create_handoff`。这将把当前会话的关键学习成果提取并保存到记忆中，供下次会话使用。\n*   **恢复上下文**: 新会话开始时，说 **\"Resume where we left off\"** 或触发 `resume_handoff`，系统将加载之前的上下文和记忆。\n*   **技能优先级**: 系统会根据上下文提示技能优先级（⚠️ 必须使用、📚 推荐使用、💡 建议使用），请留意终端输出的激活检查信息。\n\n通过以上步骤，您即可拥有一个能够持续学习、跨会话保持上下文的增强型 AI 开发环境。","某全栈开发者正在为一个复杂的电商后台系统重构支付模块，需要在多次会话中持续迭代代码并协调多个微服务。\n\n### 没有 Continuous-Claude-v3 时\n- **上下文频繁丢失**：当对话历史过长触发压缩机制时，之前确定的架构决策和边界条件被遗忘，导致 AI 重复询问或生成冲突代码。\n- **Token 浪费严重**：每次修改都需要重新读取整个大型文件以获取上下文，不仅速度慢，还迅速耗尽了模型的上下文窗口限额。\n- **多任务协调困难**：同时处理数据库迁移、API 更新和前端适配时，缺乏统一的调度机制，容易顾此失彼，产生逻辑漏洞。\n- **经验无法沉淀**：每次开启新会话都是“从零开始”，之前会话中修复的特定 Bug 或学到的业务规则无法自动带入下一次工作。\n\n### 使用 Continuous-Claude-v3 后\n- **状态无缝延续**：通过 YAML 交接单（handoffs）和分类账（ledgers）机制，即使会话重启，核心的架构决策和业务规则也能完整保留，实现“复利式”智能积累。\n- **高效代码分析**：利用五层代码分析和语义索引技术，仅提取关键变更点而非通读全文件，大幅降低 Token 消耗并提升响应速度。\n- **智能代理编排**：内置的 32 个专业代理自动协同工作，元技能（Meta-skills）统一调度数据库、后端和前端的修改任务，确保多端逻辑一致。\n- **自动化知识记忆**：守护进程自动从每次会话中提取学习成果并存入记忆系统，后续任务能自动调用过往的修复经验和业务约束，避免重蹈覆辙。\n\nContinuous-Claude-v3 将原本碎片化的 AI 辅助编程转变为具备持续学习和记忆能力的开发伙伴，彻底解决了长周期开发中的上下文断裂与效率瓶颈。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fparcadei_Continuous-Claude-v3_5ba79805.png","parcadei","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Fparcadei_6f2ca57f.png",null,"https:\u002F\u002Fgithub.com\u002Fparcadei",[78,82,86,89,93],{"name":79,"color":80,"percentage":81},"Python","#3572A5",64,{"name":83,"color":84,"percentage":85},"TypeScript","#3178c6",22.5,{"name":87,"color":75,"percentage":88},"Lean",8.4,{"name":90,"color":91,"percentage":92},"Shell","#89e051",2.9,{"name":94,"color":95,"percentage":96},"JavaScript","#f1e05a",2.2,3700,287,"2026-04-18T15:06:30","MIT",4,"未说明",{"notes":104,"python":105,"dependencies":106},"该工具是基于 Claude Code 的多智能体开发环境，并非本地运行的大模型，因此无需 GPU。主要依赖 Docker 运行本地 PostgreSQL 数据库（需启用 pgvector 扩展），并使用 uv 作为包管理器。安装过程包含一个 12 步的设置向导，用于配置数据库、API 密钥及集成 Claude Code。支持可选的远程数据库部署（如 AWS RDS, Supabase）。数学功能（SymPy, Z3, Pint）和某些诊断工具为可选项。","3.11+",[107,108,109,110,111,112,113,114,115],"uv","Docker","PostgreSQL (with pgvector)","Claude Code CLI","SymPy (可选)","Z3 (可选)","Pint (可选)","ast-grep (可选)","Loogle (可选)",[45,13],[118,119,120,121,122,123,124,125,126],"agents","claude-code","claude-code-cli","claude-code-hooks","claude-code-mcp","claude-code-skills","claude-code-subagents","claude-skills","mcp","2026-03-27T02:49:30.150509","2026-04-19T09:37:51.706387",[130,135,140,145,149,154],{"id":131,"question_zh":132,"answer_zh":133,"source_url":134},42143,"安装设置向导时遇到 Docker 健康检查失败或数据库迁移错误怎么办？","这通常是由于脚本中缺少 `-f` 标志指定 compose 文件，或使用了错误的数据库名称和 SQL 文件名导致的。维护者已修复以下问题：\n1. 将所有 `docker compose` 命令添加了 `-f` 标志以指定 compose 文件路径。\n2. 修正数据库名称：从 `claude_continuity` 改为 `continuous_claude`。\n3. 修正初始化 SQL 文件名：从 `init-db.sql` 改为 `init-schema.sql`。\n\n解决方案：请拉取最新代码 (`git pull`) 并重新运行安装脚本，无需手动修改代码。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3\u002Fissues\u002F22",{"id":136,"question_zh":137,"answer_zh":138,"source_url":139},42144,"在 Windows (WSL2) 上启用 Hooks 后，终端表格和文本渲染出现乱码如何解决？","这是由于多个 Hooks 同时写入 stdout 导致的竞争条件，特别是在 Windows\u002FWSL 环境下 Bash Hooks 的 I\u002FO 时序与原生 Node Hooks 不同所致。\n\n临时解决方案：\n1. 打开 `~\u002F.claude\u002Fsettings.json` 文件。\n2. 移除或注释掉以下 5 个 bash hooks（搜索 `braintrust-tracing`）：\n   - `SessionStart`\n   - `UserPromptSubmit`\n   - `PostToolUse`\n   - `Stop`\n   - `SessionEnd`\n3. 重启 Claude Code 会话。\n\n如果乱码消失，说明是这些 hooks 导致的。后续版本将会更新以路由这些输出从而解决该问题。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3\u002Fissues\u002F41",{"id":141,"question_zh":142,"answer_zh":143,"source_url":144},42145,"Continuous Claude v3 与 Claude-Mem v9 有什么主要区别？","两者解决上下文退化问题的理念不同：\n- **Continuous Claude v3**：主张“复合优于紧凑”。使用 PostgreSQL + pgvector (Docker) 存储状态，通过 TLDR 工具进行 5 层代码结构分析 (AST\u002FCFG\u002FDFG) 以节省 Token。拥有 32 个专用代理，强调严谨的工作流（如 TDD、形式验证），适合需要高正确性和安全性的工程场景。\n- **Claude-Mem v9**：主张“捕获 > 压缩 > 注入”。使用 SQLite + Chroma (本地) 存储，内存完全自动捕获且对用户不可见。采用渐进式披露策略，只有一个优化工作代理，适合追求流畅体验和自动化的场景。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3\u002Fissues\u002F49",{"id":146,"question_zh":147,"answer_zh":148,"source_url":144},42146,"Continuous Claude v3 与 Gas Town (gastown) 有何不同？","两者都是针对 Claude Code 的多代理编排平台，但架构截然不同：\n- **Gas Town**：使用 Go 语言开发，核心创新是利用 Git worktrees 和基于 Git 的 JSONL \"Beads\" 进行状态持久化，通过 Git diff 管理上下文。\n- **Continuous Claude v3**：使用 Python 开发，核心创新是 TLDR 5 层代码分析技术和 PostgreSQL + pgvector 内存系统。它拥有更多专用代理（32 个 vs ~8 个），并通过分析实现高达 95% 的 Token 缩减率，而非依赖 Git diff。",{"id":150,"question_zh":151,"answer_zh":152,"source_url":153},42147,"是否支持使用嵌入式 Postgres (如 pglite 或 native binary) 来简化安装？","目前官方版本依赖 Docker 运行 PostgreSQL 以确保环境一致性。虽然有用户尝试集成原生嵌入式 Postgres (pgserver) 以避免 Docker 依赖，但在许多 Linux 发行版上遇到了动态加载错误和兼容性問題 (manylinux 2_28 vs 新版 Ubuntu)。\n\n当前建议：继续使用推荐的 Docker 设置以保证稳定性。如果未来社区解决了二进制兼容性问题，可能会考虑支持更轻量级的嵌入式方案。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002FContinuous-Claude-v3\u002Fissues\u002F42",{"id":155,"question_zh":156,"answer_zh":157,"source_url":134},42148,"项目为什么同时存在 main 和 master 两个分支？何时合并？","这是用户在修复 Bug 过程中提出的疑问。通常情况下，维护者会将所有修复和功能统一合并到一个主分支（通常是 `main`）。在 Issue #22 的修复过程中，维护者直接在主分支上推送了修复提交（包括 Docker 配置、数据库名称和 SQL 文件名的修正），表明开发活动主要集中在单一主线分支上进行，用户应始终拉取最新的主分支代码以获取修复。",[]]