eagle-mem 4.10.13 → 4.11.0

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.11.0 Agent Compatibility and Governance Surfaces
+
+This feature release expands Eagle Mem from Claude/Codex memory hooks into a broader multi-agent governance substrate:
+
+- **Agent Compatibility Docs**: Added official-doc-backed compatibility notes for Claude Code, Codex, and OpenCode hook/plugin behavior.
+- **OpenCode Integration**: Added a local OpenCode plugin adapter, hook normalization fixtures, and install/update checks.
+- **Compaction Survival**: Expanded compaction recovery tests across summaries, memories, tasks, feature verification, recall, and graph memory.
+- **Orchestration Events**: Added durable event tables for orchestration and hook observability, with dashboard and replay/inspect/repair utilities.
+- **Trust Surfaces**: Hardened doctor, statusline, JSON output, repair, and release verification behavior with new regression coverage.
+- **Web/Docs Refresh**: Updated README, architecture page, and compatibility docs to describe the current hook, plugin, dashboard, and governance model.
+
+---
+
 ## v4.10.13 Feature Gate Monorepo Hardening
 
 This hotfix closes the feature verification gate false positives found in monorepos with repeated basenames:

package/README.md

@@ -7,11 +7,11 @@
 
 # Eagle Mem
 
-**Shared memory, release guardrails, and worker lanes for Claude Code, Codex, Grok, and Google Antigravity.**
+**Shared memory, release guardrails, and worker lanes for Claude Code, Codex, OpenCode, Grok, and Google Antigravity.**
 
-Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code, Codex, and Google Antigravity hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
+Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code, Codex, OpenCode, and Google Antigravity hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
 
