savant-code 0.0.17 → 0.0.19

package/docs/reports/repos/AionUi.md

@@ -0,0 +1,75 @@
+# AionUi — Feature Inventory
+
+> **Repo:** `resources/AionUi` | **Stack:** Electron + React 19 + TypeScript + Bun + Rust (AionCore)
+> **Tagline:** "A free, open-source Cowork app with AI Agents"
+
+## Overview
+
+AionUi is a desktop-first AI coworking application with a Rust backend (AionCore), Electron shell, and React 19 UI. It wraps 20+ CLI-based AI agents behind a unified ACP protocol, supports team-mode multi-agent collaboration, and ships with a full extension SDK.
+
+## Feature Inventory
+
+### Architecture
+
+- **Two-Process Electron + Rust** — Strict separation between Electron Main/Renderer and a Rust backend binary (AionCore). IPC bridge maps renderer calls to HTTP/WS. (`packages/desktop/src/process/`, `packages/desktop/src/renderer/`, `packages/desktop/src/common/adapter/ipcBridge.ts`)
+- **WebUI Mode** — Standalone HTTP server mode via `packages/web-host` with LAN/remote access. (`packages/web-host/`)
+- **Platform Abstraction** — `IPlatformServices` with Electron and Node implementations. (`packages/desktop/src/common/platform/`)
+
+### Agent Orchestration
+
+- **ACP Protocol** — Wraps 20+ CLI agents (Claude Code, Codex, Goose, OpenClaw, Hermes, Cursor, etc.) behind a unified protocol with capability negotiation. (`packages/desktop/src/common/types/platform/acpTypes.ts`, `packages/desktop/src/renderer/pages/conversation/platforms/acp/`)
+- **Team Mode** — Leader agent breaks tasks into subtasks, delegates to teammates via mailbox. Task dependency graph (`blocked_by`/`blocks`), shared workspace, per-agent permissions. (`packages/desktop/src/renderer/pages/team/`, `packages/desktop/src/common/types/team/teamTypes.ts`)
+- **Agent Process Registry** — JSON-file registry with atomic writes for tracking spawned agent subprocesses. (`packages/web-host/src/agent-process-registry.ts`)
+
+### Provider Integrations
+
+- **30+ LLM Platforms** — Gemini, OpenAI, Anthropic, Bedrock, DeepSeek, Dashscope, Ollama, LM Studio, plus Chinese providers (Zhipu, Moonshot, Qianfan, Hunyuan). (`packages/desktop/src/common/types/provider/`)
+- **Centralized MCP** — Configure once, sync to all agents. stdio, HTTP, SSE transports. OAuth support. (`packages/desktop/src/renderer/hooks/mcp/`)
+
+### Tool Systems
+
+- **Three-Tier Skills** — Builtin, custom, extension skills with per-conversation enable/disable. (`packages/desktop/src/renderer/pages/settings/SkillsSettings/`)
+- **@ Command Parser** — File reference syntax in chat input. (`packages/desktop/src/common/chat/atCommandParser.ts`)
+- **Slash Commands** — Three-source (ACP/builtin/skill) with merge priority. (`packages/desktop/src/common/chat/slash/`)
+- **Image Generation** — Shared logic with JSON repair for malformed responses. (`packages/desktop/src/common/chat/imageGenCore.ts`)
+
+### Scheduling
+
+- **Cron Scheduler** — Standard 5-field cron, fixed interval, one-time triggers. Conversation-bound or new-conversation mode. Keep-awake, missed-trigger detection. (`packages/desktop/src/renderer/pages/cron/`)
+
+### Memory & Database
+
+- **SQLite with WAL** — better-sqlite3 with 26 schema versions, migrations, 5s busy_timeout. (`packages/desktop/src/process/services/database/schema.ts`)
+- **Approval Store** — Session-level permission caching. (`packages/desktop/src/common/chat/approval/ApprovalStore.ts`)
+
+### UI Surfaces
+
+- **Desktop App** — Electron with React 19, Arco Design, CodeMirror, Monaco, react-markdown, KaTeX/GFM/mermaid, virtual scrolling, drag-and-drop.
+- **Preview Panel** — 10+ format preview (PDF, Word, Excel, PPT, code, Markdown, images, HTML, diff) with Git version history.
+- **Mobile App** — React Native / Expo for iOS and Android. (`mobile/`)
+- **Chat Platforms** — Telegram, Lark/Feishu, DingTalk, WeChat, WeCom, Slack, Discord.
+- **Desktop Pet** — Virtual pet with 21 states reacting to agent activity. (`packages/desktop/src/process/pet/`)
+
+### Extensibility
+
+- **Extension SDK** — `aion-extension.json` manifest with contributions: ACP adapters, MCP servers, assistants, agents, skills, themes, settings, i18n. Lifecycle hooks, permissions model. (`examples/`)
+- **Custom Assistants** — Markdown-defined with rules, prompts, skills, MCP servers, models. 21 built-in assistants.
+
+### Testing
+
+- **E2E Tests** — 19 team-mode test cases covering lifecycle, communication, whitelisting, workspace migration. (`tests/e2e/cases/teams/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | ACP Protocol Types | `DetectedAgent<K>` discriminated union and capability negotiation |
+| HIGH | Team Mode Mailbox + Task Board | Async inter-agent communication with dependency chains |
+| HIGH | Extension SDK (aion-extension.json) | Comprehensive extensibility model |
+| HIGH | Centralized MCP Management | "Configure once, sync to all agents" |
+| HIGH | BackendLifecycleManager | Crash restart with exponential backoff |
+| MEDIUM | Three-Tier Skill System | Builtin/custom/extension with per-conversation toggle |
+| MEDIUM | Agent Process Registry | Atomic writes for subprocess tracking |
+| MEDIUM | Cron Scheduler | Conversation-bound scheduled tasks |
+| LOW | Desktop Pet State Machine | Priority-based states with auto-return (novel but niche) |
+| LOW | Mobile Companion App | Expo-based reference implementation |

package/docs/reports/repos/OpenHands.md

@@ -0,0 +1,76 @@
+# OpenHands — Feature Inventory
+
+> **Repo:** `resources/OpenHands` | **Language:** Python | **Stack:** FastAPI + React frontend
+> **License:** MIT
+
+## Overview
+
+OpenHands is a multi-backend coding agent platform with a sandbox abstraction layer (Docker, local process, remote VM, cloud), an Agent-Client Protocol (ACP) for interoperability, trigger-based skill loading, an EventCallbackProcessor pattern for integrations, and enterprise features (Slack, Jira, GitHub, billing).
+
+## Feature Inventory
+
+### Multi-Backend Agent Orchestration
+
+- **Sandbox Abstraction** — Run agent work in Docker, local process, remote VM, or cloud. Flip between backends mid-session. (`openhands/app_server/sandbox/sandbox_service.py`, `docker_sandbox_service.py`, `process_sandbox_service.py`, `remote_sandbox_service.py`)
+
+### Agent-Client Protocol (ACP)
+
+- **Interoperability Protocol** — Any agent implementing ACP can plug in as a sub-agent or standalone backend. (`openhands/app_server/integrations/service_types.py`)
+
+### Skills / Microagents
+
+- **Trigger-Based Loading** — Skills only injected when user messages match keyword triggers. Multi-source: public skills, repo-specific (`.openhands/skills/`), org-level. MCP tool declarations in skill frontmatter. Self-improving `agent_memory` skill. (`skills/`, `openhands/app_server/app_conversation/skill_loader.py`)
+
+### MCP Integration
+
+- **Server + Proxy** — Exposes tools (create_pr, create_mr) as MCP tools. Proxies remote MCP services under namespaces (e.g., Tavily under `tavily/`). (`openhands/app_server/mcp/mcp_router.py`)
+
+### Event System
+
+- **EventCallbackProcessor** — Typed event-driven hooks for FID state changes, notifications, downstream work. Webhook, Slack, Jira, GitHub callbacks. (`openhands/app_server/event/event_service.py`, `event_callback/`)
+
+### Git Integration
+
+- **Multi-Provider** — GitHub, GitLab, Bitbucket, Azure DevOps, Forgejo. Uniform `GitService` protocol. PR/MR creation via MCP tools. (`openhands/app_server/integrations/`)
+
+### Secrets Management
+
+- **Sandbox-Scoped** — Two-tier: user-level encrypted secrets + sandbox-scoped endpoints. `ConversationSecretEnricher` extension point. (`openhands/app_server/secrets/`)
+
+### LLM Profiles
+
+- **Switchable Configurations** — Up to 10 named LLM profiles with active pointer. Managed proxy URL resolution. (`openhands/app_server/settings/llm_profiles.py`)
+
+### Task Tracking
+
+- **Planner UI** — Real-time task list with status. `TaskTrackerAction`/`TaskTrackerObservation` events. (`frontend/src/components/v1/chat/task-tracking/`)
+
+### Enterprise Integrations
+
+- **Slack, Jira, GitHub, Linear, Bitbucket, Azure DevOps** — Callback processor pattern with typed `EventKind`. (`enterprise/integrations/`)
+
+### Other
+
+- **Sandbox Lifecycle** — Start, resume, pause, delete with health-check polling. `wait_for_sandbox_running` with configurable timeout. (`openhands/app_server/sandbox/`)
+- **File Store Abstraction** — Local, S3, Google Cloud, in-memory. (`openhands/app_server/file_store/`)
+- **Event Store** — Filesystem, AWS, Google Cloud backends. (`openhands/app_server/event/`)
+- **Sub-Agent Visualization** — UI renders delegated agent work as distinct components. (`frontend/src/components/v1/chat/subagent/`)
+- **Suggested Task Generation** — Auto-generates tasks from merge conflicts, failing CI, unresolved PR comments. (`openhands/app_server/integrations/templates/suggested_task/`)
+- **Browser Automation** — Navigate, click, type, scroll, switch tabs. (`frontend/src/components/v1/chat/event-content-helpers/`)
+- **Workspace Archive** — Archive workspace state before sandbox teardown. (`openhands/app_server/sandbox/workspace_archive.py`)
+- **Rate Limiting** — In-memory (OSS) + Redis (enterprise). (`openhands/app_server/middleware.py`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Sandbox Abstraction Layer | Run agent work in Docker, local, or cloud interchangeably |
+| HIGH | EventCallbackProcessor Pattern | Typed event-driven hooks for FID state changes |
+| HIGH | Trigger-Based Skill Loading | Only inject skills when relevant |
+| HIGH | Agent Memory Skill | Self-improving pattern for future sessions |
+| MEDIUM | MCP Proxy Pattern | Namespace-mount remote MCP servers securely |
+| MEDIUM | Suggested Task Generation | Auto-generate FIDs from repo issues |
+| MEDIUM | Hooks System | User-defined event-driven lifecycle hooks |
+| MEDIUM | Sub-Agent Event Visualization | Structured rendering of delegated work |
+| LOW | Workspace Archive | Archive state before teardown |
+| LOW | PR Directory Pattern | `.pr/` for temporary PR-specific artifacts |

package/docs/reports/repos/SWE-agent.md

@@ -0,0 +1,82 @@
+# SWE-agent — Feature Inventory
+
+> **Repo:** `resources/SWE-agent` | **Language:** Python (3.11+)
+> **Runtime:** Docker/Modal/AWS via SWE-ReX
+
+## Overview
+
+SWE-agent is a research-oriented coding agent from Princeton that formalizes the Agent-Computer Interface (ACI) concept. It features YAML-driven configuration, 11 output parser strategies, a composable history processor pipeline, a three-layer hook system, and a retry agent with LLM-based review/chooser loops.
+
+## Feature Inventory
+
+### ACI Design Philosophy
+
+- **Agent-Computer Interface** — Curated tool surfaces that maximize agent performance. Specialized file viewers, search commands, and editors with built-in linters rather than raw shell. (`docs/background/aci.md`, `tools/windowed_edit_linting/`)
+
+### YAML-Driven Configuration
+
+- **Composable Configs** — Entire agent behavior governed by YAML files. Multiple configs merged via repeated `--config` flags. (`config/default.yaml`, `sweagent/utils/config.py`)
+
+### Tool Bundle System
+
+- **Self-Contained Bundles** — Each tool is a directory with `config.yaml`, `bin/` executables, optional `install.sh`, optional `lib/`. `hidden_tools` feature, `state_command` for dynamic state injection. (`tools/`, `sweagent/tools/bundle.py`)
+
+### 11 Parser Strategies
+
+- **FunctionCallingParser** — LiteLLM tool calls. **ThoughtActionParser** — backtick code blocks. **XMLThoughtActionParser**, **XMLFunctionCallingParser**, **JsonParser**, **ActionParser**, **ActionOnlyParser**, **EditFormat**, **Identity**, **BashCodeBlockParser**, **SingleBashCodeBlockParser**. (`sweagent/tools/parsing.py`)
+
+### History Processor Pipeline
+
+- **Composable Processors** — `LastNObservations` (polling-aware caching), `CacheControlHistoryProcessor` (Anthropic prompt cache), `ClosedWindowHistoryProcessor` (collapse outdated windows), `TagToolCallObservations`, `RemoveRegex`, `ImageParsingHistoryProcessor`. (`sweagent/agent/history_processors.py`)
+
+### Container Sandboxing
+
+- **Docker/Modal/AWS** — via SWE-ReX. Agent never runs code on host. Clean separation between agent logic and runtime. (`sweagent/environment/swe_env.py`)
+
+### Retry Agent with Review Loop
+
+- **Multi-Attempt** — Runs agent multiple times. `Reviewer` (separate LLM) scores solutions. `Chooser` with `Preselector` picks best. `ScoreRetryLoop` (threshold) and `ChooserRetryLoop` (LLM selection). (`sweagent/agent/reviewer.py`, `sweagent/agent/agents.py`)
+
+### Action Sampling
+
+- **AskColleagues** — Sample N completions, present as "colleague ideas", model synthesizes. **BinaryTrajectoryComparison** — Pairwise tournament selection. (`sweagent/agent/action_sampler.py`)
+
+### Command Safety
+
+- **Blocklist** — Configurable prefix, exact match, or conditional regex blocking. (`sweagent/tools/tools.py`)
+
+### Three-Layer Hook System
+
+- **Agent/Env/Run Hooks** — `AgentHook` (per-step), `EnvHook` (environment lifecycle), `RunHook` (instance lifecycle). Combined dispatch. Events: `on_actions_generated`, `on_action_executed`, `on_model_query`, `on_query_message_added`. (`sweagent/agent/hooks/`, `sweagent/environment/hooks/`, `sweagent/run/hooks/`)
+
+### Batch Execution
+
+- **Parallel Workers** — ThreadPoolExecutor with per-instance cost tracking, thread-safe API key rotation, random startup delays, live progress bars, continuous SWE-bench submission. (`sweagent/run/run_batch.py`)
+
+### Other
+
+- **Multimodal Support** — Image processing from GitHub issues. Vision model integration. (`sweagent/agent/problem_statement.py`)
+- **Human-in-the-Loop Shell** — `^C` switches to human input, `^D` returns to AI. (`sweagent/agent/extra/shell_agent.py`)
+- **Web-Based Trajectory Inspector** — Built-in HTTP server for viewing agent trajectories. (`sweagent/inspector/`)
+- **Auto-Submission on Errors** — Extracts partial work on fatal errors. (`sweagent/agent/agents.py`)
+- **Demonstrations** — Pre-recorded trajectories injected as few-shot examples. (`sweagent/agent/agents.py`)
+- **Registry Bundle** — Persistent JSON key-value store for inter-tool state. (`tools/registry/`)
+- **PR Opening Hook** — Auto-creates draft GitHub PRs with safety checks. (`sweagent/run/hooks/open_pr.py`)
+- **Edit Tools with Linting** — Linting-gated edits reject syntactically invalid changes. (`tools/windowed_edit_linting/`)
+- **Diff State Tracking** — `git diff` as per-step template variable. (`tools/diff_state/`)
+- **Web Browser Bundle** — 14 Playwright-based tools for browser automation. (`tools/web_browser/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | ACI Design Philosophy | Design agent-optimized tools, not raw shell |
+| HIGH | Tool Bundle System with state_command | Modular, self-contained tool packaging |
+| HIGH | History Processor Pipeline | Composable context management |
+| HIGH | Three-Layer Hook System | Clean extensibility at agent/env/run levels |
+| HIGH | Retry Agent with Review Loop | Multi-attempt with LLM-based selection |
+| MEDIUM | Action Sampling (AskColleagues) | Multi-sample consensus for action selection |
+| MEDIUM | Command Blocklist/Safety Filtering | Prevent dangerous agent actions |
+| MEDIUM | Auto-Submission on Errors | Graceful degradation |
+| MEDIUM | Registry Bundle (Shared State) | Inter-tool persistent state |
+| LOW | YAML Config Composition | Declarative, mergeable agent profiles |

package/docs/reports/repos/agno.md

@@ -0,0 +1,89 @@
+# Agno — Feature Inventory
+
+> **Repo:** `resources/agno` | **Language:** Python | **License:** Apache-2.0
+> **Tagline:** High-performance AI agent framework
+
+## Overview
+
+Agno is a Python-based AI agent framework with an extremely broad provider surface (54 LLM providers), a composable workflow engine, and a full AgentOS serving layer. It emphasizes performance, modularity, and multi-agent orchestration.
+
+## Feature Inventory
+
+### Agent Core
+
+- **Agent Class** — Central orchestrator with model, tools, memory, knowledge, instructions, session management, fork/checkpoint, telemetry. (`agent/agent.py`)
+- **Agent Factory** — Config-driven dynamic agent creation from YAML/JSON dicts. (`agent/factory.py`)
+- **Remote Agent** — Transparent delegation to remote AgentOS endpoints. (`agent/remote.py`)
+- **Session Forking** — Branch session state for alternative explorations. (`cookbook/02_agents/21_fork_session/`)
+
+### Team Orchestration
+
+- **Team Class** — Multi-agent coordinator with four modes: coordinate, route, broadcast, tasks. (`team/team.py`, `team/mode.py`)
+
+### Workflow Engine
+
+- **Workflow Class** — DAG of steps with conditional routing, loops, and dynamic step selection. (`workflow/workflow.py`)
+- **CEL Router** — Common Expression Language for routing conditions. (`workflow/cel.py`)
+
+### Model Layer (54 Providers)
+
+- **Provider Catalog** — 54 provider implementations: OpenAI, Anthropic, Google, xAI, DeepSeek, MiniMax, Bedrock, Vertex, Azure, Groq, Together, Fireworks, Ollama, LM Studio, Mistral, Cohere, HuggingFace, Novita, SambaNova, Cerebras, Perplexity, IBM watsonx, etc. (`models/`)
+- **Reasoning Providers** — 13 first-class reasoning model support modules. (`reasoning/`)
+
+### Tool System
+
+- **Toolkit Class** — Container with caching, include/exclude filtering, HITL confirmation. (`tools/toolkit.py`)
+- **MCP Tools** — Client + multi-MCP server merging with auth and namespacing. (`tools/mcp/mcp.py`, `tools/mcp/multi_mcp.py`)
+- **Workspace Tool** — File system + shell with allow/confirm/exclude patterns. (`tools/workspace.py`)
+- **145 Tool Integrations** — File, shell, web, search, email, calendar, CRM, databases, cloud, media, social, finance. (`tools/`)
+
+### Memory & Knowledge
+
+- **Memory Manager** — Strategy-based memory (summarize, etc.) with DB backend. (`memory/manager.py`, `memory/strategies/`)
+- **Knowledge System** — Vector DB with 24 backends, document loaders, chunking, embedders, rerankers. (`knowledge/`, `vectordb/`)
+- **Context Providers** — 12+ providers: calendar, database, filesystem, Gmail, Google, Slack, web, wiki, workspace. (`context/`)
+
+### Learning System
+
+- **LearningMachine** — Orchestrates memory, entity memory, session context, learned knowledge, decision logs. (`learn/machine.py`)
+
+### Scheduler
+
+- **ScheduleManager** — DB-backed cron scheduler with persistence. (`scheduler/manager.py`)
+
+### Eval System
+
+- **Eval Suite** — Cases, AgentAsJudge, Reliability eval, SuiteResult. (`eval/`)
+
+### Guardrails & Approval
+
+- **BaseGuardrail** — Check/validate inputs or outputs. (`guardrails/base.py`)
+- **@approval Decorator** — HITL gating with `required` and `audit` modes. (`approval/decorator.py`)
+
+### AgentOS
+
+- **FastAPI Application** — Serves agents as HTTP endpoints with auth, MCP, WebSocket streaming. (`os/app.py`)
+- **MCP Server** — Exposes agents as MCP servers. (`os/mcp.py`)
+- **Interface Adapters** — A2A, AG-UI, Slack, Telegram, WhatsApp. (`os/interfaces/`)
+- **19 API Routers** — Agents, approvals, components, database, evals, health, knowledge, etc. (`os/routers/`)
+
+### Other
+
+- **CompressionManager** — LLM-based tool output compression. (`compression/manager.py`)
+- **OpenTelemetry Tracing** — Full OTel with DB-backed span export. (`tracing/`)
+- **22 Database Backends** — PostgreSQL, SQLite, MySQL, MongoDB, Redis, DynamoDB, etc. (`db/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Rank | Feature | Impact | Effort |
+|------|---------|--------|--------|
+| 1 | MCP Client + Server | Critical | Medium |
+| 2 | 54-provider model catalog (adapter pattern) | High | Medium |
+| 3 | Workflow Engine with CEL routing | High | Medium |
+| 4 | Persistent Memory with strategy system | High | Medium |
+| 5 | @approval HITL decorator | High | Low |
+| 6 | Scheduler (DB-backed cron) | Medium | Low |
+| 7 | Eval Suite (Case/SuiteResult/Reliability) | Medium | Low |
+| 8 | Context Providers for git/CI/docs | Medium | Low |
+| 9 | Team Modes (coordinate/route/broadcast/tasks) | Medium | Low |
+| 10 | CompressionManager for tool outputs | Low-Medium | Low |

package/docs/reports/repos/aider.md

@@ -0,0 +1,74 @@
+# Aider — Feature Inventory
+
+> **Repo:** `resources/aider` | **Language:** Python | **License:** Apache-2.0
+> **Tagline:** AI pair programming in your terminal | ~6.8M installs, ~60k stars
+
+## Overview
+
+Aider is a mature Python coding agent with ~6.8M installs. Its distinguishing innovation is a **polymorphic edit format system** (13+ strategies) and a **PageRank-based repo map** for codebase indexing. It uses litellm for provider abstraction and has deep git integration.
+
+## Feature Inventory
+
+### Edit Formats (Core Architecture)
+
+- **13+ Polymorphic Coders** — SEARCH/REPLACE blocks, unified diff, whole file, patch, fenced variants, editor variants, architect/editor two-stage, ask, context, help. Each model gets an optimal edit format. (`coders/base_coder.py`, `coders/editblock_coder.py`, `coders/udiff_coder.py`, `coders/wholefile_coder.py`)
+
+### Architect/Editor Pattern
+
+- **Two-Stage Workflow** — Architect LLM analyzes and produces edit instructions; editor LLM implements them. Can use different models. (`coders/architect_coder.py`)
+
+### Repo Map (PageRank + tree-sitter)
+
+- **Graph-Based Codebase Indexing** — tree-sitter extracts definitions/references, PageRank ranks files by relevance. Token-budgeted output. snake_case/kebab/camelCase get 10x weight; private identifiers get 0.1x. (`repomap.py`, `queries/tree-sitter-language-pack/`)
+
+### Multi-Model Architecture
+
+- **Main/Weak/Editor Models** — Three model tiers: main for coding, weak for commit messages/summarization, editor for architect pattern. 100+ model configs in YAML. (`models.py`, `resources/model-settings.yml`)
+
+### Prompt Caching
+
+- **Cache Warming** — Background thread sends periodic pings to keep Anthropic prompt caches alive. Configurable keepalive. (`coders/base_coder.py`, `coders/chat_chunks.py`)
+
+### Chat History Summarization
+
+- **Recursive Compression** — Splits at logical boundaries, summarizes older half, recursively combines. Background thread. (`history.py`)
+
+### File Watcher (IDE Integration)
+
+- **AI Comment Detection** — Regex detects `# ai...` / `// ai...` in any editor, triggers automatic code changes. Gitignore-aware. (`watch.py`, `watch_prompts.py`)
+
+### Linting & Testing
+
+- **Auto-Lint-After-Edit** — Runs configurable lint commands, feeds errors back to LLM for self-correction (up to `max_reflections`). (`linter.py`, `coders/base_coder.py`)
+
+### Reflection Loop
+
+- **Self-Correction** — After each LLM response, checks for issues and retries up to `max_reflections` times. (`coders/base_coder.py`)
+
+### Git Integration
+
+- **Deep Git** — Auto-commit with LLM-generated messages, gitignore management, `.aiderignore`, subtree-only mode, co-author attribution. (`repo.py`)
+
+### Other
+
+- **Voice-to-Code** — Microphone capture + LLM transcription. (`voice.py`)
+- **Web Scraping** — Playwright headless Chromium with HTTP fallback. (`scrape.py`)
+- **Clipboard Watcher** — Auto-populates input from clipboard for web chat integration. (`copypaste.py`)
+- **Benchmark System** — Polyglot Exercism + SWE-bench with Docker isolation. (`benchmark/`)
+- **Lazy Import Loading** — Version-aware deferred imports for fast startup. (`llm.py`)
+- **Structured Exceptions** — Classified retry logic with exponential backoff. (`exceptions.py`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Repo Map (PageRank + tree-sitter) | Best-in-class codebase indexing |
+| HIGH | Edit Format Strategy Pattern | 13+ polymorphic coders; each model gets optimal format |
+| HIGH | Architect/Editor Two-Stage Pattern | Clean planning/execution separation |
+| HIGH | Reflection Loop (edit → lint → retry) | Core quality loop |
+| MEDIUM | Multi-Model (Main/Weak/Editor) | Cost optimization via model tiering |
+| MEDIUM | Prompt Cache Warming | Keeps Anthropic caches alive |
+| MEDIUM | Chat History Summarization | Recursive background compression |
+| MEDIUM | Model Settings YAML Registry | 100+ model configs in declarative YAML |
+| MEDIUM | AI Comment File Watcher | Editor-agnostic trigger mechanism |
+| LOW | Benchmark Framework | Polyglot eval methodology |

package/docs/reports/repos/cline.md

@@ -0,0 +1,83 @@
+# Cline — Feature Inventory
+
+> **Repo:** `resources/cline` | **Stack:** Bun 1.3.13 + Node >= 22, TypeScript monorepo
+> **License:** Apache 2.0
+
+## Overview
+
+Cline is a TypeScript/Bun coding agent with a disciplined layered SDK architecture (`shared → llms → agents → core → apps`). It features a sophisticated multi-agent team system, subprocess sandboxing for plugins, a 7-callback hook system, and VCR-style HTTP recording for testing.
+
+## Feature Inventory
+
+### Architecture
+
+- **Layered SDK** — Strict dependency direction: `@cline/shared` → `@cline/llms` → `@cline/agents` → `@cline/core` → apps (CLI, VS Code, JetBrains). (`sdk/packages/`)
+
+### Tool System
+
+- **Tool Presets** — Act/Plan/Search/Minimal/Yolo modes with different tool availability. (`sdk/packages/core/src/extensions/tools/presets.ts`)
+- **Model-Tool Routing** — Dynamic tool enable/disable based on provider+model+mode (e.g., OpenAI gets `apply_patch` instead of `editor`). (`sdk/packages/core/src/extensions/tools/model-tool-routing.ts`)
+- **9 Default Tool Factories** — `read_files`, `search_codebase`, `run_commands`, `fetch_web_content`, `editor`/`apply_patch`, `skills`, `ask_question`, `submit_and_exit`, `spawn_agent`. (`sdk/packages/core/src/extensions/tools/definitions.ts`)
+
+### Sandbox
+
+- **SubprocessSandbox** — IPC-based isolation for plugins with typed message protocol, auto-reinit on crash, timeout enforcement. (`sdk/packages/core/src/runtime/tools/subprocess-sandbox.ts`)
+
+### Plugin System
+
+- **Contribution-Based Plugins** — Tools, commands, rules, message builders, providers, automation events, MCP servers, shortcuts, flags. npm/git/remote installation. Marketplace. (`sdk/packages/core/src/extensions/plugin/`)
+
+### MCP Integration
+
+- **Full MCP Client** — Tool discovery, OAuth, policy enforcement, settings synchronization. (`sdk/packages/core/src/extensions/mcp/`)
+
+### Multi-Agent Teams
+
+- **AgentTeamsRuntime** — Lead/teammate hierarchy, task management, run queuing, mailbox messaging, outcome tracking, mission logs, team state persistence, completion guard. 20+ team tools. (`sdk/packages/core/src/extensions/tools/team/multi-agent.ts`)
+
+### Cron Automation
+
+- **Markdown Spec System** — `.cline/cron/*.md` with YAML frontmatter. One-off, schedule (cron), and event triggers. SQLite-backed. Filesystem watching for spec changes. (`sdk/packages/core/src/cron/`)
+
+### Connector System (Messaging)
+
+- **6 Platform Connectors** — Telegram, Slack (webhook + socket), Discord, Google Chat, WhatsApp, Linear. (`apps/cli/src/connectors/`)
+
+### Hook System
+
+- **7-Callback Hooks** — `beforeRun`, `afterRun`, `beforeModel`, `afterModel`, `beforeTool`, `afterTool`, `onEvent`. `beforeModel` can inject messages and modify tools per-request. (`sdk/packages/shared/src/agent.ts`)
+
+### Safety
+
+- **Loop Detection** — Repeated tool-call detection with soft warning (3) and hard stop (5). (`sdk/packages/core/src/runtime/safety/loop-detection.ts`)
+
+### Checkpoints
+
+- **Git-Based** — Git commits as checkpoints, diffing, restore. (`sdk/packages/core/src/session/checkpoint-diff.ts`)
+
+### VCR (Testing)
+
+- **HTTP Record/Playback** — Records/replays HTTP via fetch patching. Selective filtering, sensitive data sanitization, SSE replay. (`sdk/packages/shared/src/vcr.ts`)
+
+### Eval System
+
+- **3-Layer Pyramid** — Contract tests → smoke tests (5 scenarios, 3 models, pass@k) → E2E (Harbor/SWE-bench). (`evals/`)
+
+### Agent Client Protocol
+
+- **ACP Implementation** — `@agentclientprotocol/sdk` with session management, image prompts, provider switching, tool approval routing. (`apps/cli/src/acp/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | `createTool` factory + ToolPresets | Clean tool definition with mode-based presets |
+| HIGH | Multi-Agent Team system | Production-grade orchestration with persistence |
+| HIGH | Loop Detection | Simple but critical safety feature |
+| HIGH | Eval system (3-layer pyramid) | Rigorous testing framework |
+| HIGH | Plugin sandbox (SubprocessSandbox) | Safe extension execution |
+| HIGH | 7-callback hook system | Well-designed runtime extensibility |
+| MEDIUM | VCR (HTTP record/playback) | Deterministic testing |
+| MEDIUM | Connector catalog pattern | Messaging platform integration |
+| MEDIUM | Cron automation (markdown specs) | Scheduled agent runs |
+| MEDIUM | Git-based checkpoints | Elegant undo/restore |

package/docs/reports/repos/codex.md

@@ -0,0 +1,83 @@
+# Codex — Feature Inventory
+
+> **Repo:** `resources/codex` | **Language:** Rust (codex-rs) + TypeScript/Python SDKs
+> **Build:** Bazel + Cargo dual build system
+
+## Overview
+
+OpenAI's Codex CLI is a Rust-based terminal coding agent with OS-level sandboxing, a role-based agent registry, a Starlark execution policy engine, an 11-event lifecycle hook system, and a two-phase memories pipeline. It is one of the most technically sophisticated coding agents in the ecosystem.
+
+## Feature Inventory
+
+### Multi-Agent Orchestration
+
+- **Role-Based Agent Registry** — Built-in `explorer` and `worker` roles with config layering (user roles override built-in). `SpawnReservation` RAII pattern, nickname pools, spawn depth/thread count limits. (`codex-rs/core/src/agent/`)
+
+### OS-Level Sandboxing
+
+- **Cross-Platform** — macOS Seatbelt (SBPL profiles), Linux seccomp/Landlock/bubblewrap, Windows restricted token. Unified `SandboxManager` with `SandboxType` enum. (`codex-rs/sandboxing/src/`)
+
+### Execution Policy Engine
+
+- **Starlark Rules** — Declarative allow/prompt/forbidden decisions for shell commands. Prefix matching with alternatives, host executable path resolution, self-validating rules. (`codex-rs/execpolicy/src/`)
+
+### Lifecycle Hooks (11 Events)
+
+- **11-Event System** — `PreToolUse`, `PermissionRequest`, `PostToolUse`, `PreCompact`, `PostCompact`, `SessionStart`, `SessionEnd`, `UserPromptSubmit`, `SubagentStart`, `SubagentStop`, `Stop`. Matcher fields, persistable states. (`codex-rs/hooks/src/`)
+
+### Context Compaction
+
+- **Multi-Strategy** — Remote summarization, pre-turn compaction, manual, model fallback. Hook integration, replacement history tracking. (`codex-rs/core/src/compact.rs`)
+
+### Thread Management
+
+- **Full Lifecycle** — Create, resume, fork (branch), archive, delete, rollback. Dual persistence: JSONL rollouts + SQLite state DB. (`codex-rs/core/src/thread_manager.rs`)
+
+### MCP Integration
+
+- **Bidirectional** — Both MCP client and server. Plugin-contributed MCP servers with OAuth. Tool catalog caching. (`codex-rs/codex-mcp/src/`, `codex-rs/mcp-server/src/`)
+
+### Skills System
+
+- **Markdown-Based** — `.md` files with metadata. Implicit invocation detection (matching shell commands to skills). Scope (User/Repo/System/Admin), policy, budget. (`codex-rs/core-skills/src/`)
+
+### Plugin/Marketplace
+
+- **Full Ecosystem** — Local (filesystem) or remote (Git-based marketplace). Contributes skills, MCP servers, hooks, apps. (`codex-rs/plugin/src/`)
+
+### Memories (Two-Phase Pipeline)
+
+- **Phase 1:** Extract structured memories from completed conversations (parallel with concurrency caps).
+- **Phase 2:** Consolidate into workspace artifacts via git-baseline diff. (`codex-rs/memories/`)
+
+### App-Server Protocol (JSON-RPC)
+
+- **50+ RPC Methods** — Thread management, turn control, file ops, model listing, skills, plugins. `turn/steer` (mid-turn injection), `thread/fork`, backpressure. (`codex-rs/app-server/src/`)
+
+### Execution Server
+
+- **Remote Execution** — Sandboxed subprocess management with Noise-encrypted relay, PTY-backed processes, filesystem RPCs. (`codex-rs/exec-server/src/`)
+
+### Other
+
+- **Collaboration Modes** — Template-based behavioral presets (Default, Execute, Pair Programming, Plan). (`codex-rs/collaboration-mode-templates/`)
+- **Agent Graph Store** — Parent-child relationships, spawn reasons, status transitions. (`codex-rs/agent-graph-store/src/`)
+- **Rollout Budget** — Token usage and turn count budgets per session. (`codex-rs/core/src/rollout_budget.rs`)
+- **Context Fragments** — Bounded (max 10K tokens) with trait enforcement. (`codex-rs/context-fragments/src/`)
+- **Realtime/Voice** — WebRTC/WebSocket voice conversations. (`codex-rs/core/src/realtime_conversation/`)
+- **TUI** — ratatui-based with markdown rendering, diff visualization, inline tool output. (`codex-rs/tui/src/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Role-Based Agent Registry | Config layering for ECHO agent roster |
+| HIGH | Lifecycle Hook System (11 events) | Maps 1:1 to agent lifecycle needs |
+| HIGH | Context Compaction | Essential for long-running sessions |
+| HIGH | Execution Policy Engine | Safety gate for tool execution |
+| HIGH | Memories Two-Phase Pipeline | Production-grade memory architecture |
+| HIGH | Bounded Context Fragments | Prevents context explosion |
+| MEDIUM | Plugin/Marketplace System | Extensibility for community contributions |
+| MEDIUM | Agent Graph Store | Multi-agent relationship tracking |
+| MEDIUM | Collaboration Modes | Behavioral presets per task type |
+| MEDIUM | Completion Policy (headless gating) | Ensures headless work is actually complete |