# BooCode Lift Analysis — What Can We Lift Into BooCode?

Date: 2026-06-07
Scope: 30+ repos scanned across 2 passes.
  Pass 1 (14 repos): opencode, agentic, hcom, oh-my-openagent, oh-my-pi, OpenAgentsControl,
    Codex-CLI-Compact, conductor, measuring-ai-proficiency, boocontext, opencode-pty,
    pskoett-skills, paseo, additional-forks (openspec, codesight, tree-sitter-analyzer, etc.)
  Pass 2 (16 repos): bun, claudish, cline, goose, han, happy, openchamber, llama.cpp, unsloth,
    SkillOpt, subtask2, superset, pi-acp, qwen-code, opencode-background-agents,
    opencode-sentry-monitor, opencode-skillful, opencode-wakatime, opencode-worktree,
    opencode-zellij-namer

---

## BooCode Architecture (for context mapping)

```
apps/server     — Fastify API + inference loop + file-read tools + MCP client + codecontext client
apps/web        — React 18 + Vite + Tailwind v4 + shadcn/ui
apps/booterm    — Fastify + node-pty + tmux (browser terminal panes)
apps/coder      — BooCoder: write tools + ACP/PTY dispatcher + provider snapshot + Arena + MCP server
packages/contracts — Cross-app wire contracts (WsFrame, provider-snapshot, message-metadata)
codecontext/    — Go sidecar (codegraph MCP server, v3.2.1)
conductor/      — 22 read-only Han flows via local Qwen
data/AGENTS.md  — 8 agent personas (Code Reviewer, Debugger, Refactorer, etc.)
data/skills/    — Skills system (SKILL.md + optional eval.yaml)
orchestrator    — Multi-agent conductor (Paseo-style run pane, evidence-disciplined reports)
```

---

## LIFT MATRIX — Capability Domain × Source Repo × BooCode Target

### Domain 1: Multi-Provider Model Routing & LLM Abstraction

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Route/protocol abstraction layer (4-axis: route=protocol+endpoint+auth+framing) | **opencode** `packages/llm/` → `Route.make({provider, protocol, endpoint, auth, framing})` | apps/server inference loop → replace hardcoded provider dispatch | Large | High |
| 40+ provider plugins with model discovery + fallback chains | **oh-my-pi** `packages/ai/` | apps/coder provider-registry.ts (currently 5 providers) | Med | High |
| Provider priority chains, capability detection, availability checking, model normalization | **oh-my-openagent** `packages/model-core/` → pure TS, no harness deps | apps/coder provider-registry.ts → abstract model resolution | Small | High |
| Config-backed provider lifecycle with overrides | **opencode** `packages/core/src/plugin/provider/` | apps/coder provider-registry.ts + data/coder-providers.json | Med | Med |

### Domain 2: Codebase Context & Code Intelligence

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Replace Go codecontext sidecar with TS boocontext (7 tools, session cache, wiki) | **boocontext** (this fork `boocontext/`) | codecontext/ sidecar → replace HTTP shim with MCP client | Med | Critical |
| Call graph analysis (callers/callees with depth) | **tree-sitter-analyzer** via boocontext | apps/server codecontext_client.ts → new tool | Med | High |
| Health grades (A-F per file, 7 dimensions) | **tree-sitter-analyzer** via boocontext | apps/server → new tool for Refactorer/Architect agents | Med | High |
| BM25-ranked symbol search | **tree-sitter-analyzer** via boocontext | codecontext_client.ts → replace search_symbols | Med | High |
| Impact analysis (symbol trace + file blast radius merged) | **boocontext** `src/tools/impact.ts` | apps/server → new tool for change planning | Med | High |
| Wiki mode (targeted articles: auth.md, database.md, etc.) | **codesight** `--wiki` mode | apps/server → generate persistent codebase wiki | Med | Med |
| Semantic codebase graph (info_graph + chat_action_graph) | **Codex-CLI-Compact** `bin/dual_graph_launch.sh` (proprietary core) | apps/server → build own dual-graph system | Large | High |
| Token-efficient scanning (7-12x reduction vs manual exploration) | **codesight** | codecontext/ → adopt codesight's scanner | Small | High |

### Domain 3: Multi-Agent Orchestration

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Declarative workflow definitions (JSON DAGs) | **conductor** `schemas/WorkflowDef.json` | conductor/ orchestrator → flow format | Med | High |
| Task state machine (SCHEDULED → IN_PROGRESS → COMPLETED/FAILED/TIMED_OUT with retriable flag) | **conductor** `TaskModel.java` | conductor/ flows → step state model | Small | High |
| DO_WHILE loop for agent iteration | **conductor** `DoWhile.java` | conductor/ → loop support | Med | High |
| FORK_JOIN parallel execution with Join synchronization | **conductor** `Fork.java` + `Join.java` | conductor/ → parallel step execution | Med | High |
| SWITCH task for conditional branching | **conductor** `Switch.java` | conductor/ → conditional flow routes | Small | Med |
| Parallel execution with batch batching (independent tasks run concurrently) | **OpenAgentsControl** `.opencode/agent/subagents/core/task-manager.md` | conductor/ → parallel batch execution | Small | High |
| Subagent tool restriction schema (YAML frontmatter: read/grep/glob/bash bools) | **agentic** `agent/*.md` frontmatter | data/AGENTS.md + conductor/agents → tool permissions per agent | Small | High |
| Structured phased workflow lifecycle (ticket → research → plan → execute → commit → review) | **agentic** `command/ticket.md`, `command/research.md`, etc. | conductor/ or new workflow | Med | Med |
| Multi-agent orchestration hub daemon | **paseo** (this fork `paseo/`) | apps/coder → multi-agent lifecycle management | Large | Med |

### Domain 4: Inter-Agent Communication & Coordination

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Inter-agent messaging via shared DB + delivery | **hcom** `src/delivery.rs` + `src/db.rs` | apps/server → message queue between Orchestrator + BooCoder | Large | High |
| Per-tool hook normalization (10 tools: Claude, Codex, Gemini, etc.) | **hcom** `src/hooks/` | apps/coder → normalized hook payload format | Med | Med |
| Event subscription system (agents subscribe to status/file-edit events) | **hcom** `src/commands/` (`hcom events --wait --sql`) | apps/server → reactive event triggers | Med | High |
| Collision detection (two agents editing same file within 30s) | **hcom** `src/` (codex_file_edits.rs) | apps/coder → concurrent edit warnings | Small | Med |
| Multi-agent topologies (worker-reviewer, ensemble, cascade pipeline) | **hcom** `docs/` 6 documented patterns | conductor/ → expand beyond read-only Qwen flows | Large | High |
| Cross-device relay (MQTT with E2E encryption) | **hcom** `src/relay/` | net-new network layer | Large | Low |

### Domain 5: PTY / Terminal

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Exit notifications (`<pty_exited>` with exit code, last line) | **opencode-pty** (this fork) | apps/booterm → notify AI on process completion | Small | High |
| Pattern-based log search with offset/limit pagination | **opencode-pty** `pty_read` with regex pattern | apps/booterm → grep within PTY buffer | Small | High |
| Per-session timeouts | **opencode-pty** `timeoutSeconds` parameter | apps/booterm → runaway process protection | Small | Med |
| Rich session metadata (title, description, parent agent) | **opencode-pty** PTYSession metadata | apps/booterm → AI context about background tasks | Small | Med |
| In-process native PTY (Rust bun-pty vs node-pty+tmux) | **oh-my-pi** `crates/pi-shell/` (embedded bash) | apps/booterm → alternative PTY backend | Large | Med |

### Domain 6: Code Editing & Execution

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Hashline editing (content hash anchors, hash mismatch = reject) | **oh-my-openagent** `packages/hashline-core/` | apps/coder edit_file → line anchors with content hashes | Small | High |
| AST-based structural editing (ast_edit with preview) | **oh-my-pi** `packages/coding-agent/` tools | apps/coder → structural rewrite tool | Med | High |
| ast-grep pattern matching across 50+ language grammars | **oh-my-pi** `crates/pi-ast/` | apps/coder → ast_grep_search/replace tools | Med | High |
| Built-in eval kernels (persistent Python + JS cells) | **oh-my-pi** `packages/coding-agent/` eval tool | apps/coder → code execution sandbox | Large | Med |
| Fuzzy edit matching (exact → whitespace → unicode → Levenshtein ladder) | Already in BooCode (`apps/coder/src/fuzzy-match.ts`) | — (already shipped) | — | — |

### Domain 7: AI Proficiency & Metrics

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| MCP server with 13 proficiency scanning tools | **measuring-ai-proficiency** `measure-ai-proficiency-mcp` CLI | apps/server MCP client → register as MCP server | Small | Med |
| Maturity level (1-8) scoring + recommendations | **measuring-ai-proficiency** `scanner.py` | apps/server → agent "skill level" awareness | Small | Med |
| 2026 context-engineering signals (verification, hooks, primitive discipline, eval loops) | **measuring-ai-proficiency** `signals.py` | apps/server → track AI readiness | Small | Med |
| Validation warnings (STALE, TEMPLATE, BLOAT, MISSING REF) | **measuring-ai-proficiency** `scanner.py` validation | apps/server → alert on broken context files | Small | Low |
| Cross-session context store (decisions, tasks, blockers persist between sessions) | **Codex-CLI-Compact** `context-store.json` pattern | apps/server → project memory | Med | High |
| Token tracking dashboard (per-model, per-project costs) | **Codex-CLI-Compact** `dashboard/server.py` | apps/web → token usage UI | Med | Med |

