@adaptic/maestro 1.1.7 → 1.4.1

package/README.md

@@ -152,7 +152,7 @@ After scaffolding, run `claude "/init-maestro"` to configure your agent. This is
 | **1. Identity Gathering** | Prompts for agent name, surname, title, archetype, email, phone, Mac mini hostname, principal (reporting line), responsibilities, communication style, operating principles |
 | **2. Parallel Rewrite** | 8 sub-agents rewrite the repo in parallel: `config/agent.ts`, `CLAUDE.md`, config files, `package.json`, scripts, agent definitions, triggers/workflows, and agent-specific tools/skills |
 | **3. Machine Config** | Generates launchd plists with the correct agent name, installs them, optionally configures macOS for headless 24/7 operation |
-| **4. Service Setup** | Walks through Slack, Gmail, Twilio, Cloudflare, voice integration -- writing credentials to `.env` |
+| **4. Service Setup** | Walks through Slack, Gmail, Twilio, Cloudflare, voice integration -- writing credentials to `.env`. See [Voice & SMS Setup Guide](docs/guides/voice-sms-setup.md) for detailed telephony instructions |
 | **5. README** | Generates an agent-specific README.md |
 | **6. GitHub Repo** | Optionally creates a GitHub repository and pushes the initial commit |
 | **7. Verification** | Greps for stale references, validates `config/agent.ts`, runs healthcheck, prints summary |
@@ -361,11 +361,56 @@ Security policies are defined in `policies/` and `docs/governance/`.
 
 ## Key Documentation
 
-- [Agent Persona Setup Guide](docs/guides/agent-persona-setup.md) -- Detailed guide for configuring identity, operating charter, and behavioural policies
+### Setup Guides
+
+- [Agent Persona Setup](docs/guides/agent-persona-setup.md) -- Identity, operating charter, and behavioural policies
+- [Email Setup](docs/guides/email-setup.md) -- Gmail IMAP polling, SMTP sending, thread dedup, signatures
+- [Slack Setup](docs/guides/slack-setup.md) -- Slack app, tokens, sending, typing indicators, events, CDP
+- [WhatsApp Setup](docs/guides/whatsapp-setup.md) -- Twilio WhatsApp sandbox/production, webhook handler
+- [Voice & SMS Setup](docs/guides/voice-sms-setup.md) -- Twilio SMS, Slack huddle voice, Deepgram STT, ElevenLabs TTS
+- [Poller & Daemon Setup](docs/guides/poller-daemon-setup.md) -- Event polling, reactive daemon, triggers, watchdog
+- [Outbound Governance Setup](docs/guides/outbound-governance-setup.md) -- Hooks, dedup, information barriers, disclosure
+- [RAG & Context Setup](docs/guides/rag-context-setup.md) -- SQLite FTS5 search, pre-draft context, entity indexing
+- [PDF Generation Setup](docs/guides/pdf-generation-setup.md) -- Pandoc + XeLaTeX branded document generation
+- [Media Generation Setup](docs/guides/media-generation-setup.md) -- Gemini/Veo image and video generation
+- [Claude-Mem Setup](docs/guides/claude-mem-setup.md) -- Persistent session memory with semantic recall
+- [Claude-Pace Setup](docs/guides/claude-pace-setup.md) -- Real-time rate limit tracking and burn rate awareness
+- [ccxray Diagnostics](docs/guides/ccxray-diagnostics.md) -- Token/cost analysis and session debugging
+- [Claudraband Sessions](docs/guides/claudraband-sessions.md) -- Persistent sessions, daemon mode, HTTP API
+- [ClawTeam Swarm](docs/guides/clawteam-swarm.md) -- Multi-agent coding swarm orchestration via git worktrees
+- [Agents Observe](docs/guides/agents-observe-setup.md) -- Real-time multi-agent observability dashboard
+- [Code-Review-Graph](docs/guides/code-review-graph-setup.md) -- Tree-sitter structural knowledge graph for codebases
+- [Self-Optimization Pattern](docs/guides/self-optimization-pattern.md) -- AutoAgent-inspired benchmark-driven self-improvement
+
+### Architecture & Governance
+
 - [System Architecture](docs/architecture/system-architecture.md) -- Full system design and component overview
 - [Agent Topology](docs/architecture/agent-topology.md) -- Sub-agent hierarchy and delegation model
 - [Action Approval Model](docs/governance/action-approval-model.md) -- Communication governance and approval levels
 - [Communications Policy](docs/governance/communications-policy.md) -- Voice modes, autonomy model, escalation rules
