[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-72229":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":16,"subscribersCount":16,"size":16,"stars1d":17,"stars7d":18,"stars30d":19,"stars90d":16,"forks30d":16,"starsTrendScore":18,"compositeScore":20,"rankGlobal":10,"rankLanguage":10,"license":21,"archived":22,"fork":22,"defaultBranch":23,"hasWiki":24,"hasPages":22,"topics":25,"createdAt":10,"pushedAt":10,"updatedAt":35,"readmeContent":36,"aiSummary":37,"trendingCount":16,"starSnapshotCount":16,"syncStatus":38,"lastSyncTime":39,"discoverSource":40},72229,"Continuous-Claude-v3","parcadei\u002FContinuous-Claude-v3","parcadei","Context management for Claude Code. Hooks maintain state via ledgers and handoffs. MCP execution without context pollution. Agent orchestration with isolated context windows.","",null,"Python",3804,296,30,29,0,3,9,36,29.42,"MIT License",false,"main",true,[26,27,28,29,30,31,32,33,34],"agents","claude-code","claude-code-cli","claude-code-hooks","claude-code-mcp","claude-code-skills","claude-code-subagents","claude-skills","mcp","2026-06-12 02:03:00","# 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\u002Fapi.star-history.com\u002Fsvg?repos=parcadei\u002FContinuous-Claude-v2&type=timeline)](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","Continuous Claude 是一个基于Claude Code的持续学习多代理开发环境。该项目通过YAML手递手传递、记忆系统和代码分析等技术特点，解决了上下文丢失、会话间需要重新开始以及复杂任务协调等问题，确保了跨会话状态的一致性和学习成果的积累。它特别适合需要在多个交互会话中保持上下文连贯性、自动提取学习经验并高效管理资源的应用场景，如软件开发中的持续集成与部署流程优化、复杂问题解决等。项目采用Python编写，并遵循MIT许可协议。",2,"2026-06-11 03:40:57","high_star"]