{"id":36398362,"url":"https://github.com/parcadei/Continuous-Claude-v3","last_synced_at":"2026-01-14T20:00:46.532Z","repository":{"id":330515436,"uuid":"1121405464","full_name":"parcadei/Continuous-Claude-v3","owner":"parcadei","description":"Context management for Claude Code. Hooks maintain state via ledgers and handoffs. MCP execution without context pollution. Agent orchestration with isolated context windows.","archived":false,"fork":false,"pushed_at":"2026-01-10T16:56:50.000Z","size":1577,"stargazers_count":2125,"open_issues_count":10,"forks_count":153,"subscribers_count":21,"default_branch":"main","last_synced_at":"2026-01-11T00:39:15.435Z","etag":null,"topics":["agents","claude-code","claude-code-cli","claude-code-hooks","claude-code-mcp","claude-code-skills","claude-code-subagents","claude-skills","mcp"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/parcadei.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-12-23T00:12:49.000Z","updated_at":"2026-01-11T00:25:39.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/parcadei/Continuous-Claude-v3","commit_stats":null,"previous_names":["parcadei/continuous-claude","parcadei/continuous-claude-v2","parcadei/continuous-claude-v3"],"tags_count":null,"template":false,"template_full_name":null,"purl":"pkg:github/parcadei/Continuous-Claude-v3","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/parcadei%2FContinuous-Claude-v3","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/parcadei%2FContinuous-Claude-v3/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/parcadei%2FContinuous-Claude-v3/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/parcadei%2FContinuous-Claude-v3/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/parcadei","download_url":"https://codeload.github.com/parcadei/Continuous-Claude-v3/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/parcadei%2FContinuous-Claude-v3/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28434112,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-14T18:57:19.464Z","status":"ssl_error","status_checked_at":"2026-01-14T18:52:48.501Z","response_time":107,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["agents","claude-code","claude-code-cli","claude-code-hooks","claude-code-mcp","claude-code-skills","claude-code-subagents","claude-skills","mcp"],"created_at":"2026-01-11T16:00:32.184Z","updated_at":"2026-01-14T20:00:46.515Z","avatar_url":"https://github.com/parcadei.png","language":"Python","funding_links":[],"categories":["MCP Clients","Frameworks \u0026 Libraries","Agent Orchestration","Productivity Tools","Personal Assistants \u0026 Conversational Agents","MCP Servers \u0026 Protocol","Context and Memory","Context and Memory Management"],"sub_categories":["Agent Orchestration Platforms","Copilot Extensions \u0026 Alternatives","Memory \u0026 Context Management","Chatbots"],"readme":"# Continuous Claude\n\n\u003e A persistent, learning, multi-agent development environment built on Claude Code\n\n[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)\n[![Claude Code](https://img.shields.io/badge/Claude-Code-orange.svg)](https://claude.ai/code)\n[![Skills](https://img.shields.io/badge/Skills-109-green.svg)](#skills-system)\n[![Agents](https://img.shields.io/badge/Agents-32-purple.svg)](#agents-system)\n[![Hooks](https://img.shields.io/badge/Hooks-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/ruff 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\u003e \"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\" | `/fix` workflow → debug-agent, scout |\n| \"Build a user dashboard\" | `/build` workflow → plan-agent, kraken |\n| \"I want to understand this codebase\" | `/explore` + scout agent |\n| \"What could go wrong with this plan?\" | `/premortem` |\n| \"Help me figure out what I need\" | `/discovery-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 /fix, /build, 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 | `/fix` (sleuth → premortem → kraken → commit) |\n| **Agent** | Specialized sub-session | scout (exploration), oracle (research) |\n\n[See detailed skill activation docs →](docs/skill-activation.md)\n\n---\n\n## Quick Start\n\n### Prerequisites\n\n- Python 3.11+\n- [uv](https://github.com/astral-sh/uv) package manager\n- Docker (for PostgreSQL)\n- Claude Code CLI\n\n### Installation\n\n```bash\n# Clone\ngit clone https://github.com/parcadei/Continuous-Claude-v3.git\ncd Continuous-Claude-v3/opc\n\n# Run setup wizard (12 steps)\nuv run python -m scripts.setup.wizard\n```\n\n\u003e **Note:** The `pyproject.toml` is in `opc/`. Always run `uv` commands from the `opc/` directory.\n\n### What the Wizard Does\n\n| Step | What It Does |\n|------|--------------|\n| 1 | Backup existing .claude/ 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### 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/init-schema.sql\n```\n\n\u003e **Managed PostgreSQL tips:**\n\u003e - **AWS RDS**: Add `vector` to `shared_preload_libraries` in DB Parameter Group\n\u003e - **Supabase**: Enable via Database Extensions page\n\u003e - **Azure Database**: Use Extensions pane to enable pgvector\n\n#### 2. Connection Configuration\n\nSet `CONTINUOUS_CLAUDE_DB_URL` in `~/.claude/settings.json`:\n\n```json\n{\n  \"env\": {\n    \"CONTINUOUS_CLAUDE_DB_URL\": \"postgresql://user:password@hostname:5432/continuous_claude\"\n  }\n}\n```\n\nOr export before running Claude:\n\n```bash\nexport CONTINUOUS_CLAUDE_DB_URL=\"postgresql://user:password@hostname:5432/continuous_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\u003e /workflow\n```\n\n### First Session Commands\n\n| Command | What it does |\n|---------|--------------|\n| `/workflow` | Goal-based routing (Research/Plan/Build/Fix) |\n| `/fix bug \u003cdescription\u003e` | Investigate and fix a bug |\n| `/build greenfield \u003cfeature\u003e` | Build a new feature from scratch |\n| `/explore` | Understand the codebase |\n| `/premortem` | 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                                    │ /clear  │\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/shared/\n           │                           │  (YAML format)     │    handoffs/*.yaml\n           │                           │  Dirty \u003e 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           └──────────────◀────── /clear ◀──────┘\n                          Fresh context + state preserved\n```\n\n### Workflow Chains\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                           META-SKILL WORKFLOWS                              │\n└─────────────────────────────────────────────────────────────────────────────┘\n\n  /fix bug                              /build 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  /tdd                                  /refactor\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/              │         │\n│                                          │ ├── ledgers/           │         │\n│                                          │ │   └── CONTINUITY_*.md│         │\n│                                          │ └── shared/            │         │\n│                                          │     ├── handoffs/*.yaml│         │\n│                                          │     └── plans/*.md     │         │\n│                                          │                        │         │\n│                                          │ .tldr/                 │         │\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/skills/`.\n\n#### Meta-Skills (Workflow Orchestrators)\n\n| Meta-Skill | Chain | Use When |\n|------------|-------|----------|\n| `/workflow` | Router → appropriate workflow | Don't know where to start |\n| `/build` | discovery → plan → validate → implement → commit | Building features |\n| `/fix` | sleuth → premortem → kraken → test → commit | Fixing bugs |\n| `/tdd` | plan → arbiter (tests) → kraken (implement) → arbiter | Test-first development |\n| `/refactor` | phoenix → plan → kraken → reviewer → arbiter | Safe code transformation |\n| `/review` | parallel specialized reviews → synthesis | Code review |\n| `/explore` | scout (quick/deep/architecture) | Understand codebase |\n| `/security` | vulnerability scan → verification | Security audits |\n| `/release` | 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., `/build`) to get an interactive question flow.\n\n**`/build \u003cmode\u003e [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**`/fix \u003cscope\u003e [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**`/explore \u003cdepth\u003e [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**`/tdd`, `/refactor`, `/review`, `/security`, `/release`**\n\nThese follow their defined chains without mode flags. Just run:\n```\n/tdd \"implement retry logic\"\n/refactor \"extract auth module\"\n/review                           # reviews current changes\n/security \"authentication code\"\n/release v1.2.0\n```\n\n#### Key Skills (High-Value Tools)\n\n**Planning \u0026 Risk**\n- **premortem**: TIGERS \u0026 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/issues/PRs\n\n**Quality**\n- **qlty-check**: 70+ linters, auto-fix\n- **braintrust-analyze**: Session analysis, replay, and debugging failed sessions\n\n**Math \u0026 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 `/prove` 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 → /workflow (guided router)\n├── Building → /build greenfield or brownfield\n├── Fixing → /fix bug\n├── Understanding → /explore\n├── Planning → premortem first, then plan-agent\n├── Researching → oracle or perplexity-search\n├── Reviewing → /review\n├── Proving → /prove (Lean4 formal verification)\n├── Computing → /math (SymPy, Z3, Pint)\n└── Shipping → /release\n```\n\n[See detailed skills breakdown →](docs/skills/)\n\n---\n\n### Agents System\n\nAgents are specialized AI workers spawned via the Task tool. Located in `.claude/agents/`.\n\n#### Agent Categories (32 active)\n\n\u003e **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/resume support\n\n**Planners (4)**\n- **architect**: Feature planning + API integration\n- **phoenix**: Refactoring + framework migration planning\n- **plan-agent**: Lightweight planning with research/MCP 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/code 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/kraken → arbiter → scribe |\n\n[See detailed agent guide →](docs/agents/)\n\n---\n\n### Hooks System\n\nHooks intercept Claude Code at lifecycle points. Located in `.claude/hooks/`.\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/ruff after edits |\n| **memory-awareness** | Surfaces relevant learnings |\n\n[See all 30 hooks →](docs/hooks/)\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/                      # File tree\ntldr structure src/ --lang python   # Code structure (codemaps)\n\n# Search and extraction\ntldr search \"process_data\" src/     # Find code\ntldr context process_data --project src/ --depth 2  # LLM-ready context\n\n# Flow analysis\ntldr cfg src/main.py main           # Control flow graph\ntldr dfg src/main.py main           # Data flow graph\ntldr slice src/main.py main 42      # What affects line 42?\n\n# Codebase analysis\ntldr impact process_data src/       # Who calls this function?\ntldr dead src/                      # Find unreachable code\ntldr arch src/                      # 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__/\n*.test.py\nnode_modules/\n.venv/\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/packages/tldr-code/)\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 (\u003e5 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 \u0026\u0026 uv run python scripts/core/recall_learnings.py \\\n    --query \"authentication patterns\"\n\n# Store a learning explicitly\ncd opc \u0026\u0026 uv run python scripts/core/store_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/ledgers/CONTINUITY_\u003ctopic\u003e.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/shared/handoffs/\u003csession\u003e/`\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\" / `/handoff` | 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| `/math` | Computing, solving, calculating |\n| `/prove` | Formal verification, machine-checked proofs |\n\n#### /math 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#### /prove - 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/prove every group homomorphism preserves identity\n/prove 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 /prove)\ncurl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh\n```\n\n---\n\n## Workflows\n\n### /workflow - Goal-Based Router\n\n```\n\u003e /workflow\n\n? What's your goal?\n  ○ Research - Understand codebase/docs\n  ○ Plan - Design implementation approach\n  ○ Build - Implement features\n  ○ Fix - Investigate and resolve issues\n```\n\n### /fix - Bug Resolution\n\n```bash\n/fix 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### /build - Feature Development\n\n```bash\n/build 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### /premortem - Risk Analysis\n\n```bash\n/premortem deep thoughts/shared/plans/feature-x.md\n```\n\n**Output:**\n- **TIGERS**: Clear threats (HIGH/MEDIUM/LOW severity)\n- **ELEPHANTS**: Unspoken concerns\n\nBlocks on HIGH severity until user accepts/mitigates risks.\n\n---\n\n## Installation\n\n### Full Installation (Recommended)\n\n```bash\n# Clone\ngit clone https://github.com/parcadei/continuous-claude.git\ncd continuous-claude/opc\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/opc\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) | ~/.claude/agents/ |\n| Skills (109) | ~/.claude/skills/ |\n| Hooks (30) | ~/.claude/hooks/ |\n| Rules | ~/.claude/rules/ |\n| Scripts | ~/.claude/scripts/ |\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 `~/.claude/` | 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/.claude/` to `~/.claude/`. Changes you make in `~/.claude/` are **local only** and will be overwritten on next update.\n\n```text\ncontinuous-claude/.claude/  ──COPY──\u003e  ~/.claude/\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 `~/.claude/` points directly to repo files. Changes in either location affect the same files.\n\n```text\n~/.claude/rules  ──SYMLINK──\u003e  continuous-claude/.claude/rules\n~/.claude/skills ──SYMLINK──\u003e  continuous-claude/.claude/skills\n~/.claude/hooks  ──SYMLINK──\u003e  continuous-claude/.claude/hooks\n~/.claude/agents ──SYMLINK──\u003e  continuous-claude/.claude/agents\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 ~/.claude/backups/$(date +%Y%m%d)\ncp -r ~/.claude/{rules,skills,hooks,agents} ~/.claude/backups/$(date +%Y%m%d)/\n\n# Verify backup succeeded before proceeding\nls -la ~/.claude/backups/$(date +%Y%m%d)/\n\n# Remove copies (only after verifying backup above)\nrm -rf ~/.claude/{rules,skills,hooks,agents}\n\n# Create symlinks (adjust path to your repo location)\nREPO=\"$HOME/continuous-claude\"  # or wherever you cloned\nln -s \"$REPO/.claude/rules\" ~/.claude/rules\nln -s \"$REPO/.claude/skills\" ~/.claude/skills\nln -s \"$REPO/.claude/hooks\" ~/.claude/hooks\nln -s \"$REPO/.claude/agents\" ~/.claude/agents\n\n# Verify\nls -la ~/.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 \u0026 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\u003e /onboard\n```\n\nThis analyzes the codebase and creates an initial continuity ledger.\n\n---\n\n## Configuration\n\n### .claude/settings.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/skills/skill-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/ 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/\n├── .claude/\n│   ├── agents/           # 32 specialized AI agents\n│   ├── hooks/            # 30 lifecycle hooks\n│   │   ├── src/          # TypeScript source\n│   │   └── dist/         # Compiled JavaScript\n│   ├── skills/           # 109 modular capabilities\n│   ├── rules/            # System policies\n│   ├── scripts/          # Python utilities\n│   └── settings.json     # Hook configuration\n├── opc/\n│   ├── packages/\n│   │   └── tldr-code/    # 5-layer code analysis\n│   ├── scripts/\n│   │   ├── setup/        # Wizard, Docker, integration\n│   │   └── core/         # recall_learnings, store_learning\n│   └── docker/\n│       └── init-schema.sql  # 4-table PostgreSQL schema\n├── thoughts/\n│   ├── ledgers/          # Continuity ledgers (CONTINUITY_*.md)\n│   └── shared/\n│       ├── handoffs/     # Session handoffs (*.yaml)\n│       └── plans/        # Implementation plans\n└── docs/                 # 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 \u0026 Architecture\n- **[@numman-ali](https://github.com/numman-ali)** - Continuity ledger pattern\n- **[Anthropic](https://anthropic.com)** - Claude Code and \"Code Execution with MCP\"\n- **[obra/superpowers](https://github.com/obra/superpowers)** - Agent orchestration patterns\n- **[EveryInc/compound-engineering-plugin](https://github.com/EveryInc/compound-engineering-plugin)** - Compound engineering workflow\n- **[yoloshii/mcp-code-execution-enhanced](https://github.com/yoloshii/mcp-code-execution-enhanced)** - Enhanced MCP execution\n- **[HumanLayer](https://github.com/humanlayer/humanlayer)** - Agent patterns\n\n### Tools \u0026 Services\n- **[uv](https://github.com/astral-sh/uv)** - Python packaging\n- **[tree-sitter](https://tree-sitter.github.io/)** - Code parsing\n- **[Braintrust](https://braintrust.dev)** - LLM evaluation, logging, and session tracing\n- **[qlty](https://github.com/qltysh/qlty)** - Universal code quality CLI (70+ linters)\n- **[ast-grep](https://github.com/ast-grep/ast-grep)** - AST-based code search and refactoring\n- **[Nia](https://trynia.ai)** - Library documentation search\n- **[Morph](https://www.morphllm.com)** - WarpGrep fast code search\n- **[Firecrawl](https://www.firecrawl.dev)** - Web scraping API\n- **[RepoPrompt](https://repoprompt.com)** - Token-efficient codebase maps\n\n---\n\n## Star History\n\n[![Star History Chart](https://api.star-history.com/svg?repos=parcadei/Continuous-Claude-v2\u0026type=timeline)](https://star-history.com/#parcadei/Continuous-Claude-v2\u0026Date)\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","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fparcadei%2FContinuous-Claude-v3","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fparcadei%2FContinuous-Claude-v3","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fparcadei%2FContinuous-Claude-v3/lists"}