Continuous-Claude-v3 README

The project's README from github.com/parcadei/Continuous-Claude-v3. As one markdown file: README.md.

Continuous Claude

A persistent, learning, multi-agent development environment built on Claude Code

License: MIT Claude Code Skills Agents Hooks

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.

Table of Contents

Why Continuous Claude?

Claude Code has a compaction problem: when context fills up, the system compacts your conversation, losing nuanced understanding and decisions made during the session.

Continuous Claude solves this with:

Problem Solution
Context loss on compaction YAML handoffs - more token-efficient transfer
Starting fresh each session Memory system recalls + daemon auto-extracts learnings
Reading entire files burns tokens 5-layer code analysis + semantic index
Complex tasks need coordination Meta-skills orchestrate agent workflows
Repeating workflows manually 109 skills with natural language triggers

The mantra: Compound, don't compact. Extract learnings automatically, then start fresh with full context.

Why "Continuous"? Why "Compounding"?

The name is a pun. Continuous because Claude maintains state across sessions. Compounding because each session makes the system smarter—learnings accumulate like compound interest.

Design Principles

An agent is five things: Prompt + Tools + Context + Memory + Model.

Component What We Optimize
Prompt Skills inject relevant context; hooks add system reminders
Tools TLDR reduces tokens; agents parallelize work
Context Not just what Claude knows, but how it's provided
Memory Daemon extracts learnings; recall surfaces them
Model Becomes swappable when the other four are solid

Anti-Complexity

We resist plugin sprawl. Every MCP, subscription, and tool you add promises improvement but risks breaking context, tools, or prompts through clashes.

Our approach:

The 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.

How to Talk to Claude

You don't need to memorize slash commands. Just describe what you want naturally.

The Skill Activation System

When 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.

> "Fix the login bug in auth.py"

🎯 SKILL ACTIVATION CHECK
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚠️ CRITICAL SKILLS (REQUIRED):
  → create_handoff

📚 RECOMMENDED SKILLS:
  → fix
  → debug

🤖 RECOMMENDED AGENTS (token-efficient):
  → debug-agent
  → scout

ACTION: Use Skill tool BEFORE responding
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Priority Levels

Level Meaning
⚠️ CRITICAL Must use (e.g., handoffs before ending session)
📚 RECOMMENDED Should use (e.g., workflow skills)
💡 SUGGESTED Consider using (e.g., optimization tools)
📌 OPTIONAL Nice to have (e.g., documentation helpers)

Natural Language Examples

What You Say What Activates
"Fix the broken login" /fix workflow → debug-agent, scout
"Build a user dashboard" /build workflow → plan-agent, kraken
"I want to understand this codebase" /explore + scout agent
"What could go wrong with this plan?" /premortem
"Help me figure out what I need" /discovery-interview
"Done for today" create_handoff (critical)
"Resume where we left off" resume_handoff
"Research auth patterns" oracle agent + perplexity
"Find all usages of this API" scout agent + ast-grep

Why This Approach?

Benefit How
More Discoverable Don't need to know commands exist
Context-Aware System knows when you're 90% through context
Reduces Cognitive Load Describe intent naturally, get curated suggestions
Power User Friendly Still supports /fix, /build, etc. directly

Skill vs Workflow vs Agent

Type Purpose Example
Skill Single-purpose tool commit, tldr-code, qlty-check
Workflow Multi-step process /fix (sleuth → premortem → kraken → commit)
Agent Specialized sub-session scout (exploration), oracle (research)

See detailed skill activation docs →

Quick Start

Prerequisites

Installation

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

# Run setup wizard (12 steps)
uv run python -m scripts.setup.wizard

Note: The pyproject.toml is in opc/. Always run uv commands from the opc/ directory.

What the Wizard Does

Step What It Does
1 Backup existing .claude/ config (if present)
2 Check prerequisites (Docker, Python, uv)
3-5 Database + API key configuration
6-7 Start Docker stack, run migrations
8 Install Claude Code integration (32 agents, 109 skills, 30 hooks)
9 Math features (SymPy, Z3, Pint - optional)
10 TLDR code analysis tool
11-12 Diagnostics tools + Loogle (optional)

To Uninstall:

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

What it does

  1. Archives your current setup → Moves ~/.claude to ~/.claude-v3.archived.
  2. Restores your backup → Finds the most recent ~/.claude.backup.* (created during install) and restores it
  3. Preserves user data → Copies these back from the archive:
  1. Removes CC-v3 additions → Everything else (hooks, skills, agents, rules)