### Domain 8: Context Engineering & Skills

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Two-loop continuous improvement (inner: detect→verify→recover, outer: inspect→encode→regress-test) | **pskoett-skills** — 19 skills | data/skills/ → architecture pattern | Med | High |
| Self-healing with mandatory verify-before-persist | **pskoett-skills** `skills/self-healing/` | data/skills/ → add healing skill | Small | High |
| Verify-gate (compile → test → lint, fix loop on failure) | **pskoett-skills** `skills/verify-gate/` | apps/server/conductor → add verify step | Small | High |
| Pre-flight check (session-start learning visibility) | **pskoett-skills** `skills/pre-flight-check/` | apps/server → session initiation context | Small | Med |
| Context system with project-specific patterns (markdown files agents load proactively) | **OpenAgentsControl** `.opencode/context/` | data/skills/ or new context/ dir | Small | High |
| ContextScout (discover relevant context files) + ExternalScout (live docs via Context7) | **OpenAgentsControl** `.opencode/agent/subagents/core/` | apps/server → dual discovery | Med | High |
| Plugin hook system (chat params, tool execution, auth, provider, shell env) | **opencode** `packages/plugin/` | apps/server → extensible hook architecture | Large | Med |
| Skills with embedded MCPs (per-session lifecycle, spun up on demand) | **oh-my-openagent** `src/features/skill-mcp-manager/` | data/skills/ → MCP-per-skill | Med | High |
| Skill pipeline (task classifier: Trivial/Small/Medium/Large/Long-running/Batch) | **pskoett-skills** `skills/skill-pipeline/` | conductor → depth-calibrated routing | Med | Med |

### Domain 9: Memory & Session Continuity

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| System Context / Context Epoch model (typed context sources, immutable baselines, snapshots) | **opencode** `packages/core/src/system-context/` | apps/server inference → context lifecycle | Large | High |
| Persistent cross-session memory (Supermemory: project habits, conventions) | **opencode-supermemory** (this fork) | apps/server → long-term agent memory | Med | Med |
| Hindsight memory (agent-curated between sessions) | **oh-my-pi** `packages/agent/` recall/retain tools | apps/server → memory persistence | Med | Med |
| Boulder state (work tracking across sessions with automatic resumption) | **oh-my-openagent** `packages/boulder-state/` | conductor → plan execution persistence | Small | Med |
| Context compression (range/message dedup, purge errors, turn protection) | **opencode-dynamic-context-pruning** (this fork) | apps/server inference → compaction | Med | High |
| Morph Fast Apply (10,500+ tok/s with lazy markers) | **opencode-morph-plugin**, **opencode-morph-fast-apply** | apps/coder edit_file → fast apply backend | Med | Med |

### Domain 10: Development Workflow

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| Spec-first development (spec.md → tasks → implementation) | **openspec** (this fork `openspec/`) | Already partially in BooCode (`openspec/` directory) | — | — |
| Context-driven dev lifecycle (Context → Spec → Plan → Implement → Revert tracks) | **opencode-conductor** (this fork) | conductor → structured dev tracks | Med | Med |
| Undo Shield (PreToolUse hook blocking destructive ops on high-attention files) | **Codex-CLI-Compact** `bin/undo_shield.py` | apps/coder → edit safety guard | Small | Med |
| Vibe Code Auditor (7 health checks: dead exports, coverage, circular deps, etc.) | **Codex-CLI-Compact** `audit.py` | apps/server → technical debt awareness | Med | Med |

---

## RANKED INTEGRATION RECOMMENDATIONS

Ordered by **value/cost ratio** for BooCode.

### Tier 1: High Value, Low Effort (Do First)

| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 1 | **Replace Go codecontext with boocontext** | `boocontext/` | codecontext/ sidecar | Direct drop-in. 7 tools instead of 5. Session caching. Call graph, health grades, impact analysis. Written in TS (BooCode's stack). Fixes 0% TypeScript recovery. |
| 2 | **PTY exit notifications** | `opencode-pty/` | apps/booterm | `<pty_exited>` structured messages on process completion. Low-effort, enables AI to react to long-running tasks. |
| 3 | **Self-healing skill** | `pskoett-skills/` | data/skills/ | Verify-before-persist discipline. HEAL entries to `.learnings/`. Pattern-Key dedup. Brings the two-loop inner loop to BooCode. |
| 4 | **Verify-gate skill** | `pskoett-skills/` | conductor/ | Compile → test → lint gate with auto-discovery. Fix loop on failure. Universal value for a dev chat app. |
| 5 | **Subagent tool restriction schema** | `agentic/` | data/AGENTS.md + conductor/agents | YAML frontmatter defining tool permissions per agent. Currently all BooCode agents have same tool set. |
| 6 | **Hashline editing** | `oh-my-openagent/` | apps/coder | Content hash anchors for edit targets. Rejects stale patches. Pure TS, no harness deps. Proven 10× success rate improvement. |
| 7 | **Model resolution core** | `oh-my-openagent/` `packages/model-core/` | apps/coder | Provider priority chains, fallback chains, model normalization. Pure TS, no deps. |
| 8 | **Fuzzy edit matching** | Already in BooCode | apps/coder | Already shipped in v2.7.1. Listed for completeness. |

### Tier 2: High Value, Medium Effort (Next)

| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 9 | **Context system (project patterns)** | `OpenAgentsControl/` | data/ or new context/ | Learn project patterns proactively instead of relying on agent discovery. MVI principle (<200 line files, 80% token reduction). |
| 10 | **ContextScout + ExternalScout** | `OpenAgentsControl/` | apps/server | Discover relevant context files + fetch live library docs via Context7. |
| 11 | **Task state machine + FORK_JOIN** | `conductor/` | conductor/ | SCHEDULED → IN_PROGRESS → COMPLETED/FAILED state model. Parallel step execution with Join sync. |
| 12 | **Session metadata for PTY panes** | `opencode-pty/` | apps/booterm | Track title, description, parent agent per terminal pane. Enables AI context awareness. |
| 13 | **Context compression (DCP)** | `opencode-dynamic-context-pruning/` | apps/server inference | Range/message dedup, purge errors. More surgical than current compaction. |
| 14 | **Boulder state (work tracking)** | `oh-my-openagent/` `packages/boulder-state/` | conductor/ | Cross-session plan execution with automatic resumption. Framework-agnostic. |
| 15 | **AST-based editing (ast_grep + ast_edit)** | `oh-my-pi/` `crates/pi-ast/` | apps/coder | Structural code editing with AST patterns. 50+ language grammars. |
| 16 | **Event subscription system** | `hcom/` `src/commands/` | apps/server | Reactive event triggers ("when file X changes, re-run flow Y"). |

### Tier 3: High Value, Large Effort (Architecture Projects)

| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 17 | **Declarative workflow DAGs** | `conductor/` | conductor/ | Replace procedural flow definitions with JSON DAGs. LLM-friendly. Versioned. |
| 18 | **Inter-agent messaging** | `hcom/` | apps/server + apps/coder | DB-backed message queue for Orchestrator → BooCoder messaging. |
| 19 | **System Context model** | `opencode/` | apps/server | Typed context sources, immutable epoch baselines, reconciliation. Foundation for long-session quality. |
| 20 | **Multi-provider routing abstraction** | `opencode/` `packages/llm/` | apps/server | 4-axis route composition. Decouples provider selection from inference loop. |
| 21 | **Plugin hook system** | `opencode/` `packages/plugin/` | apps/server | Extensible lifecycle hooks (chat params, tool execution, auth, provider). |
| 22 | **Multi-agent topologies** | `hcom/` | conductor/ | Expand beyond read-only Qwen flows to general multi-agent patterns. |
| 23 | **Skills with embedded MCPs** | `oh-my-openagent/` | data/skills/ | Per-skill MCP servers, spun up on demand, scoped per session. |

---

## BOOCODE'S CURRENT STATE — What's Already Strong

Before lifting, acknowledge what BooCode already does well that the forks don't:

| BooCode Strength | Not matched by |
|-----------------|----------------|
| Postgres-backed session storage (queryable, indexed) | hcom (SQLite), opencode (JSONL) |
| Multi-pane workspace (chat/coder/terminal/orchestrator) | All forks — single-pane or terminal-only |
| Provider snapshot system (probe status, UI toggle, cold refresh) | opencode (no status UI), oh-my-pi (no toggle) |
| Pending-changes queue + diff panel (approval gating) | None of the forks have this UX |
| Arena (same task → N models → analysis) | Unique to BooCode |
| Fuzzy edit matching (Levenshtein ladder) | opencode (exact only), oh-my-openagent (hashline only) |
| Persistent agent sessions (warm ACP resumable) | hcom (per-session only), opencode (cold per turn) |
| Codecontext sidecar (Go, containerized) | boocontext (TS, but no container) |

---

## DEPENDENCY GRAPH — What Depends On What

```
Replace codecontext with boocontext (Tier 1)
  ├── Enables: Call graph → Impact analysis → Health grades
  ├── Enables: Wiki generation → Cross-session codebase knowledge
  └── Needs: tree-sitter-analyzer as child MCP server

PTY exit notifications (Tier 1)
  └── Enables: AI reaction to long-running task completion

Self-healing + Verify-gate (Tier 1)
  ├── Prerequisite: .learnings/ directory convention
  └── Enables: Full two-loop CI (with learning-aggregator → eval-creator)

Context system + ContextScout (Tier 2)
  ├── Prerequisite: MVI context file format
  └── Enables: ExternalScout → live doc fetching

Conductor flow enhancements (Tier 2)
  ├── Task state machine → Prerequisite for: DO_WHILE, FORK_JOIN, SWITCH
  └── Enables: Declarative DAGs (Tier 3)

System Context model (Tier 3)
  └── Prerequisite for: Plugin hook system → MCP-per-skill
```

---

## IMMEDIATE NEXT ACTIONS (If we start today)

### Week 1: Quick wins
1. **Swap codecontext** — Replace Go sidecar HTTP client with boocontext MCP client. Adds 2 new tools (health, callgraph) with zero architectural change.
2. **Add PTY exit notifications** — Extend booterm's WS protocol to send structured exit payloads.
3. **Add self-healing + verify-gate skills** — Copy skill directories from pskoett-skills, adapt prompts to BooCode's agent format.

### Week 2: Context system
4. **Add ContextScout** — New agent that discovers relevant context files (from new `context/` directory).
5. **Add model-core** — Extract provider priority/fallback logic from oh-my-openagent's model-core package.

### Week 2-3: Conductor upgrades
6. **Task state machine** — Add SCHEDULED/IN_PROGRESS/FAILED/COMPLETED states to flow steps.
7. **FORK_JOIN support** — Allow parallel branch execution in conductor flows.

### Week 3-4: Memory & context
8. **Boulder state** — Add cross-session work tracking/auto-resumption.
9. **Context compression** — Integrate DCP patterns into inference loop compaction.

---

## COMPLETE REPO REFERENCE

| Repo | Path | Key Capability | Lift Priority |
|------|------|---------------|---------------|
| boocontext | `/opt/forks/boocontext/` | Code intelligence MCP (7 tools, health, callgraph, impact) | **Tier 1** |
| opencode-pty | `/opt/forks/opencode-pty/` | PTY exit notifications, log search, session metadata | **Tier 1** |
| pskoett-skills | `/opt/forks/pskoett-skills/` | Self-healing, verify-gate, two-loop skills | **Tier 1** |
| agentic | `/opt/forks/agentic/` | Subagent tool permissions, structured workflow lifecycle | **Tier 1** |
| oh-my-openagent | `/opt/forks/oh-my-openagent/` | Hashline editing, model-core, boulder state, skills+MCP | **Tier 1-2** |
| oh-my-pi | `/opt/forks/oh-my-pi/` | 40+ providers, AST editing, eval kernels, hindsight memory | **Tier 2** |
| OpenAgentsControl | `/opt/forks/OpenAgentsControl/` | Context system, ContextScout, ExternalScout, task manager | **Tier 2** |
| conductor | `/opt/forks/conductor/` | Workflow DAGs, task state machine, FORK_JOIN, DO_WHILE | **Tier 2** |
| opencode | `/opt/forks/opencode/` | System Context model, plugin hooks, LLM routing, MCP | **Tier 3** |
| hcom | `/opt/forks/hcom/` | Inter-agent messaging, event system, multi-agent topologies | **Tier 3** |
| opencode-dynamic-context-pruning | `/opt/forks/opencode-dynamic-context-pruning/` | Context compression | Tier 2 |
| opencode-supermemory | `/opt/forks/opencode-supermemory/` | Persistent memory | Tier 2 |
| Codex-CLI-Compact | `/opt/forks/Codex-CLI-Compact/` | Context store, undo shield, token dashboard, vibe audit | Tier 2 |
| measuring-ai-proficiency | `/opt/forks/measuring-ai-proficiency/` | AI proficiency MCP, maturity scoring | Tier 2 |
| opencode-morph-plugin | `/opt/forks/opencode-morph-plugin/` | Fast code editing, WarpGrep | Tier 2 |
| opencode-conductor | `/opt/forks/opencode-conductor/` | Context-driven dev lifecycle | Tier 3 |
| paseo | `/opt/forks/paseo/` | Multi-agent orchestration hub | Tier 3 |
| opencode-tokenscope | `/opt/forks/opencode-tokenscope/` | Token usage analysis | Low |
| opencode-skillful | `/opt/forks/opencode-skillful/` | Skill system (SKILL.md, lazy load, model-aware formatting) | **Tier 1** |
| llama.cpp | `/opt/forks/llama.cpp/` | LLM inference engine (BooCode's inference backend) | **Tier 1** |
| claudish | `/opt/forks/claudish/` | Claude Code multi-provider proxy (580+ models) | Tier 2 |
| cline | `/opt/forks/cline/` | Full agent platform (SDK, hub, connectors, cron) | Tier 2 |
| goose | `/opt/forks/goose/` | Block's Rust agent (MCP, 15+ providers, desktop+CLI+API) | Tier 2 |
| han | `/opt/forks/han/` | 18 skills + 23 agents (evidence-based planning, review, TDD) | Tier 2 |
| openchamber | `/opt/forks/openchamber/` | OpenCode UI runtime (Electron, web, branching timeline) | Tier 2 |
| qwen-code | `/opt/forks/qwen-code/` | Full coding agent (daemon mode, skills, hooks, subagents, cron) | Tier 2 |
| subtask2 | `/opt/forks/subtask2/` | Enhanced subtask control (return, loop, parallel, $RESULT) | Tier 2 |
| opencode-background-agents | `/opt/forks/opencode-background-agents/` | Async background delegation with persistence | Tier 2 |
| pi-acp | `/opt/forks/pi-acp/` | ACP adapter for pi (structured diffs, terminal auth) | Tier 2 |
| opencode-worktree | `/opt/forks/opencode-worktree/` | Git worktree + 15-terminal spawning + lifecycle hooks | Tier 2 |
| bun | `/opt/forks/bun/` | JS/TS runtime, bundler, test runner, bun:sqlite, Bun.serve | Tier 3 |
| happy | `/opt/forks/happy/` | Mobile remote control (E2EE, QR auth, voice) | Tier 3 |
| superset | `/opt/forks/superset/` | "Code Editor for AI Agents" - Electron desktop app | Tier 3 |
| unsloth | `/opt/forks/unsloth/` | Efficient LLM fine-tuning (2-5x faster, 70% less VRAM) | Tier 3 |
| SkillOpt | `/opt/forks/SkillOpt/` | Skill document optimization training loop | Tier 3 |
| opencode-sentry-monitor | `/opt/forks/opencode-sentry-monitor/` | Sentry observability (token usage, spans, metrics) | Tier 3 |
| opencode-wakatime | `/opt/forks/opencode-wakatime/` | WakaTime coding activity tracking | Tier 3 |
| opencode-zellij-namer | `/opt/forks/opencode-zellij-namer/` | AI-powered terminal session naming | Tier 3 |

---

## DEEP DIVE FINDINGS — 5 Audit Agents (2026-06-07)

This section captures the results of deep-dive audits across 5 focus areas: llama.cpp server features, boocontext architecture, conductor/agents/workflows, hooks/skills/prompt library, and inference configuration.

---

### 1. llama.cpp Server: 14 Feature Categories Not Used

BooCode uses llama-server via llama-swap (default) or llama-sidecar (per-agent flags). The sidecar base args are:
`-ngl 999 -c 32768 --flash-attn on --no-mmap`. Here's what's available but not enabled:

**High Impact (config only, no code changes):**

| Feature | Flag | Impact | Activation |
|---------|------|--------|------------|
| KV cache quantization | `--cache-type-k q4_0` | ~4× VRAM savings for KV cache | Sidecar `baseArgs` or unshadow in validator |
| Ngram speculative decoding | `--spec-type ngram-mod` | 2-3× tokens/sec, ~16MB memory, no draft model | Sidecar `baseArgs` or unshadow in validator |
| Context checkpointing | `--ctx-checkpoints 32` | Prevents overflow on long conversations | Via `llama_extra_args` in AGENTS.md |
| Context shift | `--context-shift` | Infinite text generation | Via `llama_extra_args` |
| Slot save/restore | `POST /slots/{id}?action=save\|restore` | Persist KV cache across restarts | New API call in compaction.ts |
| Prometheus metrics | `--metrics` | `/metrics` for token rates, latency, decode stats | Add to sidecar base args |
| Sleep mode | `--sleep-idle-seconds 600` | Auto-shutdown when idle, saves GPU memory | Add to sidecar base args |

**Key Finding — Shadowing Architecture** (both `llama-args-validator.ts` and sidecar `validator.go`):
- `denyFlags`: model, listen, credentials, webui (hard blocked)
- `shadowFlags`: context size, cache types, spec flags, template flags (auto-stripped from agent args)
- `acceptFlags`: everything else passes through

To enable cache/spec features: remove from `shadowFlags` in BOTH files, or override via `BASE_ARGS` env var on the sidecar.

**Medium Impact (via `llama_extra_args`):**
- LoRA adapters (`--lora <path>`)
- Custom chat templates (`--chat-template-file`)
- Reasoning budget (`--reasoning-budget`)
- Multi-GPU tensor split (`--tensor-split`)
- NUMA awareness (`--numa`)

**Full API surface available at the inference endpoint:**
`/v1/chat/completions` (main), `/v1/completions`, `/v1/embeddings`, `/v1/rerank`, `/v1/messages` (Anthropic-compatible), `/infill`, `/tokenize`, `/detokenize`, `/v1/audio/transcriptions`

---

### 2. Boocontext Architecture: 20 Tools in 2 Layers

**Integration target** (`codecontext_client.ts` does not yet exist — must be created).

**Option A (Recommended): MCP subprocess — zero code change:**
```json
{ "mcpServers": { "boocontext": { "command": "npx", "args": ["boocontext-mcp"] } } }
```

**Architecture:**
- **13 codesight tools**: scan, get_summary, get_routes, get_schema, get_blast_radius, get_env, get_hot_files, refresh, get_wiki_index, get_wiki_article, lint_wiki, get_events, get_coverage, get_knowledge
- **7 boocontext tools**: overview, map, health (A-F grades), symbols (BM25 search), callgraph (callers/callees), impact (trace + blast radius merged), types (TS type recovery)
- **VerdictEnvelope**: SAFE/CAUTION/UNSAFE/INFO wrapper → `{ verdict, summary, details, metadata }`
- **Child MCP servers**: tree-sitter-analyzer (via `uvx`) + type-inject (via `npx`)
- **Session cache**: in-memory, per-directory, `clearCache()` on project switch

**Fixes needed before production integration:**
1. Hardcoded type-inject path (`/opt/forks/type-inject/...`) → switch to `npx @nick-vi/type-inject-mcp`
2. Missing `uvx` requirement for tree-sitter-analyzer → document or bundle
3. No request concurrency (serial `processing` flag) → enable parallel for independent tools
4. No graceful degradation on child server failure → retry + fallback to codesight-only
5. No tool result caching per-call → add memoization for expensive operations (health, callgraph)

---

### 3. Conductor/Workflows/Agents: Static Wave Scheduler

**BooCode has TWO layers:**
- `conductor/` — standalone CLI, deterministic wave scheduler, 22 flows, 23 agents
- `apps/coder/` — in-app orchestrator, DB-persisted flow runs, dispatcher with 4 execution paths
- `data/AGENTS.md` — 9 personas (Code Reviewer, Debugger, Refactorer, etc.)
- `conductor/agents/` — 23 Han personas with frontmatter + tool permissions

**Execution model** (`flow.ts`):
```
while (done.size + skipped.size < total):
  ready = steps whose deps all satisfied
  await Promise.all(ready.map(s => s.run()))
```

**Gaps to Claude Code's Dynamic Workflows/Sub-agents/Teams:**

| Capability | Current | Target | Structural Change Needed |
|------------|---------|--------|------------------------|
| Step graph | Static `Step[]` array | Mutable `FlowGraph` with add/remove/loop | `flow.ts` — Step[] → FlowGraph with WhileStep/UntilStep |
| Result streaming | `Promise<string>` | `AsyncIterable<StepEvent>` with partial results | Step.run() signature change |
| Agent spawning | Conductor calls dispatchAgent | Steps call `ctx.spawn(agent, prompt)` | New spawn protocol |
| Shared state | `Record<string, string>` | Structured SharedState with message-passing channels | ctx.results → SharedState |
| Inter-agent comms | None | Mailbox pattern (send/receive by agent ID) | New message transport |
| Human-in-loop | None | Pause-for-input mid-flow | Flow runner → user prompt gate |
| Workflow composition | None | `flow.invoke(subflow)` | New compose mechanism |

**Dispatcher** (`dispatcher.ts`, 1726 lines): 4 execution paths (Native, PTY, ACP, OpenCode Server). Polls `tasks` table, LISTEN `tasks_new`. Per-session in-flight tracking prevents concurrent turns.

**Worktree isolation**: Per-task (`/tmp/booworktrees/<taskId>`) and session-persistent (`/tmp/booworktrees/sess-<id>`). Diff baseline from `base_commit`.

**Agent pool** (`agent-pool.ts`): Idle-TTL (30min default) + LRU cap (10 default). Busy backends never evicted. Periodic sweep.

---

### 4. Hooks System: 5 Events Defined, 0 Wired

**Location**: `apps/coder/src/plugins/host.ts`

**State**: Shipped dead code. The hook infrastructure exists (handler registry, stdin/stdout protocol, exit codes for allow/deny) but NO `emitHook()` calls exist in `turn.ts`, `tool-phase.ts`, or `stream-phase.ts`.

**The 5 dead events**: `tool.execute.before`, `tool.execute.after`, `turn.start`, `turn.end`, `task.terminal`

**What BooCode DOES have (that's active):**
- `broker.ts` — in-memory pub/sub for WS frames (session + user channels)
- `lifecycle.ts` — chat/session close/archive/delete handlers
- `flow-runner.ts` — `handleTaskTerminal` callback (the one wired hook)

**Claude Code's hook architecture (target — 32+ events):**

| Category | Events |
|----------|--------|
| Session | SessionStart, SessionEnd, Setup |
| Turn | UserPromptSubmit, Stop, StopFailure, PreCompact, PostCompact |
| Tool | PreToolUse, PostToolUse, PostToolUseFailure, PostToolBatch |
| Permission | PermissionRequest, PermissionDenied |
| Agent | SubagentStart, SubagentStop, TeammateIdle |
| File | FileChanged, CwdChanged, WorktreeCreate, WorktreeRemove |
| Config | ConfigChange, InstructionsLoaded |
| MCP | Elicitation, ElicitationResult |
| Notify | Notification, MessageDisplay, TaskCreated, TaskCompleted |

**BooCode inference lifecycle points** (from `turn.ts` `runAssistantTurn`):
1. loadContext — session/project loaded
2. Doom-loop check
3. Budget check
4. Compaction check
5. Message payload build
6. executeStreamPhase — LLM streaming
7. executeToolPhase — tool execution
8. MistakeTracker integration
9. Step cap summary on exit

These are natural hook insertion points.

---

### 5. Prompt Library: None

**Current state**: No central prompt library. Skills contain prompts (41 files in `data/skills/`) but not organized as a user-facing library. `openspec/` has per-batch docs. `data/AGENTS.md` has system prompts.

**Target**: 20-30 prompts organized by SDLC phase (discover, design, build, ship, operate), filterable by role, with fillable slots and "Why this works" explanations. Markdown files with YAML frontmatter in `data/prompts/`.

---

### 6. Inference Configuration: Two Paths, Shadowing Architecture

**Default path**: BooCode → `LLAMA_SWAP_URL` → llama-swap → llama-server
**Per-agent path**: BooCode → `LLAMA_SIDECAR_URL` → llama-sidecar (proxy) → per-model llama-server process

**Sidecar** spawns per-agent llama-server processes via LRU pool (max 2, ports 8500-8599). Configuration env vars:
```
LLAMA_SERVER_BIN, MODEL_DIR_MAP_FILE, LLAMA_SIDECAR_BIND (127.0.0.1:8402),
MAX_SIDECARS (2), PORT_RANGE (8500-8599),
BASE_ARGS (["-ngl","999","-c","32768","--flash-attn","on","--no-mmap"]),
HEALTH_TIMEOUT_SECONDS (60), HEALTH_INTERVAL_SECONDS (30)
```

**AI SDK integration**: `@ai-sdk/openai-compatible` wrapping `createOpenAICompatible({ baseURL: LLAMA_SWAP_URL/v1 })`. Sampler options passed via `providerOptions.openaiCompatible` extraBody (top_k, min_p, top_n_sigma, dry_* family).

**Model context discovery**: `GET /upstream/<model>/props` → `n_ctx` from `default_generation_settings`. Cached forever on success, 60s on failure.

**Task model**: Non-streaming `POST ${TASK_MODEL_URL}/v1/chat/completions` with `FAST_MODEL` model name. Currently hardcoded to `gemma-3-270m-it`.

**Key env vars**: `LLAMA_SWAP_URL`, `LLAMA_SIDECAR_URL`, `TASK_MODEL_URL`, `FAST_MODEL`, `DEFAULT_MODEL`

---
---

## PASS 3 — EXTENSION: Repos Missed in Initial Analysis (2026-06-07, evening)

After the original lift analysis was written, a second pass identified additional repos in `/forks` that were not covered. This section documents the findings from analyzing those repos for patterns liftable into BooCode.

---

### Domain 11: Claude Code Plugin Architecture (Official)

**Source**: `claude-code/plugins/` — 14 official Anthropic plugins

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Plugin packaging structure** (`.claude-plugin/plugin.json` + commands/agents/skills/hooks/.mcp.json — standard layout) | `claude-code/plugins/` — `plugin-dev/` | `data/plugins/` or enhance `data/skills/` | Small | High |
| **Parallel PR review agents** (5 agents: bug-finder, comment-analyzer, test-analyzer, type-designer, code-simplifier — parallel execution) | `claude-code/plugins/pr-review-toolkit/` | `conductor/` — PR review workflow | Med | High |
| **Feature dev workflow agents** (3 agents: code-explorer, code-architect, code-reviewer — 7-phase structured process) | `claude-code/plugins/feature-dev/` | `conductor/` — feature development flows | Med | High |
| **Self-referential agent loop** (Ralph Loop: agent runs same task repeatedly until completion, Stop hook intercepts exit) | `claude-code/plugins/ralph-wiggum/` | `apps/coder` → `/ralph-loop` command | Small | High |
| **Security guidance hook** (PreToolUse scanning 9 security patterns: command injection, XSS, eval, pickle deserialization, os.system, etc.) | `claude-code/plugins/security-guidance/` | `apps/coder` → PreToolUse security scan | Small | High |
| **Hookify rule system** (analyze conversations → auto-create hook rules to prevent unwanted behaviors) | `claude-code/plugins/hookify/` | `apps/coder` → behavior prevention rules | Med | High |
| **Agent SDK verifier plugins** (Python + TS SDK validation agents) | `claude-code/plugins/agent-sdk-dev/` | `apps/coder` → SDK compliance checking | Med | Med |
| **Frontend design skill** (production-grade UI design guidance, auto-invoked) | `claude-code/plugins/frontend-design/` | `data/skills/` → frontend design skill | Small | Med |
| **PR toolkit type design analyzer** (specialized agent for API design review) | `claude-code/plugins/pr-review-toolkit/agents/` | `conductor/agents/` → type review agent | Small | Med |
| **Agent tool permission schemas** (YAML frontmatter in agent `.md` files with `tools:` restrict list) | `claude-code/plugins/feature-dev/agents/*.md` frontmatter | `data/AGENTS.md` → tool restriction per agent | Small | High |

**Key insight**: Claude Code plugin architecture is the most mature reference for how BooCode's skill/plugin system should work. The `plugin.json` → commands/agents/skills/hooks/ `.mcp.json` layout is the de facto standard. The `code-architect.md` agent frontmatter (name, description, tools, model, color) shows exactly how agent metadata should be structured.

---

### Domain 12: Behavioral Compliance Engine (boocontext-audit)

**Source**: `boocontext-audit/` — TypeScript audit + behavioral rules engine (Way more than just "audit extraction")

**What it actually is**: A full **Parlant-inspired behavioral compliance engine** ported to TypeScript, wrapping:
- **Guideline system**: `condition`/`action` natural language rules with criticality (low/medium/high/critical)
- **Multi-batch matcher**: observational, actionable, previously-applied, disambiguation, response analysis, low-criticality batches
- **Relational resolver**: DEPENDS_ON, PRIORITIZES, ENTAILS, TAG_ALL, TAG_PRIORITIZES relationship types with iterative convergence loop
- **Schematic generator**: abstract LLM batch caller for structured output per match type
- **Full audit trail**: PostToolUse/Stop/UserPromptSubmit middleware, JSONL buffer, session lifecycle, graded context recovery (L0-L4)

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Guideline condition/action model** (natural language rules with criticality, priority, labels, tags) | `boocontext-audit/src/guideline.ts` | `apps/coder` → behavioral rules engine | Small | Critical |
| **Multi-batch matcher** (6 batch types: Observational, Actionable, PreviouslyApplied, Disambiguation, ResponseAnalysis, LowCriticality — each with LLM structured output) | `boocontext-audit/src/matching.ts` (371 lines) | `apps/coder` → context-relevant rule matching | Med | High |
| **Relational resolver** (Dependency/Priority/Entailment resolution with iterative convergence, max 100 iterations) | `boocontext-audit/src/resolver.ts` (299 lines) | `apps/coder` → rule conflict resolution | Med | High |
| **Relationship store** (5 relationship kinds: DEPENDS_ON, PRIORITIZES, ENTAILS, TAG_ALL, TAG_PRIORITIZES) | `boocontext-audit/src/relationship.ts` (190 lines) | `apps/coder` → rule relationships | Small | High |
| **Schematic generator** (abstract LLM batch caller with temperature retry, structured output per batch type) | `boocontext-audit/src/generation.ts` (183 lines) | `apps/coder` → structured LLM calls | Med | High |
| **Full audit middleware** (PostToolUse, Stop, UserPromptSubmit hooks with JSONL buffer, session handoff, graded recovery) | `boocontext-audit/src/middleware.ts`, `buffer.ts`, `session.ts` | `apps/coder` → audit trail system | Med | High |
| **User correction tracking** (detect corrections in conversations, persist as priority records, load first on recovery) | `boocontext-audit/src/correction.ts` | `apps/coder` → learn from user corrections | Small | High |
| **Anomaly detection** (configurable alert rules with lambdas, CRITICAL/WARNING levels) | `boocontext-audit/src/anomaly.ts` | `apps/coder` → runtime monitoring | Med | Med |
| **Ambient context via AsyncLocalStorage** | `boocontext-audit/src/ambient-context.ts` | `apps/server` → parameter pollution reduction | Small | High |
| **Graded context recovery** (L0 index → L1 session → L2 corrections → L3 full → L4 cross-day) | `boocontext-audit/src/recovery.ts` | `apps/server` → context restoration | Med | High |

**Key insight**: `boocontext-audit` is the single most undervalued repo in `/forks`. It's a complete behavioral compliance system already ported to TypeScript with zero external dependencies (only `@modelcontextprotocol/sdk`). The Guideline + MultiBatch + RelationalResolver stack is directly usable by BooCode's agent system to enforce agent behavior rules with structured LLM evaluation. The audit middleware is production-ready and can be wired into BooCode's inference lifecycle in days.

---

### Domain 13: TypeScript Type Intelligence (type-inject)

**Source**: `type-inject/` — TypeScript type context for AI coding assistants

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Type extraction pipeline** (ts-morph-based: parse tsconfig, load files, extract types/signatures/JSDoc/import depth) | `type-inject/packages/core/lib/extractor.ts` (1070 lines) | `apps/coder` → type-aware editing | Med | High |
| **Type lookup MCP tools** (`lookup_type` + `list_types` — query types by name regex, source, kind) | `type-inject/packages/mcp/src/` | `apps/server` → MCP type server | Small | High |
| **Auto-type injection** (PostToolUse hook on Read injects type signatures into file reads) | `type-inject/packages/claude-hook/` | `apps/coder` → type context on file reads | Small | High |
| **Type checking on write** (PostToolUse hook on Write runs type checker, reports errors) | `type-inject/packages/claude-hook/` | `apps/coder` → type error feedback | Small | High |
| **Type prioritizer** (rank types by relevance: used types first, direct imports over transitive, exported over private) | `type-inject/packages/core/lib/prioritizer.ts` | `apps/coder` → relevant type ordering | Small | Med |
| **Token-budgeted type injection** (configurable maxTokens, skipBarrelFiles, onlyUsed filtering) | `type-inject/packages/core/lib/config.ts` | `apps/coder` → context budget management | Small | Med |
| **Svelte support** (extract types from `.svelte` files via optional svelte compiler) | `type-inject/packages/core/lib/svelte-utils.ts` | `apps/coder` → Svelte type awareness | Small | Low |
| **OpenCode plugin** (full plugin with auto-injection on reads and MCP tools) | `type-inject/packages/opencode/` | `apps/coder` → direct integration point | Small | High |

**Key insight**: type-inject directly solves the "TypeScript type information is missing from context" problem that the lift analysis identified as codecontext's biggest gap (0% TS recovery). Instead of building it, BooCode can use type-inject as an MCP server or direct plugin. The `@nick-vi/type-inject-mcp` package is published and installable via `npx`. This is a **direct port** — add to BooCode's MCP servers config.

---

### Domain 14: Claude Agent SDK (Official Anthropic)

**Source**: `claude-agent-sdk-typescript/` — Anthropic's official Agent SDK

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Agent lifecycle as SDK** (construct → generate → stream → saveSession — standard agent loop) | `claude-agent-sdk-typescript/` | `apps/server` → standardized agent API | Large | Med |
| **Session store abstraction** (pluggable session persistence backends) | `claude-agent-sdk-typescript/examples/session-stores/` | `apps/server` → session store interface | Small | High |
| **Streaming agent results** (structured stream events for tool calls, text deltas, results) | `claude-agent-sdk-typescript/` | `apps/coder` → streaming agent pattern | Med | Med |
| **Tool use with structured output** (JSON schema enforcement for tool results) | `claude-agent-sdk-typescript/` | `apps/coder` → structured tool results | Small | High |

**Key insight**: The Claude Agent SDK is less valuable for direct code lift (it's a high-level API wrapper) than for its **design patterns** — the session store abstraction and streaming event protocol are clean references for BooCode's existing agent loop.

---

### Domain 15: LLM Inference Sidecar Architecture (llama-sidecar)

**Source**: `llama-sidecar/` — BooCode's own per-agent llama-server process pool (Go)

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Process pool with LRU eviction** (max 2 sidecars, port range 8500-8599, LRU eviction of idle) | `llama-sidecar/internal/pool/` (pool.go, sidecar.go) | (already BooCode's) | — | — |
| **Flag validator** (deny groups: model identity, network, auth/TLS, server UI — blocks security-critical flags) | `llama-sidecar/internal/validator/validator.go` (156 lines) | `apps/coder` → llama-args-validator.ts (already ported) | — | — |
| **Arg hash for sidecar dedup** (hash(modelID, flags) → reuse existing sidecar for same config) | `llama-sidecar/internal/pool/hash.go` | (already BooCode's) | — | — |
| **Windows service support** (NSSM integration for Windows daemon) | `llama-sidecar/internal/winsvc/` | (already BooCode's) | — | — |
| **Health check system** (background health checks every 30s, 60s timeout) | `llama-sidecar/internal/pool/` | (already BooCode's) | — | — |
| **X-Agent-Flags header** (per-request flag overrides via HTTP header) | `llama-sidecar/README.md` → `X-Agent-Flags: --top-k 20` | `apps/server` → per-agent flag routing | Small | High |
| **Slot management (coming soon?)** (save/restore KV cache slots — not implemented yet) | (potential) | `apps/server` → cross-turn KV persistence | Large | High |

**Key insight**: llama-sidecar is already BooCode's own code. The main lift opportunity is the **`X-Agent-Flags` header pattern** — enabling per-agent llama-server parameter overrides (top-k, temperature, cache types) without spawning new sidecar processes. Currently, all agent flags are compiled into the BASE_ARGS. Adding header-based per-request override would enable agent-specific inference tuning.

---

### Domain 16: LangGraph Python Ecosystem (Supervisor + Swarm Patterns)

**Source**: `langchain/langgraph-supervisor-py/` + `langchain/langgraph-swarm-py/` (Python — patterns only)

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Supervisor agent pattern** (central coordinator delegates to specialized agents via handoff tools) | `langgraph-supervisor-py/langgraph_supervisor/supervisor.py` (469 lines) | `conductor/` → supervisor orchestration | Med | High |
| **Swarm agent pattern** (agents dynamically hand off control based on specialization, no central coordinator) | `langgraph-swarm-py/langgraph_swarm/swarm.py` (289 lines) | `conductor/` → swarm orchestration | Med | High |
| **Handoff tool mechanism** (agents transfer control + context via `create_handoff_tool(agent_name, description)`) | `langgraph-supervisor-py/langgraph_supervisor/handoff.py` | `conductor/` → agent-to-agent handoff | Small | High |
| **Agent name normalization + routing** (Literal-based active_agent enum for type-safe routing) | `langgraph-swarm-py/langgraph_swarm/swarm.py` | `conductor/` → typed agent routing | Small | Med |

**Key insight**: The supervisor and swarm patterns from LangGraph are the two canonical multi-agent architectures. LangGraph supervisor = central coordinator pattern (like BooCode's conductor but more structured). LangGraph swarm = distributed handoff pattern (agents choose who to delegate to). Both are well-specified <500-line Python modules. The `create_handoff_tool()` mechanism is the critical pattern — a tool that transfers context between agents with a description the source agent can reason about.

---

### Domain 17: Sim Studio — Full AI Agent Workspace

**Source**: `sim/` — SimStudio open-source AI agent workspace (Next.js + monorepo)

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Visual workflow builder** (drag-and-drop block-based agent design with canvas) | `sim/apps/sim/blocks/` | `apps/web` → visual agent builder | Large | High |
| **Block execution engine** (executor orchestrating block DAGs with variable resolution) | `sim/apps/sim/executor/` | `conductor/` → visual flow execution | Large | High |
| **1,000+ tool integrations** via standardized tool config pattern | `sim/apps/sim/tools/` + `tools/registry.ts` | `data/skills/` → integration framework | Large | High |
| **Knowledge base** (document upload, vector RAG, query from agents) | `sim/apps/sim/` (knowledge base feature) | `apps/server` → RAG system | Large | High |
| **Realtime collaborative canvas** (Socket.IO, room-based multi-user) | `sim/apps/realtime/` | `apps/web` → collaborative workspace | Large | Med |
| **Workflow persistence layer** (load/save/subflow, raw block state) | `sim/packages/workflow-persistence/` | `conductor/` → flow persistence | Med | High |
| **Audit action recording** (`recordAudit + AuditAction + AuditResourceType`) | `sim/packages/audit/` | `apps/server` → audit framework | Small | Med |
| **Better Auth shared session** (cross-service auth via shared DB + secret) | `sim/packages/auth/` | `apps/server` → multi-service auth | Small | High |

**Key insight**: Sim is a full production AI agent workspace — orders of magnitude more complex than anything else in `/forks`. Its value for BooCode is primarily as a **reference architecture** for the visual workflow builder and block execution engine. The `workflow-types/`, `workflow-persistence/`, and `workflow-authz/` packages are well-modularized and could provide patterns. The audit system and auth patterns are directly portable.

---

### Domain 18: Vercel Ecosystem (Missed Repos)

**Source**: Various Vercel repos. See DEEP RESEARCH C for Vercel Workflow and DEEP RESEARCH E for Vercel Sandbox.

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Turborepo task scheduler** (dependency graph, parallel execution, local+remote caching, task profiles) | `vercel/turborepo/` | `conductor/` → task dependency scheduling | Med | High |
| **Vercel AI SDK provider pattern** (model-provider abstraction with streaming, tool calling, structured output) | `vercel/ai/` | `apps/server` → provider abstraction (already partially done) | Large | High |
| **SWR stale-while-revalidate** (data fetching cache: serve stale→revalidate→update, dedup, focus revalidation) | `vercel/swr/` | `apps/server` → data caching layer | Small | High |
| **Next.js server actions** (RPC-style server functions called directly from client components) | `vercel/next.js/` | `apps/web` → server action pattern | Small | Med |
| **Vercel CLI platform API** (deployment, environment variables, domain management) | `vercel/vercel/` | `apps/server` → deployment integration | Large | Low |
| **Styled-JSX** (scoped CSS with zero runtime, compile-time transformation) | `vercel/styled-jsx/` | `apps/web` → CSS-in-JS reference | Small | Low |

**Key insight**: The most valuable Vercel patterns for BooCode are **Turborepo's task scheduler** (parallel dependency-graph execution maps to conductor workflow scheduling) and **SWR's stale-while-revalidate** (maps to BooCode's data caching for codecontext/boocontext results). Vercel AI SDK's provider pattern is already partially replicated in BooCode.

---

### Domain 19: LangChain Example Apps (Not Individual Libraries)

**Source**: Various LangChain example repos (chat-langchain, open-canvas, deep-agents-ui, etc.)

These repos are **example applications** of LangChain/LangGraph, not libraries with independent patterns. They demonstrate usage of the core libraries already analyzed (langchain-core, langgraph, langmem).

| Repo | Assessment | Value to BooCode |
|------|-----------|-----------------|
| `chat-langchain/` | LangSmith-powered RAG chatbot example | **Low** — LangChain-specific patterns |
| `open-canvas/` | Collaborative AI writing canvas (Next.js) | **Low** — product concept, not liftable code |
| `deep-agents-ui/` | TypeScript UI for Deep Agents | **Low** — React UI for langgraphjs |
| `deepagents/` | Python sub-agent framework | **Med** — sub-agent spawning pattern (covered by harness-sdk & DeerFlow analyses) |
| `deepagentsjs/` | JS port of deepagents | **Low** — same as Python version |
| `local-deep-researcher/` | Local research agent (Ollama) | **Low** — simple agent example |
| `open_deep_research/` | LangChain deep research | **Low** — report generation example |
| `open-swe/` | SWE-bench agent framework | **Low** — benchmark-specific |
| `opengpts/` | GPTs clone with LangGraph | **Low** — product concept |
| `openwork/` | LangGraph workflow platform | **Med** — visual workflow patterns |
| `langsmith-starter-kit/` | LangSmith evaluation starter | **Low** — LangSmith-specific |
| `claude-workflow-v2/` | CloudAI-X workflow definitions | **Med** — workflow agent patterns |
| `opencode-workflow/` | CloudAI-X OpenCode workflows | **Med** — OpenCode workflow configurations |

**Key insight**: These are primarily **example applications** for LangChain's commercial products. They don't contain independently liftable patterns beyond what's already captured in the core LangGraph/LangMem analyses. Skip deep analysis — focus on the library-level repos already covered.

---

### Domain 20: Strands Tools Library

**Source**: `tools/` — Strands Agents tool library

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Tool library pattern** (file ops, shell, memory, web, image, swarm tools as independent modules) | `tools/` | `data/skills/` → tool organization pattern | Small | Med |
| **Tool module format** (each tool = single directory with standardized interface) | `tools/` | `data/skills/` → tool packaging standard | Small | Med |

**Key insight**: The strands tools library is a reference for how BooCode could organize its growing tool/skill collection. Each tool as an independent module with a standard interface is the right pattern.

---

### Domain 21: Other Missed Repos — Quick Assessment

| Repo | Summary | Worth Lift? | Reason |
|------|---------|-------------|--------|
| `amp-acp/` | ACP (Agent Communication Protocol) adapter | **Med** | ACP is a standard, any implementation is useful. Reference for BooCode's ACP layer |
| `qgn.app/` | Electron desktop app (QuickGen — AI code generation UI) | **Low** | Features duplicated: screenshot→code, code editing UI. BooCode's web UI covers the same ground |
| `agent-runtime/` | Generic agent runtime | **Low** | Overlaps with harness-sdk analysis |
| `ai-sdk-provider-opencode-sdk/` | OpenCode provider for Vercel AI SDK | **Low** | Integration adapter, not independently valuable |
| `memory_engine/` | (Not analyzed — see langmem for LangChain memory) | **Low** | Covered by langmem + deer-flow analyses |
| `parlant/` | Already deeply analyzed in DEEP RESEARCH A | — | Covered |
| `audit-harness/` | Already deeply analyzed in DEEP RESEARCH A | — | Covered |
| `Archon/` | Already deeply analyzed in DEEP RESEARCH C | — | Covered |
| `harness-sdk/` | Already deeply analyzed in DEEP RESEARCH B | — | Covered |
| `hive/` | Already deeply analyzed in DEEP RESEARCH B | — | Covered |
| `CowAgent/` | Already deeply analyzed in DEEP RESEARCH D | — | Covered |
| `deer-flow/` | Already deeply analyzed in DEEP RESEARCH D+F | — | Covered |
| `ruflo/` | Already deeply analyzed in DEEP RESEARCH F | — | Covered |
| `opencode-extras/*/` | Already covered in original lift analysis | — | Covered |

---

## UPDATED RANKED INTEGRATION RECOMMENDATIONS (Post-Extension)

New findings sorted into the existing Tier structure:

### Tier 0: Immediate (New — higher value than existing Tier 1)
| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 0a | **Add boocontext-audit as behavioral rules engine** | `boocontext-audit/` | `apps/coder` + `apps/server` | Complete TypeScript Parlant port: guideline model, 6-batch matcher, relational resolver, audit trail, ambient context, graded recovery. Zero external deps. Single most undervalued repo. |
| 0b | **Add type-inject MCP server** | `type-inject/packages/mcp/` | `apps/server` MCP client | Fixes 0% TypeScript recovery. Published as `@nick-vi/type-inject-mcp`. One-line config addition. |
| 0c | **Add type-inject auto-injection hook** | `type-inject/packages/claude-hook/` | `apps/coder` | Type injection on file reads + type checking on writes. Direct improvement to edit quality. |

### Tier 0.5: Plugin Architecture from claude-code

| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 0d | **Adopt claude-code plugin format** | `claude-code/plugins/*/` | `data/plugins/` + `apps/coder` | Standard plugin structure (`.claude-plugin/plugin.json` → commands/agents/skills/hooks/MCP). Proven 14-plugin ecosystem. |
| 0e | **Security guidance hooks** | `claude-code/plugins/security-guidance/` | `apps/coder` PreToolUse | 9 security pattern detectors. Stops command injection, XSS, unsafe deserialization before they happen. |
| 0f | **Self-referential agent loop** | `claude-code/plugins/ralph-wiggum/` | `apps/coder` → `/ralph-loop` | Agent runs same task until completion. Stop hook intercepts exit. |

### Updated Tier 1 additions:
| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 1a | **Supervisor agent pattern** | `langgraph-supervisor-py/langgraph_supervisor/` | `conductor/` | Central coordinator delegates to specialized agents. Pattern-ported from 469-line Python module. |
| 1b | **Handoff tool mechanism** | `langgraph-supervisor-py + langgraph-swarm-py` | `conductor/` | Agent-to-agent context transfer via `create_handoff_tool(agent_name, description)`. |
| 1c | **X-Agent-Flags header** | `llama-sidecar/` | `apps/server` | Per-agent LLM parameter overrides without spawning new processes. |

### Updated Tier 2 additions:
| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 2a | **Turborepo task scheduler** | `turborepo/` | `conductor/` | Dependency graph scheduling, parallel execution, caching. Maps directly to workflow execution needs. |
| 2b | **SWR stale-while-revalidate cache** | `swr/` | `apps/server` | Data caching layer for codecontext/boocontext results. Serve cached → revalidate → update. |
| 2c | **Swarm agent pattern** | `langgraph-swarm-py/langgraph_swarm/` | `conductor/` | Dynamic agent handoff without central coordinator. |
| 2d | **Sim workflow-types package** | `sim/packages/workflow-types/` | `conductor/` | Pure BlockState/Loop/Parallel types — reference for BooCode's own flow types. |

### Updated Tier 3 additions:
| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 3a | **Visual workflow builder** | `sim/apps/sim/blocks/` + `executor/` | `apps/web` | Drag-and-drop agent design. Large effort but high strategic value. |
| 3b | **PR review agent team** | `claude-code/plugins/pr-review-toolkit/` | `conductor/` → PR review flow | 5 parallel agents for code review, bug finding, test analysis, type design, simplification. |

---

## REVISED DEPENDENCY GRAPH

```
boocontext-audit behavioral engine (NEW — Tier 0)
  ├── Guideline model → Multi-batch matcher → Relational resolver
  ├── Audit middleware → Graded context recovery
  └── Depends on: LLM backend for SchematicGenerator

type-inject MCP (NEW — Tier 0)
  ├── Type extraction → Type prioritization → Token-budgeted injection
  └── Independent — add as MCP server

claude-code plugin format (NEW — Tier 0.5)
  ├── Enables: Security hooks → Self-referential loops → PR review teams
  └── Prerequisite: plugin.json convention

LangGraph supervisor pattern (NEW — Tier 1)
  └── Enables: Handoff tool → Swarm pattern (Tier 2)

Turborepo scheduler (NEW — Tier 2)
  └── Enables: Task dependency graph → Parallel execution → Caching
```

---

## REVISED COMPLETE REPO REFERENCE (Additions)

| Repo | Path | Key Capability | Lift Priority |
|------|------|---------------|---------------|
| boocontext-audit | `/opt/forks/boocontext-audit/` | Behavioral compliance engine (guidelines, matching, resolution, audit, recovery) | **Tier 0** |
| type-inject | `/opt/forks/type-inject/` | TypeScript type extraction, lookup MCP, auto-injection hooks | **Tier 0** |
| claude-code plugins | `/opt/forks/claude-code/plugins/` | 14 official plugins: plugin format, security hooks, loop, PR review, feature dev | **Tier 0.5** |
| langgraph-supervisor | `/opt/forks/langchain/langgraph-supervisor-py/` | Supervisor agent pattern (central coordinator → specialized agents) | **Tier 1** |
| langgraph-swarm | `/opt/forks/langchain/langgraph-swarm-py/` | Swarm agent pattern (dynamic handoff, no central coordinator) | **Tier 2** |
| turborepo | `/opt/forks/vercel/turborepo/` | Task dependency graph scheduling, parallel execution, caching | **Tier 2** |
| swr | `/opt/forks/vercel/swr/` | Stale-while-revalidate data fetching cache | **Tier 2** |
| sim | `/opt/forks/sim/` | Full AI agent workspace: visual workflows, block engine, knowledge base | **Tier 3** |
| claude-agent-sdk | `/opt/forks/claude-agent-sdk-typescript/` | Session store abstraction, streaming agent pattern | **Tier 2** |
| claude-agent-sdk-python | `/opt/forks/claude-agent-sdk-python/` | Python version (same patterns as TS) | Low |
| strands tools | `/opt/forks/tools/` | Tool organization pattern | Tier 3 |
| amp-acp | `/opt/forks/amp-acp/` | ACP protocol adapter | Tier 2 |
| llama-sidecar | `/opt/forks/llama-sidecar/` | X-Agent-Flags header pattern | **Tier 1** |

---

## KEY FINDINGS SUMMARY

### Most Undervalued Repo
**`boocontext-audit/`** — Not a simple audit extraction. A full Parlant-inspired behavioral compliance engine with:
- Guideline condition/action model (Parlant port)
- 6-batch multi-matcher (Observational, Actionable, PreviouslyApplied, Disambiguation, ResponseAnalysis, LowCriticality)
- Relational resolver (DEPENDS_ON, PRIORITIZES, ENTAILS, TAG_ALL, TAG_PRIORITIZES with iterative convergence)
- SchematicGenerator for structured LLM batch calls
- Full audit middleware with graded context recovery (L0-L4)
- Zero external deps (only `@modelcontextprotocol/sdk`)

The behavioral engine could enforce agent behavior rules (security policies, code style, tool restrictions) via structured LLM evaluation — far beyond simple CLAUDE.md guidelines.

### Easiest Wins
1. **type-inject MCP server** — One-line config add. Fixes 0% TypeScript recovery.
2. **Security guidance hooks** — Copy claude-code/plugins/security-guidance/ pattern. Days of effort.
3. **X-Agent-Flags header** — Small change to inference routing for per-agent LLM parameters.
4. **SWR caching for codecontext** — Stale-while-revalidate for MCP tool results. Days of effort.

### Architecture Patterns Worth Studying
1. **claude-code plugin format** — `.claude-plugin/plugin.json` → commands/agents/skills/hooks/ `.mcp.json` is the de facto standard. BooCode should adopt a compatible format.
2. **LangGraph supervisor pattern** — Clean central-coordinator architecture with handoff tools.
3. **Sim's workflow-types package** — Pure type definitions for BlockState, Loop, Parallel — reference for conductor flow types.
4. **Turborepo's task scheduling** — Dependency graph with remote caching — maps to conductor's parallel execution needs.

---

## PASS 4 — CORRECTED ASSESSMENTS (Deep Analysis Findings)

Several repos were initially assessed as "Low Value" in the extension. Deep analysis reveals they are much more significant.

---

### Domain 22: Agent Runtime — Combined Eval + Sandbox + Pregel in TypeScript

**Source**: `agent-runtime/` — `/home/samkintop/opt/forks/agent-runtime/`

**What it is**: A **pre-compiled TypeScript monorepo** that combines three independent subsystems into one clean package:
- `@agent-runtime/eval` — OpenEvals-style LLM evaluation framework
- `@agent-runtime/sandbox` — Vercel Sandbox-style remote execution
- `@agent-runtime/graph` — langgraphjs-style Pregel state graph engine

**Why this matters**: This is the exact combined system from DEEP RESEARCH E (OpenEvals + Vercel Sandbox + langgraphjs), already ported to TypeScript, already compiled to `dist/`, with zero LangChain dependencies. It's a direct-lift candidate.

**Key Architecture** (`packages/graph/src/`):

```
pregel/
├── index.ts      — Pregel class (compiled graph engine)
├── algo.ts       — _applyWrites, _prepareNextTasks
├── loop.ts       — PregelLoop (execution loop)
├── runner.ts     — PregelRunner (parallel task execution)
├── read.ts       — PregelNode (channel reads)  
├── write.ts      — ChannelWrite
├── io.ts         — mapInput, readChannels
└── types.ts      — Pregel types
channels/
├── base.ts       — BaseChannel (abstract)
├── last_value.ts — LastValue, LastValueAfterFinish
├── binop.ts      — BinaryOperatorAggregate
├── topic.ts      — Topic (publish/subscribe)
├── ephemeral.ts  — EphemeralValue
└── named_barrier.ts — NamedBarrierValue
graph/
├── graph.ts      — Graph class (untyped DAG)
├── state.ts      — StateGraph class (typed state machine)
└── annotation.ts — Annotation.Root helpers
stream/
├── index.ts      — StreamEvent protocol, GraphRunStream
state/
├── schema.ts     — State schema + channel builder
└── adapter.ts    — State adapter
interrupt.ts      — interrupt(), interruptMultiple() — HITL
constants.ts      — START, END, INTERRUPT, Command, Send
errors.ts         — NodeSpecError, GraphCycleError, ChannelError
```

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Pre-compiled Pregel engine** (StateGraph, superstep execution, channels, streaming — zero LangChain deps) | `agent-runtime/packages/graph/dist/` | `conductor/` → workflow graph engine | **Small** (import/adapt) | **Critical** |
| **LLM-as-judge evaluator** (structured scoring, prompt templates, multi-turn simulation, trajectory evaluation) | `agent-runtime/packages/eval/dist/` | `apps/server` → agent quality evaluation | **Small** | **High** |
| **Remote sandbox abstraction** (command execution, POSIX filesystem, snapshots, network policy) | `agent-runtime/packages/sandbox/dist/` | `apps/booterm` → sandboxed code execution | **Small** | **High** |
| **Human-in-the-loop interrupts** (interrupt()/interruptMultiple() pattern — resumable execution) | `agent-runtime/packages/graph/src/interrupt.ts` | `apps/coder` → pause-for-input mid-workflow | **Small** | **High** |
| **Channel types** (LastValue, Topic, BinaryOperatorAggregate, Ephemeral, NamedBarrierValue) | `agent-runtime/packages/graph/src/channels/` | `conductor/` → typed state channels | **Small** | **High** |
| **StreamEvent protocol** (STREAM_MODES, GraphRunStream, customEvent) | `agent-runtime/packages/graph/src/stream/` | `apps/server` → streaming workflow events | **Small** | **High** |
| **Execution loop with checkpoint** (PregelLoop → PregelRunner → _applyWrites → checkpoint cycle) | `agent-runtime/packages/graph/src/pregel/loop.ts` + `runner.ts` | `conductor/` → structured execution lifecycle | **Small** | **High** |

**Key insight**: `agent-runtime` is the #1 most undervalued repo. It's a pre-built, compiled TypeScript implementation of the most powerful patterns from DEEP RESEARCH E, ready for direct import. The `@agent-runtime/graph` package provides a complete Pregel state machine that could replace or augment BooCode's conductor flow runner. Zero LangChain deps, clean TypeScript, already built.

---

### Domain 23: Memory Engine — Complete 3-Tier Memory System

**Source**: `memory_engine/` — `/home/samkintop/opt/forks/memory_engine/`

**What it is**: A standalone Python memory system combining LangMem's token-budget summarization, CowAgent's 3-tier architecture (Context→Daily→Core), and DeerFlow's memory update flow. Complete with SQLite FTS5 + vector search, Deep Dream consolidation, and management tools.

**Why this matters**: Unlike the other memory repos (LangMem = framework-coupled, CowAgent = complex, DeerFlow = LangChain-coupled), `memory_engine` is a **clean, standalone Python package** with a clear architecture that can be ported to TypeScript for boocode directly.

**Key Architecture:**

```
config.py               — MemoryConfig (Pydantic, all tunable params)
core/
├── store.py            — MemoryStore (SQLite + FTS5 + vector BLOB, 262 lines)
├── hybrid_search.py    — HybridSearchEngine (vector 0.7 + keyword 0.3)
├── schemas.py          — MemoryChunk, SearchResult, Fact (Pydantic + dataclass)
tiers/
├── context.py          — ContextTier (short-term, token-budget summarization, 205 lines)
├── core.py             — CoreTier (long-term SQLite + hybrid search, 132 lines)
├── daily.py            — DailyTier (Markdown files + MEMORY.md, 107 lines)
tools/
├── manage.py           — Memory management (create/update/delete)
├── search.py           — Search tools
background/
├── deep_dream.py       — Deep Dream LLM consolidation (like CowAgent)
├── queue.py            — Debounced background queue (like DeerFlow)
embedding/
extraction/
utils/
```

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **SQLite FTS5 store** with vector BLOB storage, WAL mode, thread safety | `memory_engine/core/store.py` (262 lines) | `apps/coder` → memory persistence | Med | High |
| **3-tier memory** (Context: token-budget summary → Daily: Markdown files → Core: SQLite+vectors) | `memory_engine/tiers/` (context.py, daily.py, core.py) | `apps/coder` → structured memory hierarchy | Med | **Critical** |
| **Hybrid search** (vector 0.7 + keyword 0.3 with FTS5, temporal decay) | `memory_engine/core/hybrid_search.py` | `apps/coder` → memory retrieval | Med | High |
| **MemoryConfig** (typed, Pydantic, 21 tunable parameters with defaults) | `memory_engine/config.py` | `apps/server` → configuration pattern | Small | Med |
| **Deep Dream consolidation** (overnight LLM rewrite of MEMORY.md) | `memory_engine/background/deep_dream.py` | `apps/coder` → long-term memory consolidation | Med | High |
| **Management tools** (manage.py create/update/delete + search.py) | `memory_engine/tools/` | `apps/coder` → memory CRUD tools | Small | High |
| **Debounced background queue** | `memory_engine/background/queue.py` | `apps/server` → async memory processing | Small | Med |

**Key insight**: `memory_engine` is the cleanest reference implementation of the memory patterns identified in DEEP RESEARCH D. Where LangMem is framework-coupled (LangGraph) and CowAgent is feature-rich but complex (1500+ line files), memory_engine has clean <300-line files with clear separation of concerns. Best model for porting 3-tier memory to boocode.

---

## UPDATED RANKED INTEGRATION RECOMMENDATIONS (Post-Correction)

### New Tier 0 additions:
| # | What | Source | BooCode Target | Why |
|---|------|--------|----------------|-----|
| 0g | **Import @agent-runtime/graph Pregel engine** | `agent-runtime/packages/graph/dist/` | `conductor/` → replace flow runner | Pre-compiled TS StateGraph with Pregel execution, channels, interrupts, streaming. Zero deps. Direct lift. |
| 0h | **Import @agent-runtime/eval evaluator** | `agent-runtime/packages/eval/dist/` | `apps/server` → agent quality eval | LLM-as-judge, trajectory, code correctness, multi-turn simulation. Ready to use. |
| 0i | **Port memory_engine 3-tier memory to TypeScript** | `memory_engine/` (Python → TS port) | `apps/coder` → structured memory | Cleanest reference for Context→Daily→Core with SQLite FTS5 + vectors + Deep Dream. |

### Updated REVISED COMPLETE REPO REFERENCE

| Repo | Path | Key Capability | Lift Priority |
|------|------|---------------|---------------|
| agent-runtime | `/opt/forks/agent-runtime/` | Pre-compiled Pregel engine + evaluator + sandbox (TypeScript, zero LangChain deps) | **Tier 0** |
| memory_engine | `/opt/forks/memory_engine/` | 3-tier memory: SQLite FTS5+vectors, Deep Dream, token-budget summarization | **Tier 0** |
| deepagents | `/opt/forks/deepagents/` | Sub-agent framework with filesystem, memory, skills, summarization middleware | Tier 2 |
| open-swe | `/opt/forks/langchain/open-swe/` | Production coding agent: 11 middleware components, sandbox lifecycle, GitHub/Linear/Slack | Tier 2 |

---

### Domain 24: Deep Agents — Production Sub-Agent Harness

**Source**: `deepagents/` — Python agent harness by LangChain

**Corrected assessment**: Initially assessed as "Med" due to being a LangChain-specific implementation. However, it contains a **clean middleware architecture** for sub-agent orchestration that is the reference implementation for boocode's sub-agent system.

**Key patterns** (`deepagents/libs/deepagents/deepagents/`):

```
graph.py             — create_deep_agent(): full agent assembly (866 lines)
middleware/
├── subagents.py     — SubAgent middleware (788 lines): spawn isolated agents with task() tool
├── async_subagents.py — AsyncSubAgent middleware: parallel sub-agent execution
├── filesystem.py    — Filesystem middleware: read/write/edit/ls with permission model
├── memory.py        — MemoryMiddleware: persistent cross-session memory
├── skills.py        — SkillsMiddleware: loadable skill behaviors
├── summarization.py — Token-budget context management
└── _tool_exclusion.py — Tool exclusion per middleware layer
backends/            — StateBackend, SandboxBackend, LangSmithSandbox
profiles/            — ProviderProfile, HarnessProfile (model-specific config)
```

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **SubAgent middleware** (task() tool spawns isolated agent with own model, tools, middleware, permissions) | `deepagents/middleware/subagents.py` (788 lines) | `conductor/` → sub-agent spawning | Med | High |
| **Filesystem middleware** (permission model: allow/deny paths by pattern) | `deepagents/middleware/filesystem.py` | `apps/coder` → file access control | Small | High |
| **Memory middleware** (cross-session persistent state via BaseStore) | `deepagents/middleware/memory.py` | `apps/coder` → agent memory abstraction | Med | High |
| **Skills middleware** (loadable skills from directories) | `deepagents/middleware/skills.py` | `data/skills/` → skill loading architecture | Med | Med |
| **Summarization middleware** (token-budget context management) | `deepagents/middleware/summarization.py` | `apps/server` → context window management | Med | High |

**Key insight**: deepagents is the reference implementation for boocode's sub-agent middleware pattern. The SubAgent spec (name, description, system_prompt, tools, model, middleware, permissions) maps directly to boocode's agent configuration. The middleware chain architecture is the right abstraction for composable agent behavior.

---

### Domain 25: Open SWE — Production Coding Agent Framework

**Source**: `open-swe/` (at `/opt/forks/langchain/open-swe/`) — LangChain's open-source internal coding agent framework

**Corrected assessment**: Initially assessed as "Low" because it was grouped with example apps. In reality, it's a **production coding agent framework** used by companies like Stripe, Ramp, Coinbase. Has 10+ middleware components, sandbox lifecycle management, and multi-channel integration (Slack, Linear, GitHub) that directly relate to boocode's domain.

**Key architecture** (`agent/`):

```
├── server.py          — Main agent factory (607 lines): create_deep_agent with curated tool list + middleware stack
├── webapp.py          — FastAPI routes: webhooks for GitHub, Linear, Slack
├── middleware/        — 11 middleware components
│   ├── check_message_queue.py  — Mid-run message injection (Linear/Slack comments arrive mid-stream)
│   ├── model_fallback.py       — Transient failure → fallback model (Anthropic↔OpenAI)
│   ├── sandbox_circuit_breaker.py — Circuit breaker on repeated sandbox failures
│   ├── sanitize_thinking_blocks.py — Strip malformed Anthropic thinking blocks
│   ├── sanitize_tool_inputs.py — Normalize tool inputs before execution
│   ├── tool_error_handler.py   — Catch tool exceptions → tool messages
│   ├── notify_step_limit.py    — Post Slack reply when agent hits step cap
│   ├── refresh_slack_status.py — Keep Slack "typing" indicator alive
│   ├── ensure_no_empty_msg.py  — Guard against empty assistant messages
│   └── exclude_tools.py        — Tool exclusion per context
├── dashboard/         — Model profiles, team settings, OAuth, usage tracking
├── integrations/      — LangSmith sandbox with GitHub proxy
├── tools/             — Curated tool set (http_request, fetch_url, web_search, Linear, Slack, GitHub)
├── reviewer.py        — Read-only PR reviewer with findings model
├── analyzer.py        — Per-repo review style learner
├── utils/             — Auth, model resolution, sandbox state management
└── skills/            — Deep agents skills for bootstrap/continual learning
```

| Capability | Source | BooCode Target | Effort | Value |
|-----------|--------|----------------|--------|-------|
| **Mid-run message injection** (queue new messages mid-stream → inject before next LLM call) | `open-swe/agent/middleware/check_message_queue.py` | `apps/coder` → mid-conversation message injection | Med | High |
| **Model fallback middleware** (primary fails → retry with fallback provider) | `open-swe/agent/middleware/model_fallback.py` (93 lines) | `apps/coder` → provider failover | Small | High |
| **Sandbox circuit breaker** (consecutive sandbox failures → abort thread) | `open-swe/agent/middleware/sandbox_circuit_breaker.py` (261 lines) | `apps/booterm` → sandbox resilience | Small | High |
| **Sanitize tool inputs middleware** (strip/normalize before tool execution) | `open-swe/agent/middleware/sanitize_tool_inputs.py` | `apps/coder` → tool input safety | Small | Med |
| **Middleware stack pattern** (ordered chain: sanitize → limit → error → queue → status → breaker → fallback) | `open-swe/agent/middleware/` + `agent/server.py` | `conductor/` → middleware architecture | Med | High |
| **Deterministic thread-id derivation** (same issue/PR → same thread) | `open-swe/agent/utils/github_comments.py` + `utils/linear.py` + `utils/slack.py` | `apps/server` → session continuity | Small | High |
| **Sandbox lifecycle** (4 cases: cached→reconnect, creating→reset, missing→create, metadata→reconnect) | `open-swe/agent/utils/sandbox_state.py` | `apps/booterm` → sandbox lifecycle management | Med | High |
| **GitHub proxy in sandbox** (inject GitHub App token → sandbox uses `gh dummy` without real tokens) | `open-swe/agent/utils/github_comments.py`, `integrations/langsmith.py` | `apps/booterm` → authenticated git in sandbox | Med | High |

**Key insight**: open-swe is the most production-relevant coding agent framework in the entire forks directory. Its middleware stack pattern (10 ordered middleware components) is a direct reference for boocode's inference lifecycle. The model fallback pattern (Anthropic↔OpenAI on transient errors) and sandbox circuit breaker are directly liftable. The mid-run message injection pattern solves a real boocode problem: "how to inject user messages that arrive while the agent is processing."

---

### Corrected Assessment: LangChain Python Library

**Source**: `langchain/langchain/libs/` + `langchain/langchain/libs/core/langchain_core/`

This is the LangChain Python framework itself. Not an example app. The core abstractions live in `libs/core/langchain_core/`:

| Module | Key Patterns | Liftable? |
|--------|-------------|-----------|
| `agents.py` | Agent types, AgentExecutor protocol | **No** — deeply coupled to LangChain's runnable framework |
| `tools.py` | BaseTool, StructuredTool abstraction | **Concept only** — boocode already has its own tool model |
| `callbacks/` | CallbackHandler, AsyncCallbackHandler (17 events) | **Inspiration** — boocode's hook system needs this event set |
| `caches.py` | LLM response caching | **Yes** — pattern for boocode's LLM cache |

**Verdict**: The LangChain library itself is too coupled to its own framework to lift individual patterns. The callback system (17 lifecycle events for tool start/end, LLM start/end, chain start/end) is a useful reference for boocode's hooks system but not directly liftable.

---

### Corrected Assessment: LangGraph Python Core

**Source**: `langchain/langgraph/libs/` — Python langgraph

Key differences from langgraphjs (already analyzed in DEEP RESEARCH E):

| Feature | Python | JS | BooCode Relevance |
|---------|--------|----|-------------------|
| Checkpointer implementations | SQLite, Postgres, Memory, Conformance tests | Checkpoint interface only | **Med** — checkpointer diversity is useful |
| Prebuilt agents | `create_react_agent` | `createReactAgent` | **Low** — same concept |
| SDK | `sdk-py`, `sdk-js` | Platform clients | **Low** — deployment-specific |
| CLI | `langgraph-cli` (dev, deploy, test) | None | **Low** — dev tooling |

**Verdict**: No significant liftable patterns beyond what was already covered in the langgraphjs Pregel analysis (DEEP RESEARCH E). The checkpointer implementations are the most useful reference.

---

### Corrected Assessment: langchainjs

**Source**: `langchain/langchainjs/`

The JS port of LangChain. Same architecture, different language. Contains no independently liftable patterns beyond what the Python LangChain library provides.

**Verdict**: No liftable patterns. Focus on `agent-runtime` instead (which is the clean TS rewrite).

---