savant-code 0.0.17 → 0.0.19

package/docs/reports/repos/gemini-cli.md

@@ -0,0 +1,92 @@
+# Gemini CLI — Feature Inventory
+
+> **Repo:** `resources/gemini-cli` | **Language:** TypeScript | **Runtime:** Node.js
+> **License:** Apache 2.0
+
+## Overview
+
+Google's Gemini CLI is a TypeScript coding agent with a graph-based context management system, an event-driven scheduler with parallel tool batching, a sophisticated hook system (including BeforeModel synthetic responses), and a behavioral eval framework with dynamic baselines.
+
+## Feature Inventory
+
+### Architecture
+
+- **7-Package Monorepo** — `core` (brain, zero UI deps), `cli` (React/Ink TUI), `sdk` (embeddable), `a2a-server`, `vscode-ide-companion`, `devtools`, `test-utils`. (`packages/core/src/`, `packages/cli/src/`, `packages/sdk/src/`)
+
+### Tool Registry
+
+- **Tool Discovery** — Auto-discovered by running a configurable CLI command returning JSON. Per-model schema adaptation. Plan Mode tool restriction. (`packages/core/src/tools/tool-registry.ts`)
+
+### Scheduler (Event-Driven)
+
+- **Parallel Batching** — Non-edit tools execute in parallel; edit tools forced sequential. `wait_for_previous` per-call override. Sandbox expansion mid-flight. Tail call replacement for hook-driven redirection. (`packages/core/src/scheduler/`)
+
+### Agent System
+
+- **Subagent Framework** — Local (in-process) and remote (A2A protocol) agents. `complete_task` tool for structured termination. Agent acknowledgement system for untrusted definitions. Activity streaming (THOUGHT_CHUNK, TOOL_CALL_START/END, ERROR). (`packages/core/src/agents/`)
+
+### Context Management (Graph-Based)
+
+- **Context as Graph** — Typed nodes (UserPrompt, AgentThought, ToolExecution, MaskedTool, AgentYield, Snapshot, RollingSummary). Processor pipeline: blobDegradation, historyTruncation, nodeDistillation, rollingSummary, stateSnapshot, toolMasking. Render cache with hysteresis. (`packages/core/src/context/`)
+
+### Chat Compression
+
+- **Model-Aware** — Automatically compresses at 50% of token limit. Split point algorithm respects turn boundaries. Reverse Token Budget truncates old tool outputs first. (`packages/core/src/context/chatCompressionService.ts`)
+
+### Tool Output Management
+
+- **Masking + Distillation** — Protection window (newest 50k tokens), min prunable threshold (30k), proportional truncation, exempt tools. (`packages/core/src/context/toolOutputMaskingService.ts`, `toolDistillationService.ts`)
+
+### Memory System
+
+- **Hierarchical + JIT** — Global, extension, project, user project, JIT subdirectory context. Auto-extraction agent produces memory patch files. MEMORY.md as index. (`packages/core/src/context/memoryContextManager.ts`, `agents/skill-extraction-agent.ts`)
+
+### Hook System (10 Events)
+
+- **10 Event Points** — BeforeTool, AfterTool, BeforeAgent, AfterAgent, SessionStart, SessionEnd, PreCompress, BeforeModel, AfterModel, BeforeToolSelection. **BeforeModel synthetic responses** (bypass model call entirely). BeforeTool input modification. AfterTool tail calls. (`packages/core/src/hooks/`)
+
+### Model Routing
+
+- **CompositeStrategy** — Chains: Fallback → Override → ApprovalMode → GemmaClassifier → Classifier → NumericalClassifier → Default. Local Gemma classifier for cheap routing. (`packages/core/src/routing/`)
+
+### MCP Integration
+
+- **Full Client** — stdio, SSE/HTTP, WebSocket transports. Per-agent MCP servers. MCP resource tools. Fully qualified tool names. (`packages/core/src/tools/mcp-client-manager.ts`)
+
+### Skills System
+
+- **On-Demand Loading** — Precedence: Extensions < User < Workspace. `activate_skill` tool for model-initiated loading. Admin toggle. (`packages/core/src/skills/`)
+
+### Plan Mode
+
+- **Tool-Restricted** — `write_file` and `edit` restricted to `.md` plan files only. Enforced at schema description level. (`packages/core/src/tools/enter-plan-mode.ts`)
+
+### Behavioral Evals
+
+- **Nightly Regression** — Tests run 3x per model per night, scored 0/33/66/100%. Dynamic baseline verification (fails on main → marked "Pre-existing"). Trustworthiness filter (60%+ per-night, 80%+ aggregate). Automated promotion. (`evals/`)
+
+### Extension System
+
+- **Multi-System** — Extensions contribute skills, MCP servers, hooks, agents, and custom context files simultaneously. (`packages/core/src/config/extensions/`)
+
+### Other
+
+- **Confirmation Bus** — Pub/sub decoupling tool execution from confirmation UI. `derive(subagentName)` for scoped buses. (`packages/core/src/confirmation-bus/`)
+- **Task Tracker** — Create, update, dependency graph with cycle detection. (`packages/core/src/tools/trackerTools.ts`)
+- **GEMINI.md Context Files** — Hierarchical project instructions with JIT loading. (`packages/core/src/utils/memoryDiscovery.ts`)
+- **Voice Input** — Dual backend: Gemini Live API + local Whisper. (`packages/core/src/voice/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Scheduler with parallel batching | Dramatically improves throughput |
+| HIGH | Context graph + processor pipeline | Far more sophisticated than flat message arrays |
+| HIGH | Tool output masking with protection window | Prevents context bloat while preserving recent context |
+| HIGH | Hook system (BeforeModel synthetic responses) | Enables testing, caching, safety interception |
+| HIGH | Behavioral eval framework with dynamic baselines | Proper regression testing for LLM behavior |
+| HIGH | JIT context discovery | Load subdirectory context on-demand |
+| HIGH | Agent acknowledgement system | Security for untrusted agent definitions |
+| HIGH | Complete_task tool | Cleaner than relying on natural conversation end |
+| MEDIUM | Model routing with composite strategies | Cost optimization via local classifier |
+| MEDIUM | Sandbox expansion mid-flow | Seamless permission escalation |

package/docs/reports/repos/goose.md

@@ -0,0 +1,65 @@
+# Goose — Feature Inventory
+
+> **Repo:** `resources/goose` | **Language:** Rust core + Electron/TypeScript UI + Ink/React TUI
+> **License:** Apache 2.0 (Linux Foundation / AAIF) | **Version:** 1.43.0
+
+## Overview
+
+Goose is a Rust-based coding agent with 15+ LLM providers, 70+ MCP server extensions, a recipe system for YAML-defined agent tasks, a plugin system with auto-update, and a cron scheduler that runs full agent sessions.
+
+## Feature Inventory
+
+### Multi-Provider LLM
+
+- **15+ Providers** — Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, Bedrock, Databricks, Snowflake, HuggingFace, llama.cpp/MLX, etc. Provider registry with runtime discovery, declarative YAML-based custom providers, OAuth device flow. (`crates/goose/src/providers/`)
+
+### Agent Core
+
+- **Single-Agent Loop** — 4400+ lines managing conversation, tool calling, context compaction, permission checks, security scanning. Auto mode and plan mode. `Stop` hook with block cap (8 iterations). (`crates/goose/src/agents/agent.rs`)
+
+### MCP Extensions
+
+- **70+ MCP Servers** — `ExtensionManager` handles subprocess spawning, OAuth, health monitoring, tool routing. Built-in MCP servers for memory, computer control, autovisualisation, tutorials. Malware checking via OSV API. (`crates/goose-mcp/src/`, `crates/goose/src/agents/extension_manager.rs`)
+
+### Platform Extensions (Built-in)
+
+- **10 Built-in Extensions** — `analyze` (tree-sitter), `todo`, `apps` (sandboxed HTML), `chatrecall` (session search), `summon` (subagents), `orchestrator` (multi-session), `summarize`, `developer`, `extensionmanager`. (`crates/goose/src/agents/platform_extensions/`)
+
+### Subagent System
+
+- **Delegate/Summon** — Sync and async delegation with configurable max turns, extensions, models, cancellation tokens. Background tasks with real-time status, notification streaming. (`crates/goose/src/agents/subagent_handler.rs`, `platform_extensions/summon.rs`)
+
+### Scheduling
+
+- **Cron for Agent Sessions** — Runs actual agent sessions (not just shell commands) with full provider/extension context. Recipes validated with file size limits and symlink protection. (`crates/goose/src/scheduler.rs`)
+
+### Recipe System
+
+- **YAML Task Definitions** — Instructions, prompts, extensions, parameters, settings (model, temperature, max_turns), sub-recipes, response schemas, retry configs. (`crates/goose/src/recipe/`)
+
+### Plugin System
+
+- **Dual Format** — Gemini-style and OpenPlugins. Auto-update every 24 hours. Skills (SKILL.md), hooks, config. Project-level in `.agents/plugins/`. (`crates/goose/src/plugins/`)
+
+### Lifecycle Hooks
+
+- **11 Events** — PreToolUse, PostToolUse, PostToolUseFailure, SessionStart, SessionEnd, UserPromptSubmit, BeforeReadFile, AfterFileEdit, BeforeShellExecution, AfterShellExecution, Stop. Regex-matched. (`crates/goose/src/hooks/`)
+
+### Tool Inspector Pipeline
+
+- **Composable Inspectors** — Permission judge → security inspector → adversary inspector → egress inspector → repetition inspector. (`crates/goose/src/agents/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | MCP Extension model with malware check | Standard tool extensibility + safety |
+| HIGH | Orchestrator extension (multi-session) | Directly applicable to multi-agent architecture |
+| HIGH | Recipe system (YAML task definitions) | Task templates with sub-recipe composition |
+| HIGH | Subagent with background tasks | Clean async delegation pattern |
+| MEDIUM | Cron for agent sessions | Full-context scheduled execution |
+| MEDIUM | Plugin auto-update with 24h interval | Keeps extensions current |
+| MEDIUM | Tool Inspector pipeline | Composable safety inspection |
+| MEDIUM | Declarative provider system (YAML) | Add providers without code |
+| LOW | Summarize extension | Deterministic file load + LLM call primitive |
+| LOW | Chatrecall extension | Session search for contextual memory |

package/docs/reports/repos/gpt-pilot.md

@@ -0,0 +1,52 @@
+# GPT Pilot — Feature Inventory
+
+> **Repo:** `resources/gpt-pilot` | **Language:** Python
+> **Tagline:** The core logic for AI pair programmer
+
+## Overview
+
+GPT Pilot is a Python-based coding agent focused on structured development workflows. It features a step-based development process, test-driven development integration, and a BugHunter debugging loop. It emphasizes structured planning before implementation.
+
+## Feature Inventory
+
+### Structured Development Workflow
+
+- **Step-Based Development** — Breaks projects into ordered steps: architecture, planning, coding, testing, debugging. Each step has clear entry/exit criteria. (`pilot/`)
+
+### Test-Driven Development
+
+- **TDD Integration** — Generates tests before code, runs them, and iterates until passing. Test output feeds back into the coding loop. (`pilot/`)
+
+### BugHunter Debugging Loop
+
+- **Automated Debugging** — When tests fail, BugHunter analyzes error output, proposes fixes, and re-runs tests. Bounded by attempt ceiling. (`pilot/`)
+
+### Project Scaffolding
+
+- **Template System** — Generates project structure from templates with configurable options. (`pilot/`)
+
+### Agent-Computer Interface
+
+- **Curated Tools** — Provides structured file viewers, search commands, and editors rather than raw shell access. (`pilot/`)
+
+### Git Integration
+
+- **Automatic Commits** — Creates commits at logical boundaries with descriptive messages. (`pilot/`)
+
+### Conversation Management
+
+- **Context Window Management** — Manages conversation history within token limits using summarization. (`pilot/`)
+
+### LLM Provider Support
+
+- **Multiple Providers** — OpenAI, Anthropic, and other providers via a unified interface. (`pilot/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Step-Based Development Workflow | Structured planning before implementation |
+| HIGH | BugHunter Debugging Loop | Automated fix-and-retry for test failures |
+| MEDIUM | TDD Integration | Test-first development pattern |
+| MEDIUM | Project Scaffolding | Template-based project generation |
+| LOW | Curated ACI Tools | Agent-optimized tool surfaces |

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

@@ -0,0 +1,101 @@
+# Hermes Agent — Feature Inventory
+
+> **Repo:** `resources/hermes-agent` | **Language:** Python | **TUI:** TypeScript (Ink/React)
+> **Tagline:** Self-improving AI agent by Nous Research
+
+## Overview
+
+Hermes Agent is a Python-based personal AI agent with extreme breadth: ~95 tools, ~30 messaging channels, 35 model provider plugins, Kanban multi-agent work queue, Mixture-of-Agents loop, and a closed learning loop with autonomous skill creation and memory persistence.
+
+## Feature Inventory
+
+### Agent Core
+
+- **AIAgent Class** — Synchronous tool-calling loop with interrupt handling, budget tracking, one-turn grace calls. ~60 parameters. (`run_agent.py`, `agent/conversation_loop.py`)
+
+### Delegation System
+
+- **Role-Based Tool Blocking** — `delegate_task` spawns child AIAgent instances. Leaf vs orchestrator tool blocking. Spawn depth limits. Background delegation with async result re-entry. (`tools/delegate_tool.py`)
+
+### Kanban Multi-Agent Work Queue
+
+- **SQLite-Backed Board** — Multi-profile/worker collaboration. Dispatcher loop, worker toolset, board routing, failure detection with auto-blocking. Heartbeat monitoring. (`tools/kanban_tools.py`, `plugins/kanban/`)
+
+### Mixture-of-Agents (MoA)
+
+- **Reference-Model Context Gathering** — `/moa` command runs advisory calls in parallel. Per-model cost accounting and trace persistence. (`agent/moa_loop.py`)
+
+### Tool System
+
+- **AST Auto-Discovery** — `registry.register()` calls discovered via AST parsing. TTL-cached availability. (`tools/registry.py`)
+- **Toolsets** — Logical groupings (browser, terminal, memory, kanban). Platform-specific composition. (`toolsets.py`)
+- **MCP Client** — Full MCP with sampling, parallel tool calls, multi-transport. (`tools/mcp_tool.py`)
+
+### Terminal Backends
+
+- **6 Backends** — Local, Docker, SSH, Singularity, Modal, Daytona. Serverless persistence with hibernation. (`tools/environments/`)
+
+### Checkpoint Manager
+
+- **Shadow Git** — Transparent filesystem snapshots via shared shadow git. Content-addressable deduplication. Auto-snapshot before mutations. (`tools/checkpoint_manager.py`)
+
+### Memory & Learning
+
+- **Pluggable Memory Backends** — Honcho (dialectic user modeling), Mem0, Supermemory, ByteRover, Hindsight, Holographic, OpenViking, RetainDB. (`plugins/memory/`)
+- **Session Search (FTS5)** — SQLite FTS5 full-text search with LLM summarization. (`hermes_state.py`, `tools/session_search_tool.py`)
+- **Curator** — Background skill lifecycle management with auto-archiving. (`agent/curator.py`)
+- **Learning Graph** — Skill-memory relationship visualization. (`agent/learning_graph.py`)
+
+### Context Management
+
+- **Context Compressor** — Summarizes middle turns, protects head/tail. Structured summary with Resolved/Pending question tracking. (`agent/context_compressor.py`)
+- **Prompt Caching** — `system_and_3` layout with 4 cache_control breakpoints. (`agent/prompt_caching.py`)
+- **System Prompt Assembly** — Three-tier: stable, context, volatile. Cache-preserving construction. (`agent/system_prompt.py`)
+
+### Scheduling
+
+- **Cron Scheduler** — Duration, "every" phrases, 5-field cron, ISO timestamps. Per-job skills, model overrides, scripts, multi-platform delivery. (`cron/scheduler.py`)
+
+### Plugin System
+
+- **Four-Source Discovery** — Bundled, user (`~/.hermes/plugins/`), project (`./.hermes/plugins/`), pip entry points. (`hermes_cli/plugins.py`)
+- **33 Model Provider Plugins** — OpenRouter, Anthropic, GMI, DeepSeek, NVIDIA, Ollama, Copilot, Bedrock, Vertex, xAI, etc. (`plugins/model-providers/`)
+
+### UI Surfaces
+
+- **Classic CLI** — Rich + prompt_toolkit with skin engine for theming. (`cli.py`)
+- **TUI** — Ink/React with TypeScript rendering, Python backend via JSON-RPC. (`ui-tui/src/`)
+- **Electron Desktop** — `@assistant-ui/react` with JSON-RPC transport. (`apps/desktop/`)
+- **Web Dashboard** — Embeds real TUI via PTY bridge with xterm.js. (`hermes_cli/web_server.py`)
+- **Messaging Gateway** — 20+ platform adapters (Telegram, Discord, Slack, WhatsApp, Signal, etc.). (`gateway/platforms/`)
+
+### Security
+
+- **Command Approval** — Per-session queue with subagent callbacks. (`tools/approval.py`)
+- **Path/URL Safety** — Dedicated modules. (`tools/path_security.py`, `tools/url_safety.py`)
+- **Credential Pool** — Multi-credential failover with borrowing semantics. (`agent/credential_pool.py`)
+
+### Other
+
+- **Verification Evidence Ledger** — Passive verification with turn-end guards. (`agent/verification_evidence.py`)
+- **Pet System (Petdex)** — Animated sprites for agent activity visualization. (`agent/pet/`)
+- **Scale-to-Zero** — Idle detection + dormant-quiesce for gateway. Fly.io suspend/resume. (`gateway/scale_to_zero.py`)
+- **Footprint Ladder** — Formal capability addition hierarchy. (AGENTS.md)
+- **Profile System** — Multiple isolated instances with separate HERMES_HOME. (`hermes_cli/profiles.py`)
+- **Batch Runner** — Parallel batch processing with checkpointing. (`batch_runner.py`)
+- **Trajectory Compressor** — Training-focused trajectory compression. (`trajectory_compressor.py`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Tool Registry with AST Auto-Discovery | Elegant pattern for plugin-heavy systems |
+| HIGH | Delegation with Role-Based Tool Blocking | Essential for multi-agent orchestration |
+| HIGH | Kanban Multi-Agent Work Queue | Excellent for parallel workstreams |
+| HIGH | Checkpoint Manager (Shadow Git) | Transparent filesystem snapshots |
+| HIGH | Context Compressor with Historical Headings | Sophisticated context management |
+| MEDIUM | Verification Evidence Ledger | Passive verification for coding agents |
+| MEDIUM | Credential Pool with Failover | Multi-credential management |
+| MEDIUM | Slash Command Registry (Single Source of Truth) | Multi-surface UI pattern |
+| MEDIUM | Footprint Ladder (Capability Decision Hierarchy) | Architectural guidance for growth |
+| LOW | Scale-to-Zero for Cloud Deployment | Cost optimization |

package/docs/reports/repos/kilocode.md

@@ -0,0 +1,79 @@
+# Kilo Code — Feature Inventory
+
+> **Repo:** `resources/kilocode` | **Stack:** TypeScript/Bun + Effect-TS | **Version:** 7.4.11
+> **License:** MIT | **Nature:** Fork of OpenCode
+
+## Overview
+
+Kilo Code is a TypeScript/Bun coding agent built on the Effect-TS functional-effect library. It features a route-based LLM provider system (4-axis decomposition), profile-based sandboxing, permission-controlled agent tool access with wildcard patterns, and a memory system with indexed search and secret filtering.
+
+## Feature Inventory
+
+### Architecture
+
+- **Effect-TS Service Architecture** — Every subsystem is an Effect `Service` with `Layer` composition. `LayerNode` enforces Location-scoped vs global-scoped services at the type level. `InstanceState.make(init, dispose?)` creates project-scoped lazy singletons via `AsyncLocalStorage`. (`packages/opencode/src/agent/agent.ts`, `packages/opencode/src/effect/instance-state.ts`)
+
+### Agent System
+
+- **Permission-Controlled Tool Access** — 7+ built-in agents (code, plan, general, explore, scout, compaction, title, summary) plus user-defined custom agents. Typed `permission` rulesets with wildcard matching. `Permission.merge(defaults, user)` composition. (`packages/opencode/src/agent/agent.ts`, `packages/opencode/src/permission/index.ts`)
+- **Subagent/Task Orchestration** — `task` tool spawns child sessions in foreground/background. Cost propagation, resumable task IDs, background auto-notify. (`packages/opencode/src/tool/task.ts`)
+- **Agent Requirements** — Pre-flight validation of MCP servers, skills before execution. (`packages/opencode/src/kilocode/agent-requirements.ts`)
+
+### Tool System
+
+- **Tool.define Pattern** — `Tool.define(id, init)` returns `{ description, parameters, execute }`. Auto-truncation with managed output files (bounded preview + complete file). (`packages/opencode/src/tool/tool.ts`, `packages/opencode/src/tool/truncate.ts`)
+- **48 Built-in Tools** — `apply_patch`, `edit`, `glob`, `grep`, `lsp`, `read`, `write`, `shell`, `task`, `webfetch`, `websearch`, `skill`, `recall` (memory), `repo_clone`, `warpgrep`, `diagnostics`. (`packages/opencode/src/tool/`)
+
+### LLM Provider System
+
+- **Route-Based 4-Axis Architecture** — Protocol (API contract), Endpoint (URL), Auth (credentials), Framing (stream parsing). 5-15 lines per new provider. DeepSeek, TogetherAI, Cerebras all reuse `OpenAIChat.protocol`. (`packages/llm/src/route/client.ts`, `packages/llm/src/protocols/`)
+- **Provider Facades** — `OpenAI.configure({ apiKey }).responses("gpt-4o-mini")`. (`packages/llm/src/providers/openai.ts`)
+- **Recorded Test Cassettes** — VCR-style cassettes with multi-interaction support. (`packages/llm/test/`)
+
+### Session Management
+
+- **Context Epochs** — Immutable baseline system context per epoch. Changes admitted lazily at safe provider-turn boundaries. `SystemContextRegistry` with ordered, scoped contributions. (`packages/opencode/CONTEXT.md`, `packages/opencode/src/session/system.ts`)
+- **Compaction** — Chunked processing, payload recovery, replay of user turns. `preserve_recent_tokens` budget. (`packages/opencode/src/session/compaction.ts`)
+
+### Permission System
+
+- **Wildcard Pattern Matching** — `Wildcard.match` with `ask/allow/deny` actions. Composable via `Permission.merge(...)`. Config file protection for `.env`, `*.env.*`. (`packages/opencode/src/permission/index.ts`)
+
+### Sandbox System
+
+- **Profile-Based Sandboxing** — Three-axis: filesystem (allow/deny write paths), network (allow/deny/proxy), environment (deny vars, set vars). Bubblewrap/Seatbelt backend support. Network proxy with per-session tokens. (`packages/kilo-sandbox/src/profile.ts`, `packages/kilo-sandbox/src/network.ts`)
+
+### Memory System
+
+- **Indexed Search** — `remember`, `forget`, `correct`, `recall`, `catalog` operations. Token-based budgeting, auto-consolidation. Session digest recording. Secret filtering. (`packages/kilo-memory/src/memory.ts`)
+
+### Skills System
+
+- **Multi-Location Discovery** — Global (`~/.claude/skills/`), project (`.kilo/skills/`), config, custom paths. Trust provenance tracking. Built-in skills seed before user skills. (`packages/opencode/src/skill/index.ts`)
+
+### Worktree Management
+
+- **Git Worktree Isolation** — Create, list, remove, reset. Handles Windows fsmonitor daemon stop. (`packages/opencode/src/worktree/index.ts`)
+
+### Other
+
+- **MCP Integration** — Full client with OAuth, tool listing, prompt caching, resource reading. (`packages/opencode/src/mcp/index.ts`)
+- **Hono HTTP Server** — OpenAPI spec generation, SSE for real-time events, auto-generated TypeScript SDK. (`packages/opencode/src/server/server.ts`)
+- **mDNS Discovery** — Server registers via mDNS for local network discovery. (`packages/opencode/src/server/mdns.ts`)
+- **Tree-Sitter Indexing** — Language detection, file extension mapping, header extraction. (`packages/kilo-indexing/src/`)
+- **PostHog + OpenTelemetry** — Telemetry with per-request tracing. (`packages/kilo-telemetry/src/`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Effect-TS Service Architecture | Structured concurrency, typed errors, clean DI |
+| HIGH | Route-Based LLM Provider System | Composable 4-axis provider abstraction |
+| HIGH | Profile-Based Sandboxing | Filesystem/network/environment constraints |
+| HIGH | Permission-Controlled Agent Tool Access | Wildcard patterns, composable rulesets |
+| HIGH | Subagent with Cost Propagation | Background tasks with cost tracking |
+| HIGH | Context Epochs | Formal context management model |
+| HIGH | Memory with Indexed Search | Project memory, session digests, secret filtering |
+| MEDIUM | Git Worktree Isolation | Parallel sessions with cleanup |
+| MEDIUM | SKILL.md Discovery with Trust Provenance | Multi-location skill loading with security |
+| MEDIUM | Tool Auto-Truncation | Managed output files prevent context overflow |

package/docs/reports/repos/openclaude.md

@@ -0,0 +1,99 @@
+# OpenClaude — Feature Inventory
+
+> **Repo:** `resources/openclaude` | **Language:** TypeScript
+> **Nature:** Claude-Code-style coding agent
+
+## Overview
+
+OpenClaude is a TypeScript coding agent with 20+ LLM providers, smart model routing, coordinator-mode multi-agent orchestration, a tree-sitter + PageRank repo map, auto-dream memory consolidation, context collapse, cron scheduling, tool search (deferred discovery), and a comprehensive skills system.
+
+## Feature Inventory
+
+### Multi-Provider Gateway
+
+- **20+ Providers** — OpenAI-compatible, Gemini, GitHub Models, Codex OAuth, Ollama, Fireworks, MiMo, NEAR AI, Cloudflare, Bedrock/Vertex/Foundry. OpenAI shim normalizes all providers. (`src/services/api/`, `src/integrations/`)
+
+### Smart Model Routing
+
+- **Complexity Classifier** — Routes simple turns (chit-chat) to cheap model, complex coding to strong model. Heuristics: word count, keywords, code fences, turn number. (`src/services/api/smartModelRouting.ts`)
+
+### Agent Routing
+
+- **Per-Agent Model Overrides** — Route Explore/Plan/verification/worker agents to different models/providers. `maxSteps` caps. (`src/services/api/agentRouting.ts`)
+
+### Coordinator Mode
+
+- **Multi-Agent Orchestration** — Main agent spawns parallel workers via `AgentTool`, continues via `SendMessageTool`, stops via `TaskStopTool`. Synthesis-before-delegation. `<task-notification>` XML protocol. (`src/coordinator/coordinatorMode.ts`)
+
+### Agent Swarms / Teams
+
+- **Named Teams** — Team lead + teammates with colors, names, roles. Persistent team files. Inter-agent messaging. (`src/tools/TeamCreateTool/`, `src/utils/swarm/`)
+
+### MCP Integration
+
+- **Full Client** — stdio, SSE, Streamable HTTP, WebSocket. InProcessTransport for same-process. SDK control transport bridge. OAuth. (`src/services/mcp/`)
+
+### Repo Map (PageRank + tree-sitter)
+
+- **Structural Code Map** — tree-sitter symbol extraction, dependency graph, PageRank ranking, token-budgeted rendering. File-stat fingerprinting cache. (`src/context/repoMap/`)
+
+### Memory System
+
+- **Auto-Dream** — Background subagent consolidates session transcripts into durable memory. Time gate (24h), session gate (5+), consolidation lock. 4-stage prompt. (`src/services/autoDream/`)
+- **Extract Memories** — Forked subagent extracts memories at end of each query loop. Structured memory types (decisions, facts, patterns). (`src/services/extractMemories/`)
+- **Session Memory** — Background maintenance of session notes file. (`src/services/SessionMemory/`)
+
+### Context Management
+
+- **Context Collapse** — Risk-scored span selection, staged collapse, dedicated "ctx agent" subagent. (`src/services/contextCollapse/`)
+- **Auto-Compact** — Multiple strategies: full, micro, reactive, snip, session memory. (`src/services/compact/`)
+
+### Cron Scheduling
+
+- **Agent-Initiated Tasks** — In-memory (session-only) and durable (`.openclaude/scheduled_tasks.json`). Max 50 jobs. (`src/tools/ScheduleCronTool/`)
+
+### Tool Search
+
+- **Deferred Discovery** — When many tools exist, compacted via `ToolSearchTool`. Agent discovers on-demand via keyword search. (`src/tools/ToolSearchTool/`)
+
+### Skills System
+
+- **Bundled + User** — 17+ bundled skills (batch, simplify, debug, loop, PDF, etc.). File extraction, hooks, MCP-derived skills. (`src/skills/`)
+
+### Built-in Agents
+
+- **6 Agent Types** — GeneralPurpose, Explore, Plan, Verification, ClaudeCodeGuide, StatuslineSetup. Tool restrictions per agent. (`src/tools/AgentTool/builtInAgents.ts`)
+
+### Other
+
+- **LSP Tool** — Language server integration for symbols, diagnostics, formatting. (`src/tools/LSPTool/`)
+- **Goal System** — Structured goal-tracking with evaluators, turn limits, auto-evaluation. (`src/services/goal/`)
+- **Git Worktree Isolation** — Create, work, exit. State persisted per-session. (`src/tools/EnterWorktreeTool/`)
+- **Background Sessions** — Non-interactive local child processes with metadata/logs. (`src/daemon/`)
+- **Web Search** — 10+ providers with DuckDuckGo free fallback. (`src/tools/WebSearchTool/providers/`)
+- **Voice Input** — Push-to-talk with native audio capture. (`src/voice/`)
+- **Vim Mode** — Full vim input mode. (`src/vim/`)
+- **Companion/Buddy System** — Pixel-art companion with 7 types and signature moves. (`src/buddy/`)
+- **VS Code Extension** — In-editor chat, provider-aware Control Center. (`vscode-extension/`)
+- **gRPC Server** — Headless bidirectional streaming. 1000 concurrent sessions. (`src/grpc/`)
+- **Wiki/Knowledge System** — Conventions tracking, identity management. (`src/services/wiki/`)
+- **PR Subscription** — Subscribe to GitHub PR events. (`src/tools/SubscribePRTool/`)
+- **Auto-Fix** — Lint/test auto-remediation with timeout handling. (`src/services/autoFix/`)
+- **Proactive Mode** — Agent can take actions proactively. (`src/proactive/`)
+- **Context Visualization** — Token usage, message breakdown, context pressure. (`src/components/ContextVisualization.tsx`)
+- **Session Resume & Fork** — Resume by ID, continue recent, or fork (branch). (`src/history.ts`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Coordinator Mode | Multi-agent orchestration with synthesis-before-delegation |
+| HIGH | Repo Map (tree-sitter + PageRank) | Codebase intelligence |
+| HIGH | Agent Routing (per-agent model overrides) | Cost optimization |
+| HIGH | Smart Model Routing | Simple vs. complex turn routing |
+| HIGH | Tool Search (deferred discovery) | Prevents tool bloat |
+| MEDIUM | Auto-Dream (memory consolidation) | Background memory maintenance |
+| MEDIUM | Context Collapse | Sophisticated context management |
+| MEDIUM | Git Worktree Isolation | Clean parallel work |
+| MEDIUM | Goal System | Structured goal-tracking |
+| MEDIUM | Cron Scheduling | Agent-initiated tasks |

package/docs/reports/repos/openclaw.md

@@ -0,0 +1,100 @@
+# OpenClaw — Feature Inventory
+
+> **Repo:** `resources/openclaw` | **Stack:** Node.js, TypeScript ESM, pnpm workspace
+> **License:** MIT | **Version:** 2026.7.2
+
+## Overview
+
+OpenClaw is a personal AI assistant platform (NOT a coding agent) with 22+ messaging channels, 150+ provider extensions, 52 skills, a plugin SDK, swarm mode, code mode (QuickJS sandbox), memory dreaming, and a gateway daemon architecture. It is the broadest platform in the ecosystem.
+
+## Feature Inventory
+
+### Gateway Architecture
+
+- **Local-First Daemon** — Single long-running process owning all sessions, channels, tools, events, state. WebSocket + HTTP control plane. (`src/gateway/server.ts`)
+
+### Multi-Channel Inbox (22+ Platforms)
+
+- **Unified Inbox** — WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, IRC, Teams, Matrix, Feishu, LINE, Mattermost, Nostr, Twitch, WeChat, QQ, WebChat, etc. Channels are transport-only; render portable presentation/actions. (`extensions/whatsapp/`, `extensions/telegram/`, etc.)
+
+### Plugin SDK & Extensions
+
+- **159 Bundled Extensions** — Code plugins (runtime hooks, providers, channels, tools) and bundle plugins (skills, MCP servers, config). 150+ typed subpath exports. (`src/plugin-sdk/`, `extensions/`)
+
+### Provider Integration
+
+- **30+ Providers** — OpenAI, Anthropic, Google, Azure, Bedrock, Cohere, Mistral, Groq, DeepSeek, xAI, Ollama, LM Studio, vLLM, OpenRouter. Auth profile rotation with cooldown/expiry/round-robin. (`extensions/openai/`, `extensions/anthropic/`, etc.)
+
+### Agent Orchestration
+
+- **Subagent Registry** — SQLite-backed with orphan detection, liveness probes, delivery retries, steering queue. (`src/agents/subagent-registry.ts`)
+- **Swarm Mode** — Lane-based concurrency limiter with per-group quotas. Retry with backoff. (`src/agents/swarm-scheduler.ts`)
+
+### Tool Search
+
+- **Dynamic Discovery** — `tool_search`, `tool_describe`, `tool_call`, `tool_search_code`. Keeps context lean. Code mode variant in QuickJS. (`src/agents/tool-search.ts`)
+
+### Code Mode (QuickJS)
+
+- **Sandboxed Execution** — QuickJS WASM runtime with memory limits, timeouts, output caps. Bridged tool search/call/yield. (`src/agents/code-mode.ts`)
+
+### Sandbox System
+
+- **Pluggable Backends** — Docker, SSH, OpenShell. Tool policy layer. Workspace mounting, remote filesystem bridges. (`src/agents/sandbox/`)
+
+### Memory System
+
+- **Dreaming** — Background cron jobs that "dream" (process transcripts into long-term memory). Light dreaming (periodic) and REM dreaming (deeper consolidation). Short-term → long-term promotion with budget constraints. (`extensions/memory-core/src/dreaming.ts`)
+
+### Cron System
+
+- **Production-Grade** — Declarative job definitions, delivery channels, session targeting (main/isolated), retry policies, heartbeat monitoring, pacing controls. (`src/cron/`)
+
+### MCP Support
+
+- **Bidirectional** — Both server and client. Channel bridging allows MCP tools from messaging channels. (`src/mcp/`)
+
+### Session Management
+
+- **Compaction** — Staged summarization with adaptive chunking, identifier preservation (UUIDs, hashes, URLs), circuit-breaker on generic fallbacks. (`src/agents/sessions/agent-session-compaction.ts`)
+
+### Security
+
+- **Multi-Layer** — DM pairing, allowlists, tool policies (allow/deny per tool per scope), sandbox restrictions, SSRF protection, credential isolation. Tool policy pipeline applies policies from multiple sources. (`src/security/`, `src/agents/tool-policy.ts`)
+
+### Skills System
+
+- **52 Bundled Skills** — 1Password, Apple Notes, GitHub, Spotify, Weather, etc. Skill-workshop for runtime creation. ClawHub marketplace. (`skills/`, `src/skills/`)
+
+### Context Engine
+
+- **Pluggable Providers** — Registered context providers for different information sources. (`src/context-engine/`)
+
+### Other
+
+- **Voice & Talk Mode** — Wake words, push-to-talk, continuous voice, realtime sessions via ElevenLabs. (`src/talk/`)
+- **Live Canvas** — Agent-driven visual workspace (A2UI). (`src/canvas/`)
+- **Browser Extension** — Chrome extension integration with profile management. (`extensions/browser/`)
+- **Device Pairing** — iOS/Android/macOS companion apps as "nodes". (`src/gateway/node-registry.ts`)
+- **Control UI** — Web dashboard (Vite + Lit). (`ui/src/`)
+- **QA System** — YAML-defined scenarios with maturity scoring. (`qa/scenarios/`)
+- **ACP (Agent Communication Protocol)** — Inter-agent spawn, steering, completion tracking. (`src/agents/acp-runtime-overlay.ts`)
+- **SQLite-First Storage** — All runtime state in SQLite with Kysely. (`src/config/sessions/store-writer.ts`)
+- **Tailscale Integration** — Zero-config secure remote access. (`src/gateway/server-tailscale.ts`)
+- **OpenAI Responses API Compat** — Compatibility surface for OpenAI tools. (`src/gateway/openresponses-http.ts`)
+- **Auth Profile Rotation** — Multi-profile with cooldown, expiry, round-robin, async primary probing. (`src/agents/auth-profiles.ts`)
+
+## Top Adoptable Ideas for savant-code
+
+| Priority | Feature | Why |
+|----------|---------|-----|
+| HIGH | Auth Profile Rotation with Cooldown | Prevents single-point-of-failure |
+| HIGH | Subagent Registry with SQLite Persistence | Formalizes agent lifecycle |
+| HIGH | Tool Search Pattern | Keeps context windows lean |
+| HIGH | Plugin Manifest System | Third-party extensibility |
+| HIGH | Layered Tool Policy Pipeline | Restricts tools by role and security context |
+| MEDIUM | Compaction with Identifier Preservation | Summarizes without losing FIDs/SHAs |
+| MEDIUM | Memory Dreaming (Background Consolidation) | Auto-extracts lessons |
+| MEDIUM | Context Engine with Registered Providers | Formalizes prompt composition |
+| MEDIUM | SQLite-First Storage | Better concurrency than file-based |
+| LOW | Swarm Scheduler (Lane-Based Concurrency) | If agent concurrency grows |