+
+### Dev Tooling
+
+Approved third-party tools for agent development and observability. Install with:
+
+```bash
+./scripts/setup/install-dev-tools.sh --all
+```
+
+| Tool | Purpose | Install |
+|------|---------|---------|
+| **claude-pace** | Rate limit status line tracker | `--tool claude-pace` |
+| **agents-observe** | Multi-agent observability dashboard | `--tool agents-observe` |
+| **ccxray** | Token/cost observability proxy | `--tool ccxray` |
+| **ClawTeam** | Git worktree swarm orchestrator | `--tool clawteam` |
+| **code-review-graph** | Tree-sitter codebase knowledge graph | `--tool code-review-graph` |
+
+### Cross-Agent Message Routing
+
+When multiple agents monitor the same Slack channels, the daemon classifier uses `config/known-agents.json` to prevent cross-agent message interception. If a message @-mentions a specific agent, only that agent's daemon will respond. Update this file when agents are added or removed.
+
+### Runbooks
+
 - [Mac Mini Bootstrap](docs/runbooks/mac-mini-bootstrap.md) -- Hardware setup and initial configuration
 - [Perpetual Operations](docs/runbooks/perpetual-operations.md) -- Keeping the agent running 24/7
 - [Recovery and Failover](docs/runbooks/recovery-and-failover.md) -- Disaster recovery procedures

package/bin/maestro.mjs