Safety Features

Remote Database Setup

By default, CC-v3 runs PostgreSQL locally via Docker. For remote database setups:

1. Database Preparation

# Connect to your remote PostgreSQL instance
psql -h hostname -U user -d continuous_claude

# Enable pgvector extension (requires superuser or rds_superuser)
CREATE EXTENSION IF NOT EXISTS vector;

# Apply the schema (from your local clone)
psql -h hostname -U user -d continuous_claude -f docker/init-schema.sql

Managed PostgreSQL tips:

  • AWS RDS: Add vector to shared_preload_libraries in DB Parameter Group
  • Supabase: Enable via Database Extensions page
  • Azure Database: Use Extensions pane to enable pgvector

2. Connection Configuration

Set CONTINUOUS_CLAUDE_DB_URL in ~/.claude/settings.json:

{
  "env": {
    "CONTINUOUS_CLAUDE_DB_URL": "postgresql://user:password@hostname:5432/continuous_claude"
  }
}

Or export before running Claude:

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

See .env.example for all available environment variables.

First Session

# Start Claude Code
claude

# Try a workflow
> /workflow

First Session Commands

Command What it does
/workflow Goal-based routing (Research/Plan/Build/Fix)
/fix bug <description> Investigate and fix a bug
/build greenfield <feature> Build a new feature from scratch
/explore Understand the codebase
/premortem Risk analysis before implementation

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                        CONTINUOUS CLAUDE                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │
│  │   Skills    │    │   Agents    │    │    Hooks    │             │
│  │   (109)     │───▶│    (32)     │◀───│    (30)     │             │
│  └─────────────┘    └─────────────┘    └─────────────┘             │
│         │                  │                  │                     │
│         ▼                  ▼                  ▼                     │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                     TLDR Code Analysis                       │   │
│  │   L1:AST → L2:CallGraph → L3:CFG → L4:DFG → L5:Slicing      │   │
│  │                    (95% token savings)                       │   │
│  └─────────────────────────────────────────────────────────────┘   │
│         │                  │                  │                     │
│         ▼                  ▼                  ▼                     │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐             │
│  │   Memory    │    │ Continuity  │    │ Coordination│             │
│  │   System    │    │   Ledgers   │    │    Layer    │             │
│  └─────────────┘    └─────────────┘    └─────────────┘             │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Data Flow: Session Lifecycle

SessionStart                    Working                      SessionEnd
    │                              │                             │
    ▼                              ▼                             ▼
┌─────────┐                  ┌─────────┐                   ┌─────────┐
│  Load   │                  │  Track  │                   │  Save   │
│ context │─────────────────▶│ changes │──────────────────▶│  state  │
└─────────┘                  └─────────┘                   └─────────┘
    │                              │                             │
    ├── Continuity ledger          ├── File claims               ├── Handoff
    ├── Memory recall              ├── TLDR indexing             ├── Learnings
    └── Symbol index               └── Blackboard                └── Outcome
                                         │
                                         ▼
                                    ┌─────────┐
                                    │ /clear  │
                                    │ Fresh   │
                                    │ context │
                                    └─────────┘

The Continuity Loop (Detailed)

