everything-claude-code

Implements a hierarchical agent system where multiple specialized agents (Observer, Skill Creator, Evaluator, etc.) coordinate through a central harness using pre/post-tool-use hooks and session-based context passing. Agents delegate subtasks via explicit hand-off patterns defined in agent.yaml, with state synchronized through SQLite-backed session persistence and strategic context window compaction to prevent token overflow during multi-step workflows.

Implements a closed-loop learning pipeline (Continuous Learning v2 Architecture) where an Observer Agent monitors code execution patterns, detects recurring problems, and automatically generates new skills via the Skill Creator. Instincts are structured as pattern-matching rules stored in SQLite, evolved through an evaluation system that tracks skill health metrics, and scoped to individual projects to prevent cross-project interference. The evolution pipeline includes observation → pattern detection → skill generation → evaluation → integration into the active skill set.

Provides a Checkpoint & Verification Workflow that creates savepoints of project state at key milestones, verifies code quality and functionality at each checkpoint, and enables rollback to previous checkpoints if verification fails. Checkpoints are stored in session state with full context snapshots, and verification uses the Plankton Code Quality System and Evaluation System to assess quality. The workflow integrates with version control to track checkpoint history.

Implements Autonomous Loop Patterns that enable agents to self-direct task execution without human intervention, using the planning-reasoning system to decompose tasks, execute them through agent delegation, and verify results through evaluation. Loops can be configured with termination conditions (max iterations, success criteria, token budget) and include safeguards to prevent infinite loops. The Observer Agent monitors loop execution and feeds patterns into continuous learning.

Provides Token Optimization Strategies that monitor token usage across agent execution, identify high-cost operations, and apply optimization techniques (context compaction, selective context inclusion, prompt compression) to reduce token consumption. Context Window Management tracks available tokens per platform and automatically adjusts context inclusion strategies to stay within limits. The system includes token budgeting per task and alerts when approaching limits.

Implements a Package Manager System that enables installation, versioning, and distribution of skills, rules, and commands as packages. Packages are defined in manifest files (install-modules.json) with dependency specifications, and the package manager handles dependency resolution, conflict detection, and selective installation. Packages can be installed from local directories, Git repositories, or package registries, and the system tracks installed versions for reproducibility.

Automatically detects project type, framework, and structure by analyzing codebase patterns, package manifests, and configuration files. Infers project context (language, framework, testing patterns, coding standards) and uses this to select appropriate skills, rules, and commands. The system maintains a project detection cache to avoid repeated analysis and integrates with the CLAUDE.md context file for explicit project metadata.

Integrates the Plankton Code Quality System for structural analysis of generated code using language-specific parsers (tree-sitter for 40+ languages) instead of regex-based matching. Provides metrics for code complexity, maintainability, test coverage, and style violations. Plankton integrates with the Evaluation System to track code quality trends and with the Skill Creator to generate quality-focused skills.

Provides Tmux Worktree Orchestration that enables parallel development across multiple Git worktrees using tmux sessions for isolation. Agents can spawn parallel tasks in separate worktrees, coordinate changes across worktrees, and merge results back to main branch. The system manages worktree lifecycle (creation, cleanup) and provides coordination primitives for synchronizing parallel execution.

Provides JIRA Integration that enables agents to read tasks from JIRA, update task status as work progresses, and link code changes to JIRA issues. The integration includes a JIRA command for manual task management and automatic status updates based on agent execution results. Session state tracks JIRA issue context for multi-session continuity.

Provides a middleware layer for intercepting and transforming tool calls through PreToolUse and PostToolUse hooks that execute before/after any MCP tool invocation. Hooks are registered globally or per-session, support async execution, can modify tool arguments or results, and integrate with the hook testing infrastructure for validation. The hook lifecycle is tied to session events (session start, context refresh, tool execution) enabling fine-grained control over agent behavior without modifying core agent logic.

Manages agent state across IDE sessions using SQLite-backed session files with structured JSON payloads, session aliases for easy recall, and a strategic compaction algorithm that summarizes old context to fit within token budgets. Sessions track conversation history, tool execution logs, agent decisions, and learned instincts. The Session Manager API provides CRUD operations, and session adapters enable format conversion for different platforms (Claude Code, Cursor, OpenCode). Compaction uses heuristics to identify low-value context (verbose logs, redundant explanations) and replace with summaries.

Defines reusable agent capabilities as discrete skill modules (SKILL.md format) that encapsulate domain knowledge, code patterns, testing strategies, and verification procedures. Skills are installed via a package manager system, can be enabled/disabled per project, and include metadata for skill health tracking (success rate, token cost, latency). The Skill Creator Agent generates new skills from observed patterns, and the Evaluation System tracks skill effectiveness. Skills integrate with the continuous learning pipeline to evolve based on execution feedback.

Provides a specialized workflow (Code Review & Security Workflow) that combines multiple agents and skills to perform automated code review, security scanning, and quality verification. Integrates with the Plankton Code Quality System for structural analysis, uses PreToolUse hooks for security guardrails (preventing dangerous operations), and leverages the Evaluation System to track review effectiveness. The workflow can be triggered manually or as part of autonomous loops, with results persisted to session state for audit trails.

Provides unified agent harness across multiple IDE platforms (Claude Code, Cursor, OpenCode, Codex CLI, Kiro IDE) through a platform abstraction layer that normalizes MCP server configuration, tool availability, and context window constraints. Platform-specific skills adapt to IDE capabilities (e.g., Swift 6.2 Concurrency for Kiro, FoundationModels for on-device LLM support). Session adapters enable session portability across platforms, and platform feature comparison documentation guides skill selection per platform.

Implements an Eval-Driven Development Workflow that uses the Evaluation System to define success metrics, automatically generate test cases, and measure agent performance against those metrics. The workflow integrates with the Skill Creator to generate new skills based on eval results, and uses the Plankton Code Quality System for structural verification. Evals are defined as YAML configurations with input/output specifications, and results are persisted to session state for tracking improvement over time.

Provides a Search-First Workflow that prioritizes information retrieval and analysis before code generation, using iterative retrieval patterns to gather context from documentation, codebase, and external sources. The workflow integrates with memory systems (RAG, knowledge bases) to retrieve relevant patterns before generating code, reducing hallucinations and improving code quality. Iterative retrieval allows Claude to refine searches based on initial results, enabling multi-step research workflows.

Implements a Test-Driven Development Workflow that generates test cases before code implementation, uses the Evaluation System to verify test quality, and integrates with the Plankton Code Quality System for structural validation. Tests are generated based on requirements and project patterns, and the workflow ensures code passes tests before considering tasks complete. Test generation leverages learned patterns from the continuous learning system.