@@ -81,6 +81,7 @@ function create(targetName) {
     "desktop-control",
     "ingest",
     "mcp",
+    "services",
   ];
 
   for (const dir of frameworkDirs) {
@@ -595,7 +596,6 @@ rubrics: []
       upgrade: "npx @adaptic/maestro upgrade",
     },
     dependencies: {
-      "@anthropic-ai/sdk": "^0.82.0",
       "@google/genai": "^1.42.0",
       dotenv: "^16.4.5",
       execa: "^9.6.1",

package/docs/guides/agents-observe-setup.md

@@ -0,0 +1,64 @@
+# Agents Observe — Multi-Agent Observability Dashboard
+
+Real-time dashboard for monitoring Claude Code agent teams. Captures tool calls, agent hierarchy, and session state via background hooks with SQLite storage.
+
+## Why It Matters
+
+Maestro agents run parallel backlog execution with multiple subagents. Currently debugging relies on post-hoc JSONL log scanning. Agents Observe provides real-time visibility into:
+
+- **Live tool calls** across all active agents
+- **Agent hierarchy trees** showing parent/child relationships
+- **Search and filter** across sessions and tool invocations
+- **WebSocket-streamed UI** with 3-5ms latency
+
+## Installation
+
+### Via install-dev-tools (recommended)
+
+```bash
+./scripts/setup/install-dev-tools.sh --tool agents-observe
+```
+
+### Manual
+
+```bash
+# As Claude Code plugin
+claude plugin install agents-observe
+
+# Or global npm
+npm install -g agents-observe
+```
+
+## Usage
+
+### Start the dashboard
+
+```bash
+agents-observe serve
+# Opens dashboard at http://localhost:3847
+```
+
+### View active agent sessions
+
+Navigate to the dashboard URL. Active sessions appear automatically when Claude Code agents run with the plugin enabled.
+
+### Query session history
+
+```bash
+agents-observe query --session <id>
+agents-observe query --tool Write --last 1h
+```
+
+## Integration with Maestro
+
+Best used during:
+- **Backlog executor cycles** — monitor parallel agent performance
+- **Debugging agent failures** — trace tool call sequences leading to errors
+- **Performance profiling** — identify slow or redundant tool calls
+
+Not recommended as always-on in production (SQLite write overhead). Enable on-demand for debugging and profiling sessions.
+
+## Repository
+
+- GitHub: https://github.com/simple10/agents-observe
+- License: MIT

package/docs/guides/ccxray-diagnostics.md

@@ -0,0 +1,65 @@
+# ccxray Diagnostics Guide
+
+ccxray provides X-ray vision into Claude Code sessions via a transparent HTTP proxy and live dashboard. It intercepts all API calls between Claude Code and Anthropic, giving you detailed token/cost analysis, timing breakdowns, and system prompt visibility.
+
+## When to Use
+
+- Debugging expensive sessions (high token burn, unexpectedly long runs)
+- Understanding which tool calls consumed the most tokens
+- Comparing system prompts across main agent and sub-agents
+- Investigating context window utilisation and heatmaps
+- Post-incident analysis of failed or timed-out sessions
+
+## What It Shows
+
+- Real-time timeline of agent turns with thinking durations
+- Per-turn token and cost breakdown with burn rate tracking
+- Context window heatmaps showing what's consuming space
+- System prompt diffs across main agent and sub-agents
+- Multi-project hub: multiple terminals share one dashboard
+- Full JSON logging of every request/response to `~/.ccxray/logs/`
+
+## Technical Details
+
+- Zero-config transparent HTTP proxy
+- Launches Claude Code through the proxy automatically
+- Web dashboard for live monitoring
+- JSON log files for post-hoc analysis
+- npx-based — no permanent installation required
+
+## Usage
+
+### Quick start
+
+```bash
+# Launch Claude Code through the ccxray proxy
+npx ccxray claude
+```
+
+This starts the proxy, opens the dashboard, and launches Claude Code. All API traffic flows through ccxray for inspection.
+
+### With an existing session
+
+```bash
+# Start the proxy on a specific port
+npx ccxray --port 8080
+```
+
+### Viewing logs
+
+Logs are stored at `~/.ccxray/logs/` as JSON files, one per session. These can be analysed post-hoc for cost attribution.
+
+## Repository
+
+- GitHub: https://github.com/lis186/ccxray
+- License: MIT
+
+## Integration with Maestro
+
+ccxray is a diagnostic tool, not a runtime dependency. It is not installed by default via `init-agent.sh` but is available on-demand via npx.
+
+Use cases for Maestro operators:
+- **Token budget audit**: Run a backlog cycle through ccxray to see per-task token costs
+- **Sub-agent analysis**: Compare token usage across spawned background agents
+- **Prompt debugging**: Inspect what system prompts sub-agents actually receive
+- **Cost optimisation**: Identify which tool calls are disproportionately expensive

package/docs/guides/claude-mem-setup.md

@@ -0,0 +1,79 @@
+# Claude-Mem Setup Guide
+
+Claude-Mem is a persistent session memory plugin for Claude Code. It automatically captures tool usage, generates semantic summaries, and injects relevant context into future sessions — giving your agent continuity of knowledge across session boundaries.
+
+## What Claude-Mem Does
+
+- **Automatic capture**: 6 lifecycle hooks (SessionStart, UserPromptSubmit, PostToolUse, Stop, SessionEnd, PreCompact) record agent activity without manual intervention
+- **AI-powered compression**: Captured actions are summarised via Claude's agent-sdk into semantic memory
+- **Vector search**: Relevant past context is retrieved and injected at session start using Chroma vector search
+- **Local storage**: All data stays on-machine in `~/.claude-mem/` (SQLite + Chroma)
+
+## Installation
+
+### Via init-agent (recommended)
+
+If you ran `scripts/setup/init-agent.sh`, Claude-Mem was installed automatically. Verify:
+
+```bash
+npx claude-mem status
+```
+
+### Manual installation
+
+```bash
+npx claude-mem install
+```
+
+This registers the plugin hooks and starts the worker service (port 37777).
+
+### Via Claude Code plugin commands
+
+```bash
+claude plugin marketplace add thedotmack/claude-mem
+claude plugin install claude-mem
+# Restart Claude Code
+```
+
+## Configuration
+
+Settings live at `~/.claude-mem/settings.json` (auto-created with defaults on first run):
+
+- **AI model**: Which model compresses captured data
+- **Worker port**: Default 37777
+- **Data directory**: Where SQLite and vector indices are stored
+- **Context injection**: How much past context to inject per session
+- **Log level**: Verbosity of worker logs
+
+## Verification
+
+```bash
+# Check worker is running
+npx claude-mem status
+
+# View captured sessions
+npx claude-mem sessions list
+
+# View memory stats
+npx claude-mem stats
+```
+
+## How It Complements Maestro's Memory
+
+Maestro already has:
+- **Interaction memory** (`memory/interactions/`) — conversation transcripts by channel/date
+- **User profiles** (`memory/profiles/`) — per-person preferences and standing instructions
+- **Knowledge base** (`knowledge/`) — entities, decisions, syntheses
+
+Claude-Mem adds:
+- **Session-level recall** — what tools were used, what worked, what failed
+- **Semantic search across sessions** — find past sessions where similar tasks were done
+- **Automatic context injection** — no manual "read the last session" needed
+
+Together they provide comprehensive memory: Maestro handles *what was communicated*, Claude-Mem handles *what was done*.
+
+## Troubleshooting
+
+- **Worker not starting**: Check `~/.claude-mem/logs/` for errors. Ensure port 37777 is free.
+- **No context injected**: Verify hooks are registered: check `~/.claude/settings.json` for claude-mem entries
+- **High memory usage**: Claude-Mem's Chroma index grows over time. Run `npx claude-mem compact` to optimise.

package/docs/guides/claude-pace-setup.md

@@ -0,0 +1,56 @@
+# Claude-Pace Setup Guide
+
+Claude-Pace is a real-time rate limit tracker for Claude Code. It displays a status line showing your 5-hour and 7-day quota usage, reset countdowns, and a pace delta indicator (green = headroom, red = burning too fast).
+
+## Why It Matters
+
+Maestro agents run continuously on 10-minute backlog cycles. Without rate limit visibility, sessions hit quota walls mid-task — the backlog executor stalls, scheduled workflows fail silently, and recovery requires manual intervention. Claude-Pace makes quota state visible so agents (and operators) can pace work intelligently.
+
+## What It Shows
+
+- 5-hour and 7-day quota usage percentages
+- Reset countdown timers
+- Pace delta: whether current burn rate will exhaust quota before reset
+- Current model, effort level, git branch, diff stats
+
+## Technical Details
+
+- Pure Bash + jq — no npm, no Node, no network calls
+- ~10ms runtime per status line refresh
+- Single file: `claude-pace.sh`
+- Reads Claude Code's local quota cache
+
+## Installation
+
+### Via init-agent (recommended)
+
+If you ran `scripts/setup/init-agent.sh`, Claude-Pace was installed automatically. Verify:
+
+```bash
+# Check if the plugin is installed
+claude plugin list | grep claude-pace
+```
+
+### Via Claude Code plugin system
+
+```bash
+claude plugin marketplace add Astro-Han/claude-pace
+claude plugin install claude-pace
+# Restart Claude Code or run /reload-plugins
+claude-pace:setup
+```
+
+### Manual installation
+
+Download `claude-pace.sh` from the repository and add to `~/.claude/settings.json` under `statusLine`.
+
+## Repository
+
+- GitHub: https://github.com/Astro-Han/claude-pace
+- License: MIT
+
+## Integration with Maestro
+
+Claude-Pace complements Maestro's existing rate-limit detection (see `project_rate_limit_detection` memory). While Maestro detects rate limits reactively via workflow log analysis ("started" without "completed"), Claude-Pace provides proactive visibility — operators see quota state before it becomes a problem.
+
+For agents running heavy backlog cycles, the pace delta indicator is the key signal: if it's red, defer non-urgent queue items to the next cycle rather than risk a mid-task stall.

package/docs/guides/claudraband-sessions.md

@@ -0,0 +1,98 @@
+# Claudraband Persistent Sessions Guide
+
+Claudraband wraps Claude Code to add persistent sessions, daemon mode with an HTTP API, and programmatic session control. It turns Claude Code from an interactive TUI into a controllable backend service.
+
+## Why It Matters
+
+Maestro agents spawn background sessions via `scripts/spawn-session.sh` for complex tasks. The current spawner uses `claude -p` with a timeout — fire-and-forget, no resumption, no mid-flight control. Claudraband adds:
+
+- **Persistent sessions**: Run headless, disconnect, reconnect later
+- **Daemon mode**: HTTP API for spawning and managing sessions programmatically
+- **Prompt injection**: Send follow-up prompts to running sessions without restarting
+- **Session lifecycle management**: List, pause, resume, and terminate sessions
+
+This is particularly valuable for the backlog executor pattern, where long-running tasks may need mid-flight adjustments.
+
+## Technical Details
+
+- TypeScript wrapper around Claude Code
+- HTTP API in daemon mode (default port 7842)
+- ACP server for editor integration
+- Exposes a TypeScript library for custom tooling
+- npx-based — zero permanent installation
+
+## Installation
+
+### Via init-agent (recommended)
+
+If you ran `scripts/setup/init-agent.sh`, claudraband is pre-installed globally. Verify:
+
+```bash
+npx @halfwhey/claudraband --version
+```
+
+### Manual
+
+```bash
+# One-shot usage
+npx @halfwhey/claudraband "your prompt here"
+
+# Start daemon
+npx @halfwhey/claudraband serve --port 7842
+```
+
+## Usage Patterns
+
+### Daemon mode (recommended for Maestro)
+
+```bash
+# Start the daemon
+npx @halfwhey/claudraband serve --port 7842
+
+# Create a session
+curl -X POST http://localhost:7842/sessions \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Research competitor X and write a brief"}'
+
+# List active sessions
+curl http://localhost:7842/sessions
+
+# Inject a follow-up prompt
+npx @halfwhey/claudraband prompt --session <id> "also check their latest SEC filing"
+
+# Terminate a session
+curl -X DELETE http://localhost:7842/sessions/<id>
+```
+
+### Direct usage (quick tasks)
+
+```bash
+npx @halfwhey/claudraband "Draft an email to the board about Q1 results"
+```
+
+### Integration with spawn-session.sh
+
+`scripts/spawn-session.sh` supports an optional `MAESTRO_SESSION_BACKEND` environment variable:
+
+- `MAESTRO_SESSION_BACKEND=claude` (default) — uses `claude -p` directly
+- `MAESTRO_SESSION_BACKEND=claudraband` — uses claudraband for persistent, resumable sessions
+
+When using the claudraband backend, sessions are registered with the daemon and can be listed, inspected, and controlled via the HTTP API.
+
+## Repository
+
+- GitHub: https://github.com/halfwhey/claudraband
+- License: MIT
+
+## Integration with Maestro
+
+Claudraband is installed as an optional session backend. The default behaviour (`claude -p`) is unchanged. To enable claudraband:
+
+1. Set `MAESTRO_SESSION_BACKEND=claudraband` in your `.env`
+2. Ensure the claudraband daemon is running (started automatically by launchd if configured via init-agent)
+3. Sessions spawned by the backlog executor will use claudraband automatically
+
+Benefits for the backlog executor:
+- **Resumable tasks**: If a session times out, it can be resumed rather than restarted
+- **Mid-flight control**: The orchestrator can inject follow-up prompts into running sessions
+- **Session inventory**: HTTP API provides visibility into all active sessions

package/docs/guides/clawteam-swarm.md

@@ -0,0 +1,116 @@
+# ClawTeam Swarm Orchestration Guide
+
+ClawTeam is a CLI-native swarm orchestrator that uses git worktrees, tmux, and filesystem-based messaging to run multiple coding agents in parallel. It implements a leader/worker pattern where a leader agent manages task creation, dependency chains, spawning, monitoring, and merge.
+
+## Why It Matters
+
+When a coding task involves 2+ independent workstreams (e.g., frontend + backend, or multiple microservices), running agents sequentially is slow and wasteful. ClawTeam gives each agent its own git worktree — isolated branch, files, staging area, and process space — eliminating conflicts, corruption, and dependency collisions.
+
+## Key Capabilities
+
+- **Leader/worker pattern**: Leader agent manages task graph; workers execute independently
+- **Git worktree isolation**: Each worker gets its own worktree branch
+- **Filesystem messaging**: Point-to-point and broadcast messaging between agents
+- **Task dependencies**: Auto-unblocking when upstream tasks complete
+- **Kanban board**: Terminal and web dashboard for monitoring
+- **Multi-agent support**: Claude Code, Codex, Hermes, nanobot, OpenClaw
+
+## Technical Details
+
+- CLI-native and fully automatable (no GUI required)
+- tmux-based worker management
+- MIT licensed
+- Known gaps: task status sync can lag (needs leader-side verification), requires explicit model pinning
+
+## Installation
+
+### Via init-agent
+
+If you ran `scripts/setup/init-agent.sh` with `MAESTRO_ENABLE_SWARM=1`, ClawTeam was cloned and configured. Verify:
+
+```bash
+# Check ClawTeam is available
+which clawteam || ls ~/ClawTeam-OpenClaw/clawteam
+```
+
+### Manual
+
+```bash
+# Clone the repository
+git clone https://github.com/win4r/ClawTeam-OpenClaw.git ~/ClawTeam-OpenClaw
+
+# Ensure tmux is installed
+brew install tmux  # macOS
+```
+
+## Usage
+
+### Basic swarm launch
+
+```bash
+cd ~/your-repo
+clawteam start --leader claude --workers 3 --task "Implement user authentication"
+```
+
+### With task dependencies
+
+```bash
+clawteam start \
+  --leader claude \
+  --task-file tasks.yaml \
+  --workers 4 \
+  --model claude-opus-4-6
+```
+
+### Monitoring
+
+```bash
+# Terminal kanban
+clawteam board
+
+# Web dashboard
+clawteam dashboard --port 8080
+```
+
+### Filesystem messaging
+
+Workers communicate via an inbox system in the worktree root:
+
+```bash
+# Leader sends to worker-2
+echo "Priority change: focus on API endpoints first" > .clawteam/inbox/worker-2/msg-001.txt
+
+# Worker reads inbox
+cat .clawteam/inbox/self/*.txt
+```
+
+## Repository
+
+- GitHub: https://github.com/win4r/ClawTeam-OpenClaw
+- License: MIT
+
+## Integration with Maestro
+
+ClawTeam is an optional module for coding-heavy agents. It is not required for operational agents (Chief of Staff, Legal, Communications) but is valuable for:
+
+- **Engineering coordination agents** running parallel coding tasks
+- **Platform architecture agents** implementing across multiple packages
+- **Any agent** where a backlog item involves 2+ independent code changes
+
+### Routing rules
+
+The backlog executor can route items to ClawTeam when:
+1. The task involves code changes to 2+ independent files/packages
+2. The task is explicitly tagged as `swarm-eligible` in the queue
+3. The agent's config has `MAESTRO_ENABLE_SWARM=1`
+
+### Post-merge workflow
+
+After ClawTeam workers complete, the leader agent:
+1. Reviews all worker diffs
+2. Runs tests on each worktree branch
+3. Merges clean branches to the integration branch
+4. Produces a structured summary of changes
+5. Cleans up worktrees
+
+This maps naturally to Maestro's session output pattern (`outputs/sessions/{id}/output.md`).

package/docs/guides/code-review-graph-setup.md

@@ -0,0 +1,86 @@
+# Code-Review-Graph — Structural Knowledge Graph for Codebases
+
+Tree-sitter-based knowledge graph mapping functions, classes, imports, and call relationships. Provides MCP tools for blast-radius analysis, review context, architecture overview, and refactor planning.
+
+## Why It Matters
+
+When agents review PRs, plan refactors, or assess engineering health, they need structural understanding of the codebase — not just text search. Code-review-graph builds a persistent knowledge graph that auto-updates on file changes, providing:
+
+- **Blast-radius analysis** — What breaks if this function changes?
+- **Review context** — What other code depends on this change?
+- **Architecture overview** — How do modules connect?
+- **Semantic search** — Find related functions by call graph, not just name
+- **Refactor planning** — Map dependencies before restructuring
+
+## Installation
+
+### Via install-dev-tools (recommended)
+
+```bash
+./scripts/setup/install-dev-tools.sh --tool code-review-graph
+```
+
+### Manual
+
+```bash
+# Global install
+npm install -g code-review-graph
+
+# Or via npx (zero-install)
+npx code-review-graph
+```
+
+## MCP Server Configuration
+
+Add to your Claude Code MCP settings (`.claude/settings.json` or project-level):
+
+```json
+{
+  "mcpServers": {
+    "code-review-graph": {
+      "command": "npx",
+      "args": ["code-review-graph", "serve", "--port", "3848"],
+      "env": {
+        "CRG_REPO_PATH": "/path/to/your/repo"
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+### Build the graph for a repo
+
+```bash
+npx code-review-graph index /path/to/repo
+```
+
+### Query via MCP tools (from Claude Code)
+
+Once configured as an MCP server, Claude Code gains these tools:
+- `blast_radius(file, function)` — Trace all callers and dependents
+- `review_context(diff)` — Generate review context from a diff
+- `architecture_overview()` — High-level module map
+- `semantic_search(query)` — Find related code by structural relationships
+
+### Standalone CLI
+
+```bash
+npx code-review-graph blast-radius --file src/lib/executor.js --function executeAction
+npx code-review-graph overview --repo ~/maestro
+```
+
+## Integration with Maestro
+
+Recommended for coding-oriented agents and workflows:
+- **Engineering health checks** — Use architecture overview to assess repo structure
+- **PR review agents** — Enrich review context with dependency information
+- **Refactoring tasks** — Plan changes with blast-radius awareness
+
+Optional for non-coding agents (operational, hiring, comms). Enable per-repo as needed.
+
+## Repository
+
+- License: Open source
+- Requires: Tree-sitter (bundled)