-**v4.10.5 and onward focuses on Graph Memory, Dream Cycle Curation, Grok, Google Antigravity support, and Compaction Survival:** Grok users get first-class skill linking and `eagle-mem grok-bootstrap`, while Antigravity users get native Python SDK hook integration via `google_antigravity_hook.py`. Claude Code, Codex, and Antigravity receive the deepest automatic lifecycle support through hooks; Grok currently uses the shared CLI and skill workflow.
+**v4.10.5 and onward focuses on Graph Memory, Dream Cycle Curation, OpenCode, Grok, Google Antigravity support, and Compaction Survival:** OpenCode users get a global local plugin plus linked skills, Grok users get first-class skill linking and `eagle-mem grok-bootstrap`, and Antigravity users get native Python SDK hook integration via `google_antigravity_hook.py`. Claude Code, Codex, OpenCode, and Antigravity receive the deepest automatic lifecycle support through hooks or plugins; Grok currently uses the shared CLI and skill workflow.
 
 **Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
 [Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |
@@ -22,12 +22,12 @@ Eagle Mem turns AI coding sessions into compounding project knowledge. It gives
 - **Start warmer** - every new session can recall project overviews, decisions, gotchas, summaries, hot files, mirrored memories, plans, and tasks.
 - **Ship safer** - feature-mapped changes create pending verification records, and release-boundary commands stay blocked until the current diff is verified or waived.
 - **Waste fewer tokens** - Eagle Mem injects compact context, nudges duplicate reads, and can route noisy shell output through RTK.
-- **Coordinate agents** - Claude, Codex, Grok, and Antigravity can share one project memory while worker lanes record owner, model, effort, worktree, logs, validation, and handoff.
+- **Coordinate agents** - Claude, Codex, OpenCode, Grok, and Antigravity can share one project memory while worker lanes record owner, model, effort, worktree, logs, validation, and handoff.
 - **Stay local** - no daemon, no hosted memory service, no vector database. The core is hooks plus SQLite/FTS5.
 
 ## The Problem
 
-Claude Code, Codex, Grok, and Google Antigravity start every session with amnesia. They don't remember what you built yesterday, what decisions you made, what files matter, or what broke last time. Every `/compact` wipes context. Every new session is a cold start. You waste tokens re-explaining your project, re-reading files, and watching agents repeat mistakes you already corrected.
+Claude Code, Codex, OpenCode, Grok, and Google Antigravity start every session with amnesia. They don't remember what you built yesterday, what decisions you made, what files matter, or what broke last time. Every `/compact` wipes context. Every new session is a cold start. You waste tokens re-explaining your project, re-reading files, and watching agents repeat mistakes you already corrected.
 
 The longer you work with Claude Code, the worse this gets. Projects accumulate history — decisions, gotchas, architectural patterns, feature dependencies — and none of it survives across sessions.
 
@@ -41,7 +41,7 @@ Eagle Mem is a local runtime layer for AI coding agents. It adds three things th
 | **Guardrails** | "The agent cannot casually undo known decisions or push unverified feature changes." | Surfaces decisions before edits and enforces feature verification on push, PR, and publish boundaries. |
 | **Lanes** | "A big task can survive compaction and split across agents." | Persists orchestrations, worker lanes, worktrees, logs, validation commands, and handoffs. |
 
-Claude Code, Codex, and Google Antigravity share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code`, `Codex`, or `Antigravity`. Grok uses the same database through skills and CLI commands.
+Claude Code, Codex, OpenCode, and Google Antigravity share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code`, `Codex`, `OpenCode`, or `Antigravity`. Grok uses the same database through skills and CLI commands.
 
 **Zero per-instance overhead.** No daemon, no vector DB, no MCP server. Just bash/python hooks, sqlite3 (WAL mode, FTS5 full-text search), and jq.
 
@@ -66,17 +66,17 @@ eagle-mem install
 eagle-mem doctor
 ```
 
-That's it. `doctor` should report a healthy install. Open Claude Code or Codex, or import the Antigravity hook in your agent config, and Eagle Mem activates automatically. For Grok, run `eagle-mem grok-bootstrap` after install to confirm the linked skills and CLI workflow.
+That's it. `doctor` should report a healthy install. Open Claude Code, Codex, or OpenCode, or import the Antigravity hook in your agent config, and Eagle Mem activates automatically. For Grok, run `eagle-mem grok-bootstrap` after install to confirm the linked skills and CLI workflow.
 
-For Claude Code, Codex, and Google Antigravity, everything is automatic. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors memories and tasks (including planning-mode artifacts like `implementation_plan.md`, `task.md`, and `walkthrough.md`), learns which commands are noisy, and prunes stale data — all in the background via hooks.
+For Claude Code, Codex, OpenCode, and Google Antigravity, everything is automatic. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors memories and tasks (including planning-mode artifacts like `implementation_plan.md`, `task.md`, and `walkthrough.md`), learns which commands are noisy, and prunes stale data — all in the background via hooks or plugins.
 
-For Google Antigravity, the installer copies the native Python integration to `~/.eagle-mem/integrations/google_antigravity_hook.py`. For Codex, the installer enables `codex_hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, symlinks Eagle Mem skills into `~/.codex/skills`, and patches `~/.codex/AGENTS.md`. For Claude Code, it integrates with `~/.claude/settings.json`, `CLAUDE.md`, and `~/.claude/skills`. Grok users get skill symlinks into `~/.grok/skills/` and can run `eagle-mem grok-bootstrap` for setup guidance and self-linking.
+For Google Antigravity, the installer copies the native Python integration to `~/.eagle-mem/integrations/google_antigravity_hook.py`. For OpenCode, it installs a global local plugin at `~/.config/opencode/plugins/eagle-mem.js` and symlinks skills into `~/.config/opencode/skills`. For Codex, the installer enables `hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, symlinks Eagle Mem skills into `~/.codex/skills`, and patches `~/.codex/AGENTS.md`. For Claude Code, it integrates with `~/.claude/settings.json`, `CLAUDE.md`, and `~/.claude/skills`. Grok users get skill symlinks into `~/.grok/skills/` and can run `eagle-mem grok-bootstrap` for setup guidance and self-linking.
 
 ### Prerequisites
 
 - `sqlite3` with FTS5 support (ships with macOS; Eagle Mem prefers known system/Homebrew SQLite binaries before PATH shims)
 - `jq` (the installer offers to install if missing)
-- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, Google Antigravity SDK, or a Grok environment (`~/.grok/`)
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, OpenCode, Google Antigravity SDK, or a Grok environment (`~/.grok/`)
 
 ## How It Works
 
@@ -91,7 +91,7 @@ Hooks fire automatically at different points in the agent lifecycle:
 | **Stop** | agent turn ends | Saves fast heuristic summaries and extracts `<eagle-summary>` blocks when present. LLM enrichment runs later in the background so the agent lifecycle is not blocked. |
 | **SessionEnd** | session closes | Re-syncs tasks, marks session completed |
 
-Codex shell hooks are registered for `Bash`, `exec_command`, `shell_command`, and `unified_exec` tool names so release-boundary protection works across current Codex shell paths.
+Codex shell hooks are registered for `Bash`, `exec_command`, `shell_command`, and `unified_exec` tool names so release-boundary protection works across current Codex shell paths. OpenCode uses a global local plugin to normalize `chat.message`, `tool.execute.before`, `tool.execute.after`, `todo.updated`, `session.idle`, and compaction events into the same Eagle Mem hook payloads.
 Codex recall is emitted as compact hook JSON, so local Codex sessions get shared memory without the multi-screen hook dumps.
 
 ### Background Automation
@@ -110,7 +110,7 @@ Eagle Mem actively reduces token consumption:
 
 ### Compaction Survival
 
-One of the core promises of Eagle Mem is protecting against `/compact` and session amnesia. Compaction Survival is project-level: it reads shared Eagle Mem state such as durable tasks, enriched summaries, stale work, and orchestration lanes. Claude Code, Codex, and Google Antigravity get automatic hook-backed recovery through `SessionStart`, `Stop`/`post_turn`, and context-pressure nudges. Grok can inspect and use the same state through `eagle-mem compaction`, `eagle-mem tasks`, and the linked skills.
+One of the core promises of Eagle Mem is protecting against `/compact` and session amnesia. Compaction Survival is project-level: it reads shared Eagle Mem state such as durable tasks, enriched summaries, stale work, and orchestration lanes. Claude Code, Codex, OpenCode, and Google Antigravity get automatic hook-backed or plugin-backed recovery through session start, turn-end, and compaction events. Grok can inspect and use the same state through `eagle-mem compaction`, `eagle-mem tasks`, and the linked skills.
 
 Run `eagle-mem compaction` anytime to check readiness.
 
@@ -134,7 +134,7 @@ Eagle Mem prevents Claude from repeating past mistakes:
 - **Gotcha surfacing** — past surprises and gotchas are surfaced when editing related files
 - **Stale memory detection** — warns when edits may contradict stored memories
 - **Token guard** — when `rtk` is installed, raw shell output commands are rewritten or blocked with an RTK equivalent so large output is compacted before it enters agent context
-- **Orchestration lanes** — long-running work can be split into durable worker lanes with owners, validation commands, worktree paths, status notes, and handoff output shared across Claude Code, Codex, Grok, and Google Antigravity
+- **Orchestration lanes** — long-running work can be split into durable worker lanes with owners, validation commands, worktree paths, status notes, and handoff output shared across Claude Code, Codex, OpenCode, Grok, and Google Antigravity
 
 ## Commands
 
@@ -199,7 +199,7 @@ eagle-mem uninstall --dry-run
 
 Install and update print the files/configs they intend to touch before they change the runtime. The installed runtime writes `~/.eagle-mem/install-manifest.json` with file sizes, modes, and SHA-256 hashes, so `doctor` can tell whether hooks, scripts, libraries, and database helpers still match the package that installed them.
 
-Uninstall removes Claude Code, Codex, Grok, and Google Antigravity hook registrations, Eagle Mem instruction blocks, custom Claude statusline integration, and skill links. It backs up user config files before editing them and keeps `~/.eagle-mem/memory.db` unless you explicitly confirm data deletion.
+Uninstall removes Claude Code, Codex, OpenCode, Grok, and Google Antigravity hook/plugin registrations, Eagle Mem instruction blocks, custom Claude statusline integration, and skill links. It backs up user config files before editing them and keeps `~/.eagle-mem/memory.db` unless you explicitly confirm data deletion.
 
 ### Download Counts, Privacy, and Telemetry
 
@@ -256,7 +256,7 @@ Dry-run validation stays unblocked. For example, `gh pr create --dry-run` and `n
 
 ### Orchestrator/Worker Lanes
 
-Use orchestration when a broad task is split across Claude Code, Codex, subagents, or separate worktrees. These are **agent-run commands**: Eagle Mem injects the protocol into Claude Code/Codex, and the active agent runs the lane/status/spawn commands itself. Users should not have to operate this manually.
+Use orchestration when a broad task is split across Claude Code, Codex, OpenCode, subagents, or separate worktrees. These are **agent-run commands**: Eagle Mem injects the protocol into Claude Code, Codex, and OpenCode, and the active agent runs the lane/status/spawn commands itself. Users should not have to operate this manually.
 
 By default Eagle Mem uses the opposite-agent worker model:
 
@@ -284,14 +284,14 @@ Each lane is stored in `orchestration_lanes` and mirrored into `agent_tasks`, so
 
 Both agents write to `~/.eagle-mem/memory.db`:
 
-- `sessions.agent` records whether a session came from Claude Code, Codex, or Antigravity
+- `sessions.agent` records whether a session came from Claude Code, Codex, OpenCode, or Antigravity
 - `summaries.agent` records which agent produced the session summary
 - mirrored memories, plans, and tasks include `origin_agent`
-- SessionStart recall labels sources as `Claude Code`, `Codex`, or `Antigravity`
+- SessionStart recall labels sources as `Claude Code`, `Codex`, `OpenCode`, or `Antigravity`
 
-That means opening the same project in Claude Code, Codex, and Google Antigravity does not create isolated memory worlds. They recall the same project history while preserving the source of each memory. Grok can search, inspect, and update that same project memory through the linked skills and CLI commands.
+That means opening the same project in Claude Code, Codex, OpenCode, and Google Antigravity does not create isolated memory worlds. They recall the same project history while preserving the source of each memory. Grok can search, inspect, and update that same project memory through the linked skills and CLI commands.
 
-## Skills (Inside Claude Code, Codex, and Grok)
+## Skills (Inside Claude Code, Codex, OpenCode, and Grok)
 
 | Skill | What It Does |
 |-------|-------------|
@@ -299,7 +299,7 @@ That means opening the same project in Claude Code, Codex, and Google Antigravit
 | `/eagle-mem-overview` | Build a rich project briefing from README, entry points, and git history |
 | `/eagle-mem-memories` | View and search mirrored agent memories and plans |
 | `/eagle-mem-tasks` | TaskAware Compact Loop — break complex work into tasks that survive `/compact` |
-| `/eagle-mem-orchestrate` | Orchestrator/worker lane handoffs across Claude Code, Codex, Grok, and Google Antigravity |
+| `/eagle-mem-orchestrate` | Orchestrator/worker lane handoffs across Claude Code, Codex, OpenCode, Grok, and Google Antigravity |
 
 ## Data
 

package/architecture.html

@@ -683,7 +683,7 @@
       <div class="brand">
         <span class="brand-label">Eagle Mem</span>
         <h1>Agent Architecture Tutorial</h1>
-        <p>Technical architecture plus UX architecture for Claude Code, Codex, Grok, Google Antigravity, and future coding agents.</p>
+        <p>Technical architecture plus UX architecture for Claude Code, Codex, OpenCode, Grok, Google Antigravity, and future coding agents.</p>
       </div>
 
       <p class="nav-title">Start Here</p>
@@ -732,7 +732,7 @@
             </div>
             <div class="meta-box">
               <strong>Agents</strong>
-              <span>Claude Code, Codex, and Google Antigravity with hooks; Grok via skills.</span>
+              <span>Claude Code, Codex, OpenCode, and Google Antigravity with hooks/plugins; Grok via skills.</span>
             </div>
             <div class="meta-box">
               <strong>Core Promise</strong>
@@ -793,7 +793,7 @@
 
           <div class="callout">
             <h3>Compaction Survival is shared state</h3>
-            <p><code>eagle-mem compaction</code> reads project-level state from SQLite: enriched summaries, durable tasks, stale tasks, active orchestration lanes, and recent durable updates. Claude Code, Codex, and Google Antigravity have hook-backed automatic recovery around compact and clear events. Grok can use the same state through linked skills and CLI commands.</p>
+            <p><code>eagle-mem compaction</code> reads project-level state from SQLite: enriched summaries, durable tasks, stale tasks, active orchestration lanes, and recent durable updates. Claude Code, Codex, OpenCode, and Google Antigravity have hook-backed or plugin-backed automatic recovery around compact and clear events. Grok can use the same state through linked skills and CLI commands.</p>
           </div>
 
           <h3>Vocabulary</h3>
@@ -862,7 +862,7 @@
               <text x="40" y="42" class="label">User Layer</text>
               <rect x="40" y="58" width="220" height="72" class="box-cyan"></rect>
               <text x="62" y="90">Developer</text>
-              <text x="62" y="112" class="small">Works in Claude, Codex, Grok, or Antigravity</text>
+              <text x="62" y="112" class="small">Works in Claude, Codex, OpenCode, Grok, or Antigravity</text>
 
               <text x="40" y="178" class="label">Agent Layer</text>
               <rect x="40" y="194" width="220" height="78" class="box"></rect>
@@ -974,7 +974,7 @@
               <div class="step-num">5</div>
               <div>
                 <h3>Agent hooks are registered</h3>
-                <p>Claude Code hooks are patched into <code>~/.claude/settings.json</code>. Codex hooks are registered in <code>~/.codex/hooks.json</code>. Google Antigravity SDK hooks are registered programmatically in <code>google_antigravity_hook.py</code> using native Python async hooks. Grok has skills and CLI access.</p>
+                <p>Claude Code hooks are patched into <code>~/.claude/settings.json</code>. Codex hooks are registered in <code>~/.codex/hooks.json</code>. OpenCode receives a global local plugin at <code>~/.config/opencode/plugins/eagle-mem.js</code>. Google Antigravity SDK hooks are registered programmatically in <code>google_antigravity_hook.py</code> using native Python async hooks. Grok has skills and CLI access.</p>
               </div>
             </article>
 
@@ -982,7 +982,7 @@
               <div class="step-num">6</div>
               <div>
                 <h3>Skills and instructions are linked</h3>
-                <p>Eagle Mem skills are symlinked into each agent's skill directory. Claude receives <code>CLAUDE.md</code> instructions. Codex receives <code>AGENTS.md</code> instructions. Google Antigravity SDK maps and mirrors standard brain planning artifacts (plans, tasks, walkthroughs). Grok receives skills under <code>~/.grok/skills</code>.</p>
+                <p>Eagle Mem skills are symlinked into each agent's skill directory. Claude receives <code>CLAUDE.md</code> instructions. Codex receives <code>AGENTS.md</code> instructions. OpenCode receives linked skills under <code>~/.config/opencode/skills</code>. Google Antigravity SDK maps and mirrors standard brain planning artifacts (plans, tasks, walkthroughs). Grok receives skills under <code>~/.grok/skills</code>.</p>
               </div>
             </article>
           </div>
@@ -1097,7 +1097,7 @@
           <p class="section-number">06 / Technical Architecture</p>
           <h2>The Agent Adapter Layer</h2>
           <p class="lead">
-            The project is agent-generic below the adapter layer. Claude Code, Codex, and Google Antigravity have direct lifecycle hook adapters, while Grok participates through skills and CLI commands. Eagle Mem normalizes each supported surface into the same project memory model.
+            The project is agent-generic below the adapter layer. Claude Code, Codex, OpenCode, and Google Antigravity have direct lifecycle hook or plugin adapters, while Grok participates through skills and CLI commands. Eagle Mem normalizes each supported surface into the same project memory model.
           </p>
 
           <div class="grid-2">
@@ -1115,7 +1115,7 @@
 
             <article class="adapter-rule">
               <h3>Codex adapter</h3>
-              <p>Registered through <code>~/.codex/hooks.json</code> after enabling <code>codex_hooks</code>. Shell protection covers current Codex shell tool paths, including <code>exec_command</code>, <code>shell_command</code>, and <code>unified_exec</code>.</p>
+              <p>Registered through <code>~/.codex/hooks.json</code> after enabling <code>hooks</code>. Shell protection covers current Codex shell tool paths, including <code>exec_command</code>, <code>shell_command</code>, and <code>unified_exec</code>.</p>
               <div class="tag-row">
                 <span class="tag">exec_command</span>
                 <span class="tag">unified_exec</span>
@@ -1125,6 +1125,17 @@
               </div>
             </article>
 
+            <article class="adapter-rule">
+              <h3>OpenCode plugin adapter</h3>
+              <p>Installed as a global local plugin at <code>~/.config/opencode/plugins/eagle-mem.js</code>. It maps OpenCode <code>chat.message</code>, <code>tool.execute.before</code>, <code>tool.execute.after</code>, <code>todo.updated</code>, <code>session.idle</code>, and <code>experimental.session.compacting</code> into Eagle Mem's hook payloads.</p>
+              <div class="tag-row">
+                <span class="tag">chat.message</span>
+                <span class="tag">tool.execute.before</span>
+                <span class="tag">todo.updated</span>
+                <span class="tag">compacting</span>
+              </div>
+            </article>
+
             <article class="adapter-rule">
               <h3>Grok skill/CLI integration</h3>
               <p>Installed through <code>~/.grok/skills</code> and the <code>eagle-mem grok-bootstrap</code> command. Grok can search memory, inspect tasks, coordinate lanes, and check compaction readiness through the same SQLite-backed CLI. Native lifecycle hooks are not assumed yet.</p>
@@ -1301,7 +1312,7 @@
               </tr>
               <tr>
                 <td><code>agent_memories</code>, <code>agent_plans</code>, <code>agent_tasks</code></td>
-                <td>What durable agent artifacts should be shared across Claude Code, Codex, Grok, and Antigravity?</td>
+                <td>What durable agent artifacts should be shared across Claude Code, Codex, OpenCode, Grok, and Antigravity?</td>
                 <td>PostToolUse, SessionEnd, skills, search CLI</td>
               </tr>
               <tr>
@@ -1507,7 +1518,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
 
           <h3>Why lanes matter for all agents</h3>
           <p>
-            Context windows end. Tools fail. A user may switch from Claude Code to Codex, Grok, or Antigravity. A worker may finish while the coordinator is compacted. Lanes make this survivable because the state is outside any one transcript.
+            Context windows end. Tools fail. A user may switch from Claude Code to Codex, OpenCode, Grok, or Antigravity. A worker may finish while the coordinator is compacted. Lanes make this survivable because the state is outside any one transcript.
           </p>
         </div>
       </section>
@@ -1523,7 +1534,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
           <div class="grid-2">
             <article class="principle">
               <h3>1. Stay in the agent's flow</h3>
-              <p>Users already live in Claude Code, Codex, Grok, or Antigravity. Eagle Mem should not require them to open a dashboard before every task. Hooks/skills inject context where the agent already is.</p>
+              <p>Users already live in Claude Code, Codex, OpenCode, Grok, or Antigravity. Eagle Mem should not require them to open a dashboard before every task. Hooks, plugins, and skills inject context where the agent already is.</p>
             </article>
             <article class="principle">
               <h3>2. Show up only when useful</h3>
@@ -1614,7 +1625,7 @@ eagle-mem orchestrate handoff --write docs/handoff-context.md</code></pre>
           <p class="section-number">13 / Tutorial</p>
           <h2>Walkthrough: From Empty Memory To Safer Release</h2>
           <p class="lead">
-            This walkthrough explains how the system feels to a beginner. The same flow works whether the active agent is Claude Code, Codex, Grok, or Antigravity.
+            This walkthrough explains how the system feels to a beginner. The same flow works whether the active agent is Claude Code, Codex, OpenCode, Grok, or Antigravity.
           </p>
 
           <div class="step-list">
@@ -1692,7 +1703,7 @@ eagle-mem install</code></pre>
           <p class="section-number">14 / All-Agent Applicability</p>
           <h2>How To Add Another Agent</h2>
           <p class="lead">
-            The project natively supports Claude Code, Codex, and Google Antigravity with lifecycle hooks, and Grok with skills plus CLI workflows. The architecture should scale to any coding agent that can run local hooks, wrapper scripts, or a skill-like command surface. The integration work should live at the edge, not inside the database model.
+            The project natively supports Claude Code, Codex, OpenCode, and Google Antigravity with lifecycle hooks or plugins, and Grok with skills plus CLI workflows. The architecture should scale to any coding agent that can run local hooks, wrapper scripts, plugins, or a skill-like command surface. The integration work should live at the edge, not inside the database model.
           </p>
 
           <h3>Minimum viable adapter</h3>
@@ -1736,7 +1747,7 @@ eagle-mem install</code></pre>
           <h3>Adapter checklist</h3>
           <ol>
             <li>Register the agent's lifecycle events to call the installed scripts in <code>~/.eagle-mem/hooks/</code>.</li>
-            <li>Set <code>EAGLE_AGENT_SOURCE</code> to a stable value, such as <code>codex</code>, <code>claude-code</code>, <code>grok</code>, <code>antigravity</code>, or a future agent key.</li>
+            <li>Set <code>EAGLE_AGENT_SOURCE</code> to a stable value, such as <code>codex</code>, <code>claude-code</code>, <code>opencode</code>, <code>grok</code>, <code>antigravity</code>, or a future agent key.</li>
             <li>Map the agent's shell and file tools into Eagle Mem's known categories.</li>
             <li>Pass enough JSON to identify <code>session_id</code>, <code>cwd</code>, tool name, tool input, and optional transcript path.</li>
             <li>Teach output formatting for the agent: compact JSON, plain additional context, or deny decisions.</li>
@@ -1782,6 +1793,7 @@ eagle-mem install</code></pre>
               <ul>
                 <li><code>scripts/install.sh</code> - runtime copy, migrations, hook registration, skills, statusline, config.</li>
                 <li><code>lib/codex-hooks.sh</code> - Codex hook enablement and hook registration.</li>
+                <li><code>lib/opencode-hooks.sh</code> and <code>integrations/opencode_eagle_mem_plugin.js</code> - OpenCode plugin and skill registration plus hook normalization.</li>
                 <li><code>lib/hooks.sh</code> - Claude Code hook patching.</li>
               </ul>
             </article>

package/bin/eagle-mem

@@ -22,6 +22,10 @@ case "$command" in
     search)     bash "$SCRIPTS_DIR/search.sh" "$@" ;;
     health)     bash "$SCRIPTS_DIR/health.sh" "$@" ;;
     doctor)     bash "$SCRIPTS_DIR/doctor.sh" "$PACKAGE_DIR" "$@" ;;