┌─────────────────────────────────────────────────────────────────────────────┐
│                            THE CONTINUITY LOOP                              │
└─────────────────────────────────────────────────────────────────────────────┘

  1. SESSION START                     2. WORKING
  ┌────────────────────┐               ┌────────────────────┐
  │                    │               │                    │
  │  Ledger loaded ────┼──▶ Context    │  PostToolUse ──────┼──▶ Index handoffs
  │  Handoff loaded    │               │  UserPrompt ───────┼──▶ Skill hints
  │  Memory recalled   │               │  Edit tracking ────┼──▶ Dirty flag++
  │  TLDR cache warmed │               │  SubagentStop ─────┼──▶ Agent reports
  │                    │               │                    │
  └────────────────────┘               └────────────────────┘
           │                                    │
           │                                    ▼
           │                           ┌────────────────────┐
           │                           │ 3. PRE-COMPACT     │
           │                           │                    │
           │                           │  Auto-handoff ─────┼──▶ thoughts/shared/
           │                           │  (YAML format)     │    handoffs/*.yaml
           │                           │  Dirty > 20? ──────┼──▶ TLDR re-index
           │                           │                    │
           │                           └────────────────────┘
           │                                    │
           │                                    ▼
           │                           ┌────────────────────┐
           │                           │ 4. SESSION END     │
           │                           │                    │
           │                           │  Stale heartbeat ──┼──▶ Daemon wakes
           │                           │  Daemon spawns ────┼──▶ Headless Claude
           │                           │  Thinking blocks ──┼──▶ archival_memory
           │                           │                    │
           │                           └────────────────────┘
           │                                    │
           │                                    │
           └──────────────◀────── /clear ◀──────┘
                          Fresh context + state preserved

Workflow Chains

┌─────────────────────────────────────────────────────────────────────────────┐
│                           META-SKILL WORKFLOWS                              │
└─────────────────────────────────────────────────────────────────────────────┘

  /fix bug                              /build greenfield
  ─────────                             ─────────────────
  ┌──────────┐  ┌──────────┐            ┌──────────┐  ┌──────────┐
  │  sleuth  │─▶│ premortem│            │discovery │─▶│plan-agent│
  │(diagnose)│  │  (risk)  │            │(clarify) │  │ (design) │
  └──────────┘  └────┬─────┘            └──────────┘  └────┬─────┘
                     │                                      │
                     ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  kraken  │                          │ validate │
              │  (fix)   │                          │ (check)  │
              └────┬─────┘                          └────┬─────┘
                   │                                      │
                   ▼                                      ▼
              ┌──────────┐                          ┌──────────┐
              │  arbiter │                          │  kraken  │
              │ (test)   │                          │(implement│
              └────┬─────┘                          └────┬─────┘
                   │                                      │
                   ▼                                      ▼
              ┌──────────┐                          ┌─�

Continuous-Claude-v3 (parcadei/Continuous-Claude-v3)

Searching Database…

3.9K ·GitHub
Continuous-Claude-v3
What is this?Continuous Claude is a plugin/environment layered on top of Claude Code that adds persistent memory, context-efficient handoffs, and multi-agent orchestration so Claude keeps learning across sessions instead of losing context on compaction.
Is this a standalone app or an add-on to Claude Code?It's an add-on installed into your existing Claude Code setup, bundling 109 skills, 32 agents and 30 hooks into the ~/.claude directory rather than running as a separate application.
How do I get it running?Run the install wizard from the opc/ directory using the uv package manager; it backs up your existing .claude/ config, checks prerequisites, sets up the database, starts the Docker stack, runs migrations, then installs the Claude Code integration.
What do I need installed before running the wizard?Python 3.11+, the uv package manager, Docker (for PostgreSQL), and the Claude Code CLI itself.
What if I want to remove it later?There's a built-in uninstall flow: it archives your current ~/.claude to a timestamped folder, restores your most recent pre-install backup, and copies back your history, MCP config, API keys and project data before stripping out the added hooks/skills/agents.
Do I need Docker's default local Postgres, or can I use a managed database?By default it runs PostgreSQL locally in Docker, but it also supports remote managed Postgres (AWS RDS, Supabase, Azure Database) as long as pgvector is enabled on that instance.
Does this require any paid API subscriptions?No required paid services — Perplexity and NIA integrations are optional extras, not mandatory.
How do I actually talk to it — slash commands or plain English?You can describe what you want in plain English (e.g. 'Fix the broken login', 'Done for today') and a hook infers which skills, agents or workflows to activate; power users can still use explicit slash commands like /fix or /build.
What's the difference between a skill, a workflow, and an agent here?A skill is a single-purpose tool (like commit or tldr-code), a workflow is a multi-step chain of skills/agents (like /fix running sleuth → premortem → kraken → commit), and an agent is a specialized sub-session with isolated context (like scout for exploration or oracle for research).
How does it avoid the usual Claude Code context-compaction problem?It uses YAML handoffs for token-efficient context transfer between sessions and a memory daemon that auto-extracts learnings, following the mantra 'Compound, don't compact' instead of relying on lossy compaction.
What is the TLDR code analysis system for?It's a 5-layer code analysis plus semantic index designed to avoid burning tokens on reading entire files, giving Claude a condensed understanding of the codebase instead.
What are similar projects?trueforge, planning-with-files, pragma, Comma, claude-db, multi-agent-discuss, context-mode, ruflo
Which topics is it in?claude-code-skills, hooks, yaml, context-engineering, claude-skills, memory, orchestration, postgresql, docker-compose, multi-agent, agents, claude-code
Creator
parcadei
Size
1.5 MB
Stars
3.9K
Updated
CommitJan 26
Age
9mo
Commits · 90 Days