Skip to content
Back to search

Continuous-Claude-v3

SkillWorks with Claude CodeGitHub

Context management for Claude Code. Hooks maintain state via ledgers and handoffs. MCP execution without context pollution. Agent orchestration with isolated context windows.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/parcadei/Continuous-Claude-v3 with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/parcadei/Continuous-Claude-v3'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/parcadei-continuous-claude-v3/badge.svg)](/listings/parcadei-continuous-claude-v3)

HTML

<a href="/listings/parcadei-continuous-claude-v3"><img src="/api/listings/parcadei-continuous-claude-v3/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- Python 3.11+ - [uv](https://github.com/astral-sh/uv) package manager - Docker (for PostgreSQL) - Claude Code CLI

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.<timestamp> 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:

- history.jsonl (your command history) - mcp_config.json (MCP servers) - .env (API keys) - projects.json (project configs) - file-history/ directory - projects/ directory 4. Removes CC-v3 additions → Everything else (hooks, skills, agents, rules)

**Safety Features**

- Your current setup is archived with timestamp - nothing gets deleted - The wizard asks for confirmation before proceeding - It restores from the backup that was made during installation - All your Claude Code settings stay intact

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 |

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 1,288 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Continuous Claude
  2. > A persistent, learning, multi-agent development environment built on Claude Code
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
  4. [![Claude Code](https://img.shields.io/badge/Claude-Code-orange.svg)](https://claude.ai/code)
  5. [![Skills](https://img.shields.io/badge/Skills-109-green.svg)](#skills-system)
  6. [![Agents](https://img.shields.io/badge/Agents-32-purple.svg)](#agents-system)
  7. [![Hooks](https://img.shields.io/badge/Hooks-30-blue.svg)](#hooks-system)
  8. **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.
  9. ## Table of Contents
  10. - [Why Continuous Claude?](#why-continuous-claude)
  11. - [Design Principles](#design-principles)
  12. - [How to Talk to Claude](#how-to-talk-to-claude)
  13. - [Quick Start](#quick-start)
  14. - [Architecture](#architecture)
  15. - [Core Systems](#core-systems)
  16. - [Skills (109)](#skills-system)
  17. - [Agents (32)](#agents-system)
  18. - [Hooks (30)](#hooks-system)
  19. - [TLDR Code Analysis](#tldr-code-analysis)
  20. - [Memory System](#memory-system)
  21. - [Continuity System](#continuity-system)
  22. - [Math System](#math-system)
  23. - [Workflows](#workflows)
  24. - [Installation](#installation)
  25. - [Updating](#updating)
  26. - [Configuration](#configuration)
  27. - [Contributing](#contributing)
  28. - [License](#license)
  29. ---
  30. ## Why Continuous Claude?
  31. Claude Code has a **compaction problem**: when context fills up, the system compacts your conversation, losing nuanced understanding and decisions made during the session.
  32. **Continuous Claude solves this with:**
  33. | Problem | Solution |
  34. |---------|----------|
  35. | Context loss on compaction | YAML handoffs - more token-efficient transfer |
  36. | Starting fresh each session | Memory system recalls + daemon auto-extracts learnings |
  37. | Reading entire files burns tokens | 5-layer code analysis + semantic index |
  38. | Complex tasks need coordination | Meta-skills orchestrate agent workflows |
  39. | Repeating workflows manually | 109 skills with natural language triggers |
  40. **The mantra: Compound, don't compact.** Extract learnings automatically, then start fresh with full context.
  41. ### Why "Continuous"? Why "Compounding"?
  42. 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.
  43. ---
  44. ## Design Principles
  45. An agent is five things: **Prompt + Tools + Context + Memory + Model**.
  46. | Component | What We Optimize |
  47. |-----------|------------------|
  48. | **Prompt** | Skills inject relevant context; hooks add system reminders |
  49. | **Tools** | TLDR reduces tokens; agents parallelize work |
  50. | **Context** | Not just *what* Claude knows, but *how* it's provided |
  51. | **Memory** | Daemon extracts learnings; recall surfaces them |
  52. | **Model** | Becomes swappable when the other four are solid |
  53. ### Anti-Complexity
  54. We resist plugin sprawl. Every MCP, subscription, and tool you add promises improvement but risks breaking context, tools, or prompts through clashes.
  55. **Our approach:**
  56. - **Time, not money** — No required paid services. Perplexity and NIA are optional, high-value-per-token.
  57. - **Learn, don't accumulate** — A system that learns handles edge cases better than one that collects plugins.
  58. - **Shift-left validation** — Hooks run pyright/ruff after edits, catching errors before tests.
  59. 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.
  60. ---
  61. ## How to Talk to Claude
  62. **You don't need to memorize slash commands.** Just describe what you want naturally.
  63. ### The Skill Activation System
  64. 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.
  65. ```
  66. > "Fix the login bug in auth.py"
  67. 🎯 SKILL ACTIVATION CHECK
  68. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  69. ⚠️ CRITICAL SKILLS (REQUIRED):
  70. → create_handoff
  71. 📚 RECOMMENDED SKILLS:
  72. → fix
  73. → debug
  74. 🤖 RECOMMENDED AGENTS (token-efficient):
  75. → debug-agent
  76. → scout
  77. ACTION: Use Skill tool BEFORE responding
  78. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  79. ```
  80. ### Priority Levels
  81. | Level | Meaning |
  82. |-------|---------|
  83. | ⚠️ **CRITICAL** | Must use (e.g., handoffs before ending session) |
  84. | 📚 **RECOMMENDED** | Should use (e.g., workflow skills) |
  85. | 💡 **SUGGESTED** | Consider using (e.g., optimization tools) |
  86. | 📌 **OPTIONAL** | Nice to have (e.g., documentation helpers) |
  87. ### Natural Language Examples
  88. | What You Say | What Activates |
  89. |--------------|----------------|
  90. | "Fix the broken login" | `/fix` workflow → debug-agent, scout |
  91. | "Build a user dashboard" | `/build` workflow → plan-agent, kraken |
  92. | "I want to understand this codebase" | `/explore` + scout agent |
  93. | "What could go wrong with this plan?" | `/premortem` |
  94. | "Help me figure out what I need" | `/discovery-interview` |
  95. | "Done for today" | `create_handoff` (critical) |
  96. | "Resume where we left off" | `resume_handoff` |
  97. | "Research auth patterns" | oracle agent + perplexity |
  98. | "Find all usages of this API" | scout agent + ast-grep |
  99. ### Why This Approach?
  100. | Benefit | How |
  101. |---------|-----|
  102. | **More Discoverable** | Don't need to know commands exist |
  103. | **Context-Aware** | System knows when you're 90% through context |
  104. | **Reduces Cognitive Load** | Describe intent naturally, get curated suggestions |
  105. | **Power User Friendly** | Still supports /fix, /build, etc. directly |
  106. ### Skill vs Workflow vs Agent
  107. | Type | Purpose | Example |
  108. |------|---------|---------|
  109. | **Skill** | Single-purpose tool | `commit`, `tldr-code`, `qlty-check` |
  110. | **Workflow** | Multi-step process | `/fix` (sleuth → premortem → kraken → commit) |
  111. | **Agent** | Specialized sub-session | scout (exploration), oracle (research) |
  112. [See detailed skill activation docs →](docs/skill-activation.md)
  113. ---
  114. ## Quick Start
  115. ### Prerequisites
  116. - Python 3.11+
  117. - [uv](https://github.com/astral-sh/uv) package manager
  118. - Docker (for PostgreSQL)
  119. - Claude Code CLI
  120. ### Installation
  121. ```bash
  122. # Clone
  123. git clone https://github.com/parcadei/Continuous-Claude-v3.git
  124. cd Continuous-Claude-v3/opc
  125. # Run setup wizard (12 steps)
  126. uv run python -m scripts.setup.wizard
  127. ```
  128. > **Note:** The `pyproject.toml` is in `opc/`. Always run `uv` commands from the `opc/` directory.
  129. ### What the Wizard Does
  130. | Step | What It Does |
  131. |------|--------------|
  132. | 1 | Backup existing .claude/ config (if present) |
  133. | 2 | Check prerequisites (Docker, Python, uv) |
  134. | 3-5 | Database + API key configuration |
  135. | 6-7 | Start Docker stack, run migrations |
  136. | 8 | Install Claude Code integration (32 agents, 109 skills, 30 hooks) |
  137. | 9 | Math features (SymPy, Z3, Pint - optional) |
  138. | 10 | TLDR code analysis tool |
  139. | 11-12 | Diagnostics tools + Loogle (optional) |
  140. #### To Uninstall:
  141. ```
  142. cd Continuous-Claude-v3/opc
  143. uv run python -m scripts.setup.wizard --uninstall
  144. ```
  145. **What it does**
  146. 1. Archives your current setup → Moves ~/.claude to ~/.claude-v3.archived.<timestamp>
  147. 2. Restores your backup → Finds the most recent ~/.claude.backup.* (created during install) and restores it
  148. 3. Preserves user data → Copies these back from the archive:
  149. - history.jsonl (your command history)
  150. - mcp_config.json (MCP servers)
  151. - .env (API keys)
  152. - projects.json (project configs)
  153. - file-history/ directory
  154. - projects/ directory
  155. 4. Removes CC-v3 additions → Everything else (hooks, skills, agents, rules)
  156. **Safety Features**
  157. - Your current setup is archived with timestamp - nothing gets deleted
  158. - The wizard asks for confirmation before proceeding
  159. - It restores from the backup that was made during installation
  160. - All your Claude Code settings stay intact
  161. ### Remote Database Setup
  162. By default, CC-v3 runs PostgreSQL locally via Docker. For remote database setups:
  163. #### 1. Database Preparation
  164. ```bash
  165. # Connect to your remote PostgreSQL instance
  166. psql -h hostname -U user -d continuous_claude
  167. # Enable pgvector extension (requires superuser or rds_superuser)
  168. CREATE EXTENSION IF NOT EXISTS vector;
  169. # Apply the schema (from your local clone)
  170. psql -h hostname -U user -d continuous_claude -f docker/init-schema.sql
  171. ```
  172. > **Managed PostgreSQL tips:**
  173. > - **AWS RDS**: Add `vector` to `shared_preload_libraries` in DB Parameter Group
  174. > - **Supabase**: Enable via Database Extensions page
  175. > - **Azure Database**: Use Extensions pane to enable pgvector
  176. #### 2. Connection Configuration
  177. Set `CONTINUOUS_CLAUDE_DB_URL` in `~/.claude/settings.json`:
  178. ```json
  179. {
  180. "env": {
  181. "CONTINUOUS_CLAUDE_DB_URL": "postgresql://user:password@hostname:5432/continuous_claude"
  182. }
  183. }
  184. ```
  185. Or export before running Claude:
  186. ```bash
  187. export CONTINUOUS_CLAUDE_DB_URL="postgresql://user:password@hostname:5432/continuous_claude"
  188. claude
  189. ```
  190. See `.env.example` for all available environment variables.
  191. ### First Session
  192. ```bash
  193. # Start Claude Code
  194. claude
  195. # Try a workflow
  196. > /workflow
  197. ```
  198. ### First Session Commands
  199. | Command | What it does |
  200. |---------|--------------|
  201. | `/workflow` | Goal-based routing (Research/Plan/Build/Fix) |
  202. | `/fix bug <description>` | Investigate and fix a bug |
  203. | `/build greenfield <feature>` | Build a new feature from scratch |
  204. | `/explore` | Understand the codebase |
  205. | `/premortem` | Risk analysis before implementation |
  206. ---
  207. ## Architecture
  208. ```
  209. ┌─────────────────────────────────────────────────────────────────────┐
  210. │ CONTINUOUS CLAUDE │
  211. ├─────────────────────────────────────────────────────────────────────┤
  212. │ │
  213. │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
  214. │ │ Skills │ │ Agents │ │ Hooks │ │
  215. │ │ (109) │───▶│ (32) │◀───│ (30) │ │
  216. │ └─────────────┘ └─────────────┘ └─────────────┘ │
  217. │ │ │ │ │
  218. │ ▼ ▼ ▼ │
  219. │ ┌─────────────────────────────────────────────────────────────┐ │
  220. │ │ TLDR Code Analysis │ │
  221. │ │ L1:AST → L2:CallGraph → L3:CFG → L4:DFG → L5:Slicing │ │
  222. │ │ (95% token savings) │ │
  223. │ └─────────────────────────────────────────────────────────────┘ │
  224. │ │ │ │ │
  225. │ ▼ ▼ ▼ │
  226. │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
  227. │ │ Memory │ │ Continuity │ │ Coordination│ │
  228. │ │ System │ │ Ledgers │ │ Layer │ │
  229. │ └─────────────┘ └─────────────┘ └─────────────┘ │
  230. │ │
  231. └─────────────────────────────────────────────────────────────────────┘
  232. ```
  233. ### Data Flow: Session Lifecycle
  234. ```
  235. SessionStart Working SessionEnd
  236. │ │ │
  237. ▼ ▼ ▼
  238. ┌─────────┐ ┌─────────┐ ┌─────────┐
  239. │ Load │ │ Track │ │ Save │
  240. │ context │─────────────────▶│ changes │──────────────────▶│ state │
  241. └─────────┘ └─────────┘ └─────────┘
  242. │ │ │
  243. ├── Continuity ledger ├── File claims ├── Handoff
  244. ├── Memory recall ├── TLDR indexing ├── Learnings
  245. └── Symbol index └── Blackboard └── Outcome
  246. │
  247. ▼
  248. ┌─────────┐
  249. │ /clear │
  250. │ Fresh │
  251. │ context │
  252. └─────────┘
  253. ```
  254. ### The Continuity Loop (Detailed)
  255. ```
  256. ┌─────────────────────────────────────────────────────────────────────────────┐
  257. │ THE CONTINUITY LOOP │
  258. └─────────────────────────────────────────────────────────────────────────────┘
  259. 1. SESSION START 2. WORKING
  260. ┌────────────────────┐ ┌────────────────────┐
  261. │ │ │ │
  262. │ Ledger loaded ────┼──▶ Context │ PostToolUse ──────┼──▶ Index handoffs
  263. │ Handoff loaded │ │ UserPrompt ───────┼──▶ Skill hints
  264. │ Memory recalled │ │ Edit tracking ────┼──▶ Dirty flag++
  265. │ TLDR cache warmed │ │ SubagentStop ─────┼──▶ Agent reports
  266. │ │ │ │
  267. └────────────────────┘ └────────────────────┘
  268. │ │
  269. │ ▼
  270. │ ┌────────────────────┐
  271. │ │ 3. PRE-COMPACT │
  272. │ │ │
  273. │ │ Auto-handoff ─────┼──▶ thoughts/shared/
  274. │ │ (YAML format) │ handoffs/*.yaml
  275. │ │ Dirty > 20? ──────┼──▶ TLDR re-index
  276. │ │ │
  277. │ └────────────────────┘
  278. │ │
  279. │ ▼
  280. │ ┌────────────────────┐
  281. │ │ 4. SESSION END │
  282. │ │ │
  283. │ │ Stale heartbeat ──┼──▶ Daemon wakes
  284. │ │ Daemon spawns ────┼──▶ Headless Claude
  285. │ │ Thinking blocks ──┼──▶ archival_memory
  286. │ │ │
  287. │ └────────────────────┘
  288. │ │
  289. │ │
  290. └──────────────◀────── /clear ◀──────┘
  291. Fresh context + state preserved
  292. ```
  293. ### Workflow Chains
  294. ```
  295. ┌─────────────────────────────────────────────────────────────────────────────┐
  296. │ META-SKILL WORKFLOWS │
  297. └─────────────────────────────────────────────────────────────────────────────┘
  298. /fix bug /build greenfield
  299. ───────── ─────────────────
  300. ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
  301. │ sleuth │─▶│ premortem│ │discovery │─▶│plan-agent│
  302. │(diagnose)│ │ (risk) │ │(clarify) │ │ (design) │
  303. └──────────┘ └────┬─────┘ └──────────┘ └────┬─────┘
  304. │ │
  305. ▼ ▼
  306. ┌──────────┐ ┌──────────┐
  307. │ kraken │ │ validate │
  308. │ (fix) │ │ (check) │
  309. └────┬─────┘ └────┬─────┘
  310. │ │
  311. ▼ ▼
  312. ┌──────────┐ ┌──────────┐
  313. │ arbiter │ │ kraken │
  314. │ (test) │ │(implement│
  315. └────┬─────┘ └────┬─────┘
  316. │ │
  317. ▼ ▼
  318. ┌──────────┐ ┌──────────┐
  319. │ commit │ │ commit │
  320. └──────────┘ └──────────┘
  321. /tdd /refactor
  322. ──── ─────────
  323. ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
  324. │plan-agent│─▶│ arbiter │ │ phoenix │─▶│ warden │
  325. │ (design) │ │(tests 🔴)│ │(analyze) │ │ (review) │
  326. └──────────┘ └────┬─────┘ └──────────┘ └────┬─────┘
  327. │ │
  328. ▼ ▼
  329. ┌──────────┐ ┌──────────┐
  330. │ kraken │ │ kraken │
  331. │(code 🟢) │ │(transform│
  332. └────┬─────┘ └────┬─────┘
  333. │ │
  334. ▼ ▼
  335. ┌──────────┐ ┌──────────┐
  336. │ arbiter │ │ judge │
  337. │(verify ✓)│ │ (review) │
  338. └──────────┘ └──────────┘
  339. ```
  340. ### Data Layer Architecture
  341. ```
  342. ┌─────────────────────────────────────────────────────────────────────────────┐
  343. │ DATA LAYER ARCHITECTURE │
  344. ├─────────────────────────────────────────────────────────────────────────────┤
  345. │ │
  346. │ TLDR 5-LAYER CODE ANALYSIS SEMANTIC INDEX │
  347. │ ┌────────────────────────┐ ┌────────────────────────┐ │
  348. │ │ L1: AST (~500 tok) │ │ BGE-large-en-v1.5 │ │
  349. │ │ └── Functions, │ │ ├── All 5 layers │ │
  350. │ │ classes, sigs │ │ ├── 10 lines context │ │
  351. │ │ │ │ └── FAISS index │ │
  352. │ │ L2: Call Graph (+440) │ │ │ │
  353. │ │ └── Cross-file │──────────────│ Query: "auth logic" │ │
  354. │ │ dependencies │ │ Returns: ranked funcs │ │
  355. │ │ │ └────────────────────────┘ │
  356. │ │ L3: CFG (+110 tok) │ │
  357. │ │ └── Control flow │ │
  358. │ │ │ MEMORY (PostgreSQL+pgvector) │
  359. │ │ L4: DFG (+130 tok) │ ┌────────────────────────┐ │
  360. │ │ └── Data flow │ │ sessions (heartbeat) │ │
  361. │ │ │ │ file_claims (locks) │ │
  362. │ │ L5: PDG (+150 tok) │ │ archival_memory (BGE) │ │
  363. │ │ └── Slicing │ │ handoffs (embeddings) │ │
  364. │ └────────────────────────┘ └────────────────────────┘ │
  365. │ ~1,200 tokens │
  366. │ vs 23,000 raw │
  367. │ = 95% savings FILE SYSTEM │
  368. │ ┌────────────────────────┐ │
  369. │ │ thoughts/ │ │
  370. │ │ ├── ledgers/ │ │
  371. │ │ │ └── CONTINUITY_*.md│ │
  372. │ │ └── shared/ │ │
  373. │ │ ├── handoffs/*.yaml│ │
  374. │ │ └── plans/*.md │ │
  375. │ │ │ │
  376. │ │ .tldr/ │ │
  377. │ │ └── (daemon cache) │ │
  378. │ └────────────────────────┘ │
  379. │ │
  380. └─────────────────────────────────────────────────────────────────────────────┘
  381. ```
  382. ---
  383. ## Core Systems
  384. ### Skills System
  385. Skills are modular capabilities triggered by natural language. Located in `.claude/skills/`.
  386. #### Meta-Skills (Workflow Orchestrators)
  387. | Meta-Skill | Chain | Use When |
  388. |------------|-------|----------|
  389. | `/workflow` | Router → appropriate workflow | Don't know where to start |
  390. | `/build` | discovery → plan → validate → implement → commit | Building features |
  391. | `/fix` | sleuth → premortem → kraken → test → commit | Fixing bugs |
  392. | `/tdd` | plan → arbiter (tests) → kraken (implement) → arbiter | Test-first development |
  393. | `/refactor` | phoenix → plan → kraken → reviewer → arbiter | Safe code transformation |
  394. | `/review` | parallel specialized reviews → synthesis | Code review |
  395. | `/explore` | scout (quick/deep/architecture) | Understand codebase |
  396. | `/security` | vulnerability scan → verification | Security audits |
  397. | `/release` | audit → E2E → review → changelog | Ship releases |
  398. #### Meta-Skill Reference
  399. Each meta-skill supports modes, scopes, and flags. Type the skill alone (e.g., `/build`) to get an interactive question flow.
  400. **`/build <mode> [options] [description]`**
  401. | Mode | Chain | Use For |
  402. |------|-------|---------|
  403. | `greenfield` | discovery → plan → validate → implement → commit → PR | New feature from scratch |
  404. | `brownfield` | onboard → research → plan → validate → implement | Feature in existing codebase |
  405. | `tdd` | plan → test-first → implement | Test-driven development |
  406. | `refactor` | impact analysis → plan → TDD → implement | Safe refactoring |
  407. | Option | Effect |
  408. |--------|--------|
  409. | `--skip-discovery` | Skip interview phase (have clear spec) |
  410. | `--skip-validate` | Skip plan validation |
  411. | `--skip-commit` | Don't auto-commit |
  412. | `--skip-pr` | Don't create PR description |
  413. | `--parallel` | Run research agents in parallel |
  414. **`/fix <scope> [options] [description]`**
  415. | Scope | Chain | Use For |
  416. |-------|-------|---------|
  417. | `bug` | debug → implement → test → commit | General bug fix |
  418. | `hook` | debug-hooks → hook-developer → implement → test | Hook issues |
  419. | `deps` | preflight → oracle → plan → implement → qlty | Dependency errors |
  420. | `pr-comments` | github-search → research → plan → implement → commit | PR feedback |
  421. | Option | Effect |
  422. |--------|--------|
  423. | `--no-test` | Skip regression test |
  424. | `--dry-run` | Diagnose only, don't fix |
  425. | `--no-commit` | Don't auto-commit |
  426. **`/explore <depth> [options]`**
  427. | Depth | Time | What It Does |
  428. |-------|------|--------------|
  429. | `quick` | ~1 min | tldr tree + structure overview |
  430. | `deep` | ~5 min | onboard + tldr + research + documentation |
  431. | `architecture` | ~3 min | tldr arch + call graph + layers |
  432. | Option | Effect |
  433. |--------|--------|
  434. | `--focus "area"` | Focus on specific area (e.g., `--focus "auth"`) |
  435. | `--output handoff` | Create handoff for implementation |
  436. | `--output doc` | Create documentation file |
  437. | `--entry "func"` | Start from specific entry point |
  438. **`/tdd`, `/refactor`, `/review`, `/security`, `/release`**
  439. These follow their defined chains without mode flags. Just run:
  440. ```
  441. /tdd "implement retry logic"
  442. /refactor "extract auth module"
  443. /review # reviews current changes
  444. /security "authentication code"
  445. /release v1.2.0
  446. ```
  447. #### Key Skills (High-Value Tools)
  448. **Planning & Risk**
  449. - **premortem**: TIGERS & ELEPHANTS risk analysis - use before any significant implementation
  450. - **discovery-interview**: Transform vague ideas into detailed specs
  451. **Context Management**
  452. - **create_handoff**: Capture session state for transfer
  453. - **resume_handoff**: Resume from handoff with context
  454. - **continuity_ledger**: Track state within session
  455. **Code Analysis (95% Token Savings)**
  456. - **tldr-code**: Call graph, CFG, DFG, slicing
  457. - **ast-grep-find**: Structural code search
  458. - **morph-search**: Fast text search (20x faster than grep)
  459. **Research**
  460. - **perplexity-search**: AI-powered web search
  461. - **nia-docs**: Library documentation search
  462. - **github-search**: Search GitHub code/issues/PRs
  463. **Quality**
  464. - **qlty-check**: 70+ linters, auto-fix
  465. - **braintrust-analyze**: Session analysis, replay, and debugging failed sessions
  466. **Math & Formal Proofs**
  467. - **math**: Unified computation (SymPy, Z3, Pint) — one entry point for all math
  468. - **prove**: Lean4 theorem proving with 5-phase workflow (Research → Design → Test → Implement → Verify)
  469. - **pint-compute**: Unit-aware arithmetic and conversions
  470. - **shapely-compute**: Computational geometry
  471. The `/prove` skill enables machine-verified proofs without learning Lean syntax. Used to create the first Lean formalization of Sylvester-Gallai theorem.
  472. #### The Thought Process
  473. ```
  474. What do I want to do?
  475. ├── Don't know → /workflow (guided router)
  476. ├── Building → /build greenfield or brownfield
  477. ├── Fixing → /fix bug
  478. ├── Understanding → /explore
  479. ├── Planning → premortem first, then plan-agent
  480. ├── Researching → oracle or perplexity-search
  481. ├── Reviewing → /review
  482. ├── Proving → /prove (Lean4 formal verification)
  483. ├── Computing → /math (SymPy, Z3, Pint)
  484. └── Shipping → /release
  485. ```
  486. [See detailed skills breakdown →](docs/skills/)
  487. ---
  488. ### Agents System
  489. Agents are specialized AI workers spawned via the Task tool. Located in `.claude/agents/`.
  490. #### Agent Categories (32 active)
  491. > **Note:** There are likely too many agents—consolidation is a v4 goal. Use what fits your workflow.
  492. **Orchestrators (2)**
  493. - **maestro**: Multi-agent coordination with patterns (Pipeline, Swarm, Jury)
  494. - **kraken**: TDD implementation agent with checkpoint/resume support
  495. **Planners (4)**
  496. - **architect**: Feature planning + API integration
  497. - **phoenix**: Refactoring + framework migration planning
  498. - **plan-agent**: Lightweight planning with research/MCP tools
  499. - **validate-agent**: Validate plans against best practices
  500. **Explorers (4)**
  501. - **scout**: Codebase exploration (use instead of Explore)
  502. - **oracle**: External research (web, docs, APIs)
  503. - **pathfinder**: External repository analysis
  504. - **research-codebase**: Document codebase as-is
  505. **Implementers (3)**
  506. - **kraken**: TDD implementation with strict test-first workflow
  507. - **spark**: Lightweight fixes and quick tweaks
  508. - **agentica-agent**: Build Python agents using Agentica SDK
  509. **Debuggers (3)**
  510. - **sleuth**: General bug investigation and root cause
  511. - **debug-agent**: Issue investigation via logs/code search
  512. - **profiler**: Performance profiling and race conditions
  513. **Validators (2)** - arbiter, atlas
  514. **Reviewers (6)** - critic, judge, surveyor, liaison, plan-reviewer, review-agent
  515. **Specialized (8)** - aegis, herald, scribe, chronicler, session-analyst, braintrust-analyst, memory-extractor, onboard
  516. #### Common Workflows
  517. | Workflow | Agent Chain |
  518. |----------|-------------|
  519. | Feature | architect → plan-reviewer → kraken → review-agent → arbiter |
  520. | Refactoring | phoenix → plan-reviewer → kraken → judge → arbiter |
  521. | Bug Fix | sleuth → spark/kraken → arbiter → scribe |
  522. [See detailed agent guide →](docs/agents/)
  523. ---
  524. ### Hooks System
  525. Hooks intercept Claude Code at lifecycle points. Located in `.claude/hooks/`.
  526. #### Hook Events (30 hooks total)
  527. | Event | Key Hooks | Purpose |
  528. |-------|-----------|---------|
  529. | **SessionStart** | session-start-continuity, session-register, braintrust-tracing | Load context, register session |
  530. | **PreToolUse** | tldr-read-enforcer, smart-search-router, tldr-context-inject, file-claims | Token savings, search routing |
  531. | **PostToolUse** | post-edit-diagnostics, handoff-index, post-edit-notify | Validation, indexing |
  532. | **PreCompact** | pre-compact-continuity | Auto-save before compaction |
  533. | **UserPromptSubmit** | skill-activation-prompt, memory-awareness | Skill hints, memory recall |
  534. | **SubagentStop** | subagent-stop-continuity | Save agent state |
  535. | **SessionEnd** | session-end-cleanup, session-outcome | Cleanup, extract learnings |
  536. #### Key Hooks
  537. | Hook | Purpose |
  538. |------|---------|
  539. | **tldr-context-inject** | Adds code analysis to agent prompts |
  540. | **smart-search-router** | Routes grep to AST-grep when appropriate |
  541. | **post-edit-diagnostics** | Runs pyright/ruff after edits |
  542. | **memory-awareness** | Surfaces relevant learnings |
  543. [See all 30 hooks →](docs/hooks/)
  544. ---
  545. ### TLDR Code Analysis
  546. TLDR provides token-efficient code summaries through 5 analysis layers.
  547. #### The 5-Layer Stack
  548. | Layer | Name | What it provides | Tokens |
  549. |-------|------|------------------|--------|
  550. | **L1** | AST | Functions, classes, signatures | ~500 tokens |
  551. | **L2** | Call Graph | Who calls what (cross-file) | +440 tokens |
  552. | **L3** | CFG | Control flow, complexity | +110 tokens |
  553. | **L4** | DFG | Data flow, variable tracking | +130 tokens |
  554. | **L5** | PDG | Program slicing, impact analysis | +150 tokens |
  555. **Total: ~1,200 tokens vs 23,000 raw = 95% savings**
  556. #### CLI Commands
  557. ```bash
  558. # Structure analysis
  559. tldr tree src/ # File tree
  560. tldr structure src/ --lang python # Code structure (codemaps)
  561. # Search and extraction
  562. tldr search "process_data" src/ # Find code
  563. tldr context process_data --project src/ --depth 2 # LLM-ready context
  564. # Flow analysis
  565. tldr cfg src/main.py main # Control flow graph
  566. tldr dfg src/main.py main # Data flow graph
  567. tldr slice src/main.py main 42 # What affects line 42?
  568. # Codebase analysis
  569. tldr impact process_data src/ # Who calls this function?
  570. tldr dead src/ # Find unreachable code
  571. tldr arch src/ # Detect architectural layers
  572. # Semantic search (natural language)
  573. tldr daemon semantic "find authentication logic"
  574. ```
  575. #### Semantic Index
  576. Beyond structural analysis, TLDR builds a **semantic index** of your codebase:
  577. - **Natural language queries** — Ask "where is error handling?" instead of grepping
  578. - **Auto-rebuild** — Dirty flag hook tracks file changes; index rebuilds after N edits
  579. - **Selective indexing** — Use `.tldrignore` to control what gets indexed
  580. ```bash
  581. # .tldrignore example
  582. __pycache__/
  583. *.test.py
  584. node_modules/
  585. .venv/
  586. ```
  587. The semantic index uses all 5 layers plus 10 lines of surrounding code context—not just docstrings.
  588. #### Hook Integration
  589. TLDR is automatically integrated via hooks:
  590. - **tldr-read-enforcer**: Returns L1+L2+L3 instead of full file reads
  591. - **smart-search-router**: Routes Grep to `tldr search`
  592. - **post-tool-use-tracker**: Updates indexes when files change
  593. [See TLDR documentation →](opc/packages/tldr-code/)
  594. ---
  595. ### Memory System
  596. Cross-session learning powered by PostgreSQL + pgvector.
  597. #### How It Works
  598. ```
  599. Session ends → Database detects stale heartbeat (>5 min)
  600. → Daemon spawns headless Claude (Sonnet)
  601. → Analyzes thinking blocks from session
  602. → Extracts learnings to archival_memory
  603. → Next session recalls relevant learnings
  604. ```
  605. The key insight: **thinking blocks contain the real reasoning**—not just what Claude did, but why. The daemon extracts this automatically.
  606. #### Conversational Interface
  607. | What You Say | What Happens |
  608. |--------------|--------------|
  609. | "Remember that auth uses JWT" | Stores learning with context |
  610. | "Recall authentication patterns" | Searches memory, surfaces matches |
  611. | "What did we decide about X?" | Implicit recall via memory-awareness hook |
  612. #### Database Schema (4 tables)
  613. | Table | Purpose |
  614. |-------|---------|
  615. | **sessions** | Cross-terminal awareness |
  616. | **file_claims** | Cross-terminal file locking |
  617. | **archival_memory** | Long-term learnings with BGE embeddings |
  618. | **handoffs** | Session handoffs with embeddings |
  619. #### Recall Commands
  620. ```bash
  621. # Recall learnings (hybrid text + vector search)
  622. cd opc && uv run python scripts/core/recall_learnings.py \
  623. --query "authentication patterns"
  624. # Store a learning explicitly
  625. cd opc && uv run python scripts/core/store_learning.py \
  626. --session-id "my-session" \
  627. --type WORKING_SOLUTION \
  628. --content "What I learned" \
  629. --confidence high
  630. ```
  631. #### Automatic Memory
  632. The **memory-awareness** hook surfaces relevant learnings when you send a message. You'll see `MEMORY MATCH` indicators—Claude can use these without you asking.
  633. ---
  634. ### Continuity System
  635. Preserve state across context clears and sessions.
  636. #### Continuity Ledger
  637. Within-session state tracking. Location: `thoughts/ledgers/CONTINUITY_<topic>.md`
  638. ```markdown
  639. # Session: feature-x
  640. Updated: 2026-01-08
  641. ## Goal
  642. Implement feature X with proper error handling
  643. ## Completed
  644. - [x] Designed API schema
  645. - [x] Implemented core logic
  646. ## In Progress
  647. - [ ] Add error handling
  648. ## Blockers
  649. - Need clarification on retry policy
  650. ```
  651. #### Handoffs
  652. Between-session knowledge transfer. Location: `thoughts/shared/handoffs/<session>/`
  653. ```yaml
  654. ---
  655. date: 2026-01-08T15:26:01+0000
  656. session_name: feature-x
  657. status: complete
  658. ---
  659. # Handoff: Feature X Implementation
  660. ## Task(s)
  661. | Task | Status |
  662. |------|--------|
  663. | Design API | Completed |
  664. | Implement core | Completed |
  665. | Error handling | Pending |
  666. ## Next Steps
  667. 1. Add retry logic to API calls
  668. 2. Write integration tests
  669. ```
  670. #### Commands
  671. | Command | Effect |
  672. |---------|--------|
  673. | "save state" | Updates continuity ledger |
  674. | "done for today" / `/handoff` | Creates handoff document |
  675. | "resume work" | Loads latest handoff |
  676. ---
  677. ### Math System
  678. Two capabilities: **computation** (SymPy, Z3, Pint) and **formal verification** (Lean4 + Mathlib).
  679. #### The Stack
  680. | Tool | Purpose | Example |
  681. |------|---------|---------|
  682. | **SymPy** | Symbolic math | Solve equations, integrals, matrix operations |
  683. | **Z3** | Constraint solving | Prove inequalities, SAT problems |
  684. | **Pint** | Unit conversion | Convert miles to km, dimensional analysis |
  685. | **Lean4** | Formal proofs | Machine-verified theorems |
  686. | **Mathlib** | 100K+ theorems | Pre-formalized lemmas to build on |
  687. | **Loogle** | Type-aware search | Find Mathlib lemmas by signature |
  688. #### Two Entry Points
  689. | Skill | Use When |
  690. |-------|----------|
  691. | `/math` | Computing, solving, calculating |
  692. | `/prove` | Formal verification, machine-checked proofs |
  693. #### /math Examples
  694. ```bash
  695. # Solve equation
  696. "Solve x² - 4 = 0" → x = ±2
  697. # Compute eigenvalues
  698. "Eigenvalues of [[2,1],[1,2]]" → {1: 1, 3: 1}
  699. # Prove inequality
  700. "Is x² + y² ≥ 2xy always true?" → PROVED (equals (x-y)²)
  701. # Convert units
  702. "26.2 miles to km" → 42.16 km
  703. ```
  704. #### /prove - Formal Verification
  705. 5-phase workflow for machine-verified proofs:
  706. ```
  707. 📚 RESEARCH → 🏗️ DESIGN → 🧪 TEST → ⚙️ IMPLEMENT → ✅ VERIFY
  708. ```
  709. 1. **Research**: Search Mathlib with Loogle, find proof strategy
  710. 2. **Design**: Create skeleton with `sorry` placeholders
  711. 3. **Test**: Search for counterexamples before proving
  712. 4. **Implement**: Fill sorries with compiler-in-the-loop feedback
  713. 5. **Verify**: Audit axioms, confirm zero sorries
  714. ```
  715. /prove every group homomorphism preserves identity
  716. /prove continuous functions on compact sets are uniformly continuous
  717. ```
  718. **Achievement**: Used to create the first Lean formalization of the Sylvester-Gallai theorem.
  719. #### Prerequisites (Optional)
  720. Math features require installation via wizard step 9:
  721. ```bash
  722. # Installed automatically by wizard
  723. uv pip install sympy z3-solver pint shapely
  724. # Lean4 (for /prove)
  725. curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 949 on GitHub
  726. ```
  727. ---
  728. ## Workflows
  729. ### /workflow - Goal-Based Router
  730. ```
  731. > /workflow
  732. ? What's your goal?
  733. ○ Research - Understand codebase/docs
  734. ○ Plan - Design implementation approach
  735. ○ Build - Implement features
  736. ○ Fix - Investigate and resolve issues
  737. ```
  738. ### /fix - Bug Resolution
  739. ```bash
  740. /fix bug "login fails silently"
  741. ```
  742. **Chain:** sleuth → [checkpoint] → [premortem] → kraken → test → commit
  743. | Scope | What it does |
  744. |-------|--------------|
  745. | `bug` | General bug investigation |
  746. | `hook` | Hook-specific debugging |
  747. | `deps` | Dependency issues |
  748. | `pr-comments` | Address PR feedback |
  749. ### /build - Feature Development
  750. ```bash
  751. /build greenfield "user dashboard"
  752. ```
  753. **Chain:** discovery → plan → validate → implement → commit → PR
  754. | Mode | What it does |
  755. |------|--------------|
  756. | `greenfield` | New feature from scratch |
  757. | `brownfield` | Modify existing codebase |
  758. | `tdd` | Test-first development |
  759. | `refactor` | Safe code transformation |
  760. ### /premortem - Risk Analysis
  761. ```bash
  762. /premortem deep thoughts/shared/plans/feature-x.md
  763. ```
  764. **Output:**
  765. - **TIGERS**: Clear threats (HIGH/MEDIUM/LOW severity)
  766. - **ELEPHANTS**: Unspoken concerns
  767. Blocks on HIGH severity until user accepts/mitigates risks.
  768. ---
  769. ## Installation
  770. ### Full Installation (Recommended)
  771. ```bash
  772. # Clone
  773. git clone https://github.com/parcadei/continuous-claude.git
  774. cd continuous-claude/opc
  775. # Run the setup wizard
  776. uv run python -m scripts.setup.wizard
  777. ```
  778. The wizard walks you through all configuration options interactively.
  779. ## Updating
  780. Pull latest changes and sync your installation:
  781. ```bash
  782. cd continuous-claude/opc
  783. uv run python -m scripts.setup.update
  784. ```
  785. This will:
  786. - Pull latest from GitHub
  787. - Update hooks, skills, rules, agents
  788. - Upgrade TLDR if installed
  789. - Rebuild TypeScript hooks if changed
  790. ### What Gets Installed
  791. | Component | Location |
  792. |-----------|----------|
  793. | Agents (32) | ~/.claude/agents/ |
  794. | Skills (109) | ~/.claude/skills/ |
  795. | Hooks (30) | ~/.claude/hooks/ |
  796. | Rules | ~/.claude/rules/ |
  797. | Scripts | ~/.claude/scripts/ |
  798. | PostgreSQL | Docker container |
  799. ### Installation Mode: Copy vs Symlink
  800. The wizard offers two installation modes:
  801. | Mode | How It Works | Best For |
  802. |------|--------------|----------|
  803. | **Copy** (default) | Copies files from repo to `~/.claude/` | End users, stable setup |
  804. | **Symlink** | Creates symlinks to repo files | Contributors, development |
  805. #### Copy Mode (Default)
  806. Files are copied from `continuous-claude/.claude/` to `~/.claude/`. Changes you make in `~/.claude/` are **local only** and will be overwritten on next update.
  807. ```text
  808. continuous-claude/.claude/ ──COPY──> ~/.claude/
  809. (source) (user config)
  810. ```
  811. **Pros:** Stable, isolated from repo changes
  812. **Cons:** Local changes lost on update, manual sync needed
  813. #### Symlink Mode (Recommended for Contributors)
  814. Creates symlinks so `~/.claude/` points directly to repo files. Changes in either location affect the same files.
  815. ```text
  816. ~/.claude/rules ──SYMLINK──> continuous-claude/.claude/rules
  817. ~/.claude/skills ──SYMLINK──> continuous-claude/.claude/skills
  818. ~/.claude/hooks ──SYMLINK──> continuous-claude/.claude/hooks
  819. ~/.claude/agents ──SYMLINK──> continuous-claude/.claude/agents
  820. ```
  821. **Pros:**
  822. - Changes auto-sync to repo (can `git commit` improvements)
  823. - No re-installation needed after `git pull`
  824. - Contribute back easily
  825. **Cons:**
  826. - Breaking changes in repo affect your setup immediately
  827. - Need to manage git workflow
  828. #### Switching to Symlink Mode
  829. If you installed with copy mode and want to switch:
  830. ```bash
  831. # Backup current config
  832. mkdir -p ~/.claude/backups/$(date +%Y%m%d)
  833. cp -r ~/.claude/{rules,skills,hooks,agents} ~/.claude/backups/$(date +%Y%m%d)/
  834. # Verify backup succeeded before proceeding
  835. ls -la ~/.claude/backups/$(date +%Y%m%d)/
  836. # Remove copies (only after verifying backup above)
  837. rm -rf ~/.claude/{rules,skills,hooks,agents}
  838. # Create symlinks (adjust path to your repo location)
  839. REPO="$HOME/continuous-claude" # or wherever you cloned
  840. ln -s "$REPO/.claude/rules" ~/.claude/rules
  841. ln -s "$REPO/.claude/skills" ~/.claude/skills
  842. ln -s "$REPO/.claude/hooks" ~/.claude/hooks
  843. ln -s "$REPO/.claude/agents" ~/.claude/agents
  844. # Verify
  845. ls -la ~/.claude | grep -E "rules|skills|hooks|agents"
  846. ```
  847. **Windows users:** Use PowerShell (as Administrator or with Developer Mode enabled):
  848. ```powershell
  849. # Enable Developer Mode first (Settings → Privacy & security → For developers)
  850. # Or run PowerShell as Administrator
  851. # Backup current config
  852. $BackupDir = "$HOME\.claude\backups\$(Get-Date -Format 'yyyyMMdd')"
  853. New-Item -ItemType Directory -Path $BackupDir -Force
  854. Copy-Item -Recurse "$HOME\.claude\rules","$HOME\.claude\skills","$HOME\.claude\hooks","$HOME\.claude\agents" $BackupDir
  855. # Verify backup succeeded before proceeding
  856. Get-ChildItem $BackupDir
  857. # Remove copies (only after verifying backup above)
  858. Remove-Item -Recurse "$HOME\.claude\rules","$HOME\.claude\skills","$HOME\.claude\hooks","$HOME\.claude\agents"
  859. # Create symlinks (adjust path to your repo location)
  860. $REPO = "$HOME\continuous-claude" # or wherever you cloned
  861. New-Item -ItemType SymbolicLink -Path "$HOME\.claude\rules" -Target "$REPO\.claude\rules"
  862. New-Item -ItemType SymbolicLink -Path "$HOME\.claude\skills" -Target "$REPO\.claude\skills"
  863. New-Item -ItemType SymbolicLink -Path "$HOME\.claude\hooks" -Target "$REPO\.claude\hooks"
  864. New-Item -ItemType SymbolicLink -Path "$HOME\.claude\agents" -Target "$REPO\.claude\agents"
  865. # Verify
  866. Get-ChildItem "$HOME\.claude" | Where-Object { $_.LinkType -eq "SymbolicLink" }
  867. ```
  868. ### For Brownfield Projects
  869. After installation, start Claude and run:
  870. ```
  871. > /onboard
  872. ```
  873. This analyzes the codebase and creates an initial continuity ledger.
  874. ---
  875. ## Configuration
  876. ### .claude/settings.json
  877. Central configuration for hooks, tools, and workflows.
  878. ```json
  879. {
  880. "hooks": {
  881. "SessionStart": [...],
  882. "PreToolUse": [...],
  883. "PostToolUse": [...],
  884. "UserPromptSubmit": [...]
  885. }
  886. }
  887. ```
  888. ### .claude/skills/skill-rules.json
  889. Skill activation triggers.
  890. ```json
  891. {
  892. "rules": [
  893. {
  894. "skill": "fix",
  895. "keywords": ["fix this", "broken", "not working"],
  896. "intentPatterns": ["fix.*(bug|issue|error)"]
  897. }
  898. ]
  899. }
  900. ```
  901. ### Environment Variables
  902. | Variable | Purpose | Required |
  903. |----------|---------|----------|
  904. | `DATABASE_URL` | PostgreSQL connection string | Yes |
  905. | `BRAINTRUST_API_KEY` | Session tracing | No |
  906. | `PERPLEXITY_API_KEY` | Web search | No |
  907. | `NIA_API_KEY` | Documentation search | No |
  908. | `CLAUDE_OPC_DIR` | Path to CC's opc/ directory (set by wizard) | Auto |
  909. | `CLAUDE_PROJECT_DIR` | Current project directory (set by SessionStart hook) | Auto |
  910. Services without API keys still work:
  911. - Continuity system (ledgers, handoffs)
  912. - TLDR code analysis
  913. - Local git operations
  914. - TDD workflow
  915. ---
  916. ## Directory Structure
  917. ```
  918. continuous-claude/
  919. ├── .claude/
  920. │ ├── agents/ # 32 specialized AI agents
  921. │ ├── hooks/ # 30 lifecycle hooks
  922. │ │ ├── src/ # TypeScript source
  923. │ │ └── dist/ # Compiled JavaScript
  924. │ ├── skills/ # 109 modular capabilities
  925. │ ├── rules/ # System policies
  926. │ ├── scripts/ # Python utilities
  927. │ └── settings.json # Hook configuration
  928. ├── opc/
  929. │ ├── packages/
  930. │ │ └── tldr-code/ # 5-layer code analysis
  931. │ ├── scripts/
  932. │ │ ├── setup/ # Wizard, Docker, integration
  933. │ │ └── core/ # recall_learnings, store_learning
  934. │ └── docker/
  935. │ └── init-schema.sql # 4-table PostgreSQL schema
  936. ├── thoughts/
  937. │ ├── ledgers/ # Continuity ledgers (CONTINUITY_*.md)
  938. │ └── shared/
  939. │ ├── handoffs/ # Session handoffs (*.yaml)
  940. │ └── plans/ # Implementation plans
  941. └── docs/ # Documentation
  942. ```
  943. ---
  944. ## Contributing
  945. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on:
  946. - Adding new skills
  947. - Creating agents
  948. - Developing hooks
  949. - Extending TLDR
  950. ---
  951. ## Acknowledgments
  952. ### Patterns & Architecture
  953. - **[@numman-ali](https://github.com/numman-ali)** - Continuity ledger pattern
  954. - **[Anthropic](https://anthropic.com)** - Claude Code and "Code Execution with MCP"
  955. - **[obra/superpowers](https://github.com/obra/superpowers)** - Agent orchestration patterns
  956. - **[EveryInc/compound-engineering-plugin](https://github.com/EveryInc/compound-engineering-plugin)** - Compound engineering workflow
  957. - **[yoloshii/mcp-code-execution-enhanced](https://github.com/yoloshii/mcp-code-execution-enhanced)** - Enhanced MCP execution
  958. - **[HumanLayer](https://github.com/humanlayer/humanlayer)** - Agent patterns
  959. ### Tools & Services
  960. - **[uv](https://github.com/astral-sh/uv)** - Python packaging
  961. - **[tree-sitter](https://tree-sitter.github.io/)** - Code parsing
  962. - **[Braintrust](https://braintrust.dev)** - LLM evaluation, logging, and session tracing
  963. - **[qlty](https://github.com/qltysh/qlty)** - Universal code quality CLI (70+ linters)
  964. - **[ast-grep](https://github.com/ast-grep/ast-grep)** - AST-based code search and refactoring
  965. - **[Nia](https://trynia.ai)** - Library documentation search
  966. - **[Morph](https://www.morphllm.com)** - WarpGrep fast code search
  967. - **[Firecrawl](https://www.firecrawl.dev)** - Web scraping API
  968. - **[RepoPrompt](https://repoprompt.com)** - Token-efficient codebase maps
  969. ---
  970. ## Star History
  971. [![Star History Chart](https://api.star-history.com/svg?repos=parcadei/Continuous-Claude-v2&type=timeline)](https://star-history.com/#parcadei/Continuous-Claude-v2&Date)
  972. ---
  973. ## License
  974. [MIT](LICENSE) - Use freely, contribute back.
  975. ---
  976. **Continuous Claude**: Not just a coding assistant—a persistent, learning, multi-agent development environment that gets smarter with every session.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.