+    repair)     bash "$SCRIPTS_DIR/repair.sh" "$@" ;;
+    inspect)    bash "$SCRIPTS_DIR/inspect.sh" "$@" ;;
+    replay)     bash "$SCRIPTS_DIR/replay.sh" "$@" ;;
+    dashboard)  bash "$SCRIPTS_DIR/dashboard.sh" "$@" ;;
     logs)       bash "$SCRIPTS_DIR/logs.sh" "$@" ;;
     config)     bash "$SCRIPTS_DIR/config.sh" "$@" ;;
     updates)    bash "$SCRIPTS_DIR/updates.sh" "$@" ;;

package/db/039_recall_events.sql

@@ -0,0 +1,27 @@
+CREATE TABLE IF NOT EXISTS recall_events (
+    id                      INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id              TEXT,
+    project                 TEXT NOT NULL,
+    cwd                     TEXT,
+    agent                   TEXT,
+    hook_name               TEXT NOT NULL DEFAULT 'UserPromptSubmit',
+    prompt_snippet          TEXT,
+    fts_query               TEXT,
+    summary_matches         INTEGER NOT NULL DEFAULT 0,
+    memory_matches          INTEGER NOT NULL DEFAULT 0,
+    code_matches            INTEGER NOT NULL DEFAULT 0,
+    summary_refs            TEXT NOT NULL DEFAULT '[]',
+    memory_refs             TEXT NOT NULL DEFAULT '[]',
+    code_refs               TEXT NOT NULL DEFAULT '[]',
+    injected_chars          INTEGER NOT NULL DEFAULT 0,
+    injected_token_estimate INTEGER NOT NULL DEFAULT 0,
+    status                  TEXT NOT NULL DEFAULT 'ok',
+    error                   TEXT,
+    created_at              TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_recall_events_project_created
+ON recall_events(project, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_recall_events_session
+ON recall_events(session_id, created_at DESC);

package/db/040_graph_decision_nodes.sql

@@ -0,0 +1,21 @@
+-- Migration 040: Allow durable decision nodes in the project graph.
+-- Decisions are first-class compaction-survival entities captured from summaries.
+
+DROP TRIGGER IF EXISTS val_graph_nodes_insert;
+DROP TRIGGER IF EXISTS val_graph_nodes_update;
+
+CREATE TRIGGER val_graph_nodes_insert BEFORE INSERT ON graph_nodes
+BEGIN
+    SELECT CASE
+        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'decision', 'tag', 'class', 'struct', 'function', 'func', 'fn', 'def')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, decision, tag, class, struct, function, func, fn, def')
+    END;
+END;
+
+CREATE TRIGGER val_graph_nodes_update BEFORE UPDATE OF node_type ON graph_nodes
+BEGIN
+    SELECT CASE
+        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'decision', 'tag', 'class', 'struct', 'function', 'func', 'fn', 'def')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, decision, tag, class, struct, function, func, fn, def')
+    END;
+END;

package/db/041_graph_semantic_edge_types.sql

@@ -0,0 +1,21 @@
+-- Migration 041: Allow semantic project-graph relationships.
+-- These edges connect durable context entities used for compaction survival.
+
+DROP TRIGGER IF EXISTS val_graph_edges_insert;
+DROP TRIGGER IF EXISTS val_graph_edges_update;
+
+CREATE TRIGGER val_graph_edges_insert BEFORE INSERT ON graph_edges
+BEGIN
+    SELECT CASE
+        WHEN NEW.edge_type NOT IN ('imports', 'declares', 'references', 'verifies', 'contains', 'supersedes', 'co_edited', 'modified', 'read', 'covers', 'mentions', 'touches', 'recorded_in', 'originated_in', 'planned_in')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid edge type. Must be one of imports, declares, references, verifies, contains, supersedes, co_edited, modified, read, covers, mentions, touches, recorded_in, originated_in, planned_in')
+    END;
+END;
+
+CREATE TRIGGER val_graph_edges_update BEFORE UPDATE OF edge_type ON graph_edges
+BEGIN
+    SELECT CASE
+        WHEN NEW.edge_type NOT IN ('imports', 'declares', 'references', 'verifies', 'contains', 'supersedes', 'co_edited', 'modified', 'read', 'covers', 'mentions', 'touches', 'recorded_in', 'originated_in', 'planned_in')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid edge type. Must be one of imports, declares, references, verifies, contains, supersedes, co_edited, modified, read, covers, mentions, touches, recorded_in, originated_in, planned_in')
+    END;
+END;

package/db/042_orchestration_auto_events.sql

@@ -0,0 +1,23 @@
+-- Migration 042: Auto-orchestration detection events.
+-- Records when hooks detect broad work and create durable lane/task state.
+
+CREATE TABLE IF NOT EXISTS orchestration_auto_events (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id       TEXT,
+    project          TEXT NOT NULL,
+    cwd              TEXT,
+    agent            TEXT,
+    prompt_snippet   TEXT,
+    trigger          TEXT NOT NULL DEFAULT 'broad_prompt',
+    orchestration_id INTEGER REFERENCES orchestrations(id) ON DELETE SET NULL,
+    orchestration_name TEXT NOT NULL DEFAULT 'auto',
+    lanes            TEXT NOT NULL DEFAULT '[]',
+    status           TEXT NOT NULL DEFAULT 'created',
+    created_at       TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_orchestration_auto_events_project_created
+ON orchestration_auto_events(project, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_orchestration_auto_events_session
+ON orchestration_auto_events(session_id, created_at DESC);

package/db/043_eagle_events.sql

@@ -0,0 +1,22 @@
+CREATE TABLE IF NOT EXISTS eagle_events (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    project         TEXT,
+    session_id      TEXT,
+    agent           TEXT,
+    event_type      TEXT NOT NULL,
+    command         TEXT,
+    hook_event_name TEXT,
+    status          TEXT NOT NULL DEFAULT 'ok',
+    detail_json     TEXT NOT NULL DEFAULT '{}',
+    created_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_eagle_events_project_created
+ON eagle_events(project, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_eagle_events_session_created
+ON eagle_events(session_id, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_eagle_events_type_created
+ON eagle_events(event_type, created_at DESC);
+

package/docs/agent-compatibility/README.md

@@ -0,0 +1,38 @@
+# Agent Compatibility Gate
+
+Eagle Mem depends on external coding-agent lifecycle contracts. Hook, statusline, config, and instruction-file behavior can change independently of this repository, so these integrations must be reverified before they are edited.
+
+## Required Workflow
+
+Before modifying any file that changes Claude Code, Codex, OpenCode, Grok, Antigravity, hook, plugin, statusline, config-installation, or agent-instruction behavior:
+
+1. Read the current official documentation for the affected agent surface.
+2. Update the matching file in `docs/agent-compatibility/` with:
+   - `Last verified: YYYY-MM-DD`
+   - official source URLs
+   - the exact behavior relied on
+   - the Eagle Mem files that depend on that behavior
+   - fixture or golden-test coverage that proves the behavior
+3. Add or update a fixture or regression test for the behavior before editing implementation code.
+4. Prefer additive compatibility changes when older installed users may still depend on the previous behavior.
+5. Do not implement agent hook or statusline changes from memory.
+
+## Sensitive Files
+
+The compatibility gate applies to these file groups:
+
+- `hooks/*.sh`
+- `lib/hooks.sh`
+- `lib/codex-hooks.sh`
+- `lib/opencode-hooks.sh`
+- `integrations/opencode_eagle_mem_plugin.js`
+- `scripts/install.sh`
+- `scripts/update.sh`
+- `scripts/uninstall.sh`
+- `scripts/doctor.sh`
+- `scripts/statusline-em.sh`
+- `lib/common.sh`
+- `AGENTS.md`
+- `CLAUDE.md` when present
+
+The test `tests/test_agent_compatibility_docs_gate.sh` enforces that these docs and fixtures exist. When sensitive files are changed in an uncommitted worktree, the same test also requires a changed compatibility doc or agent-hook fixture in the same diff.

package/docs/agent-compatibility/claude-code.md

@@ -0,0 +1,50 @@
+# Claude Code Compatibility
+
+Last verified: 2026-06-02
+
+## Official Sources
+
+- Hooks reference: https://code.claude.com/docs/en/hooks
+- Statusline reference: https://code.claude.com/docs/en/statusline
+- Settings reference: https://code.claude.com/docs/en/settings
+
+## Behavior Relied On
+
+- Command hooks receive JSON on stdin.
+- `SessionStart` runs when a session begins or resumes.
+- `UserPromptSubmit` runs before Claude processes the user prompt and can add context.
+- `PreToolUse` and `PostToolUse` match tool names such as `Bash`, `Read`, `Edit`, and `Write`.
+- `TaskCreated` and `TaskCompleted` expose durable task fields that can be mirrored into Eagle Mem.
+- `Stop` runs after the main assistant response and exposes the last assistant message.
+- `PreCompact` runs before manual or automatic compaction and receives `trigger` plus `custom_instructions`.
+- `PostCompact` runs after compaction and receives `trigger` plus `compact_summary`.
+- `SessionEnd` runs when a session terminates.
+- The custom statusline is configured with `statusLine` in Claude settings; its command receives JSON on stdin and the first stdout line becomes the visible statusline text.
+
+## Eagle Mem Files Depending On This
+
+- `lib/hooks.sh`
+- `scripts/install.sh`
+- `scripts/update.sh`
+- `scripts/uninstall.sh`
+- `scripts/statusline-em.sh`
+- `hooks/session-start.sh`
+- `hooks/user-prompt-submit.sh`
+- `hooks/pre-tool-use.sh`
+- `hooks/post-tool-use.sh`
+- `hooks/stop.sh`
+- `hooks/session-end.sh`
+
+## Fixtures And Tests
+
+- `tests/fixtures/agent-hooks/claude-user-prompt-submit.json`
+- `tests/fixtures/agent-hooks/claude-statusline.json`
+- `tests/test_agent_compatibility_docs_gate.sh`
+- `tests/test_recall_observability.sh`
+- `tests/test_compaction_survival_matrix.sh`
+- `tests/test_trust_surfaces.sh`
+
+## Reverification Notes
+
+When editing Claude Code hooks, update this file with the new verification date and include the exact hook event names, input fields, and output semantics used by the implementation. When editing brand visibility or statusline behavior, re-read the statusline reference first and update `claude-statusline.json` if the stdin schema changed.
+

package/docs/agent-compatibility/codex.md

@@ -0,0 +1,51 @@
+# Codex Compatibility
+
+Last verified: 2026-06-02
+
+## Official Sources
+
+- Codex manual: https://developers.openai.com/codex/codex-manual.md
+- Hooks reference: https://developers.openai.com/codex/hooks.md
+- AGENTS.md reference: https://developers.openai.com/codex/guides/agents-md.md
+- Advanced config reference: https://developers.openai.com/codex/config-advanced.md
+- Memories reference: https://developers.openai.com/codex/memories.md
+
+## Behavior Relied On
+
+- `AGENTS.md` is the durable repo-instruction surface for Codex. Closer nested files override earlier guidance because Codex concatenates instruction files from the project root down to the current working directory.
+- Codex hooks are discovered from active config layers through `hooks.json` or inline `[hooks]` tables in `config.toml`.
+- `features.hooks` is the canonical feature key. `features.codex_hooks` is a deprecated alias and should not be the primary setting.
+- `SessionStart`, `PreToolUse`, `PostToolUse`, `PreCompact`, `PostCompact`, `UserPromptSubmit`, `SubagentStop`, and `Stop` run at the documented lifecycle scopes.
+- `SessionStart` matchers use `startup`, `resume`, `clear`, and `compact`.
+- `PreToolUse` and `PostToolUse` match tool names, including `Bash`, `apply_patch`, MCP tool names, and aliases such as `Edit` and `Write` for `apply_patch`.
+- `UserPromptSubmit` and `Stop` do not support matchers; configured matchers are ignored for those events.
+- Hook `timeout` is measured in seconds; `statusMessage` is optional.
+- Codex memory files are generated state. Required team guidance belongs in `AGENTS.md` or checked-in documentation, not only in local memories.
+
+## Eagle Mem Files Depending On This
+
+- `lib/codex-hooks.sh`
+- `lib/provider.sh`
+- `scripts/install.sh`
+- `scripts/update.sh`
+- `scripts/uninstall.sh`
+- `hooks/session-start.sh`
+- `hooks/user-prompt-submit.sh`
+- `hooks/pre-tool-use.sh`
+- `hooks/post-tool-use.sh`
+- `hooks/stop.sh`
+- `AGENTS.md`
+
+## Fixtures And Tests
+
+- `tests/fixtures/agent-hooks/codex-user-prompt-submit.json`
+- `tests/fixtures/agent-hooks/codex-pre-tool-use.json`
+- `tests/test_agent_compatibility_docs_gate.sh`
+- `tests/test_codex_hooks_config.sh`
+- `tests/test_auto_orchestration_detection.sh`
+- `tests/test_recall_observability.sh`
+- `tests/test_trust_surfaces.sh`
+
+## Reverification Notes
+
+When editing Codex hooks or install/update behavior, update this file with the new verification date and source URLs. If a future Codex version changes hook feature flags, matcher support, trust review, event names, or input/output schema, update fixtures first and then implementation.