eagle-mem 4.7.0 → 4.8.0

package/README.md

@@ -9,7 +9,7 @@
 
 **Context that survives `/compact`.**
 
-**v4.7.0 adds first-class Codex support and enforced anti-regression checks.**
+**v4.8.0 ships first-class cross-agent orchestration, compact Codex hook recall, enforced anti-regression checks, and configurable RTK token guardrails.**
 Claude Code and Codex can now share the same local Eagle Mem database, while every captured row records which agent created it.
 
 ## The Problem
@@ -48,7 +48,7 @@ That's it. Open Claude Code or Codex in any project directory. Eagle Mem activat
 
 Everything is automatic from here. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors Claude's memories and tasks, learns which commands are noisy, and prunes stale data — all in the background via hooks.
 
-For Codex, the installer enables `codex_hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, and patches `~/.codex/AGENTS.md` with the Eagle Mem summary contract. For Claude Code, it keeps using `~/.claude/settings.json`, `CLAUDE.md`, and the existing Claude memory/task locations.
+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` with the Eagle Mem summary contract. For Claude Code, it keeps using `~/.claude/settings.json`, `CLAUDE.md`, `~/.claude/skills`, and the existing Claude memory/task locations.
 
 ### Prerequisites
 
@@ -70,6 +70,7 @@ Hooks fire automatically at different points in the agent lifecycle:
 | **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 recall is emitted as compact hook JSON, so local Codex sessions get shared memory without the multi-screen hook dumps.
 
 ### Background Automation
 
@@ -85,13 +86,14 @@ These run automatically via SessionStart — no commands needed:
 Eagle Mem actively reduces token consumption:
 
 - **Injection compression** — zero-value stats are elided from the banner, overview is capped, compact reloads get 1 recent session instead of 3
-- **Command rewriting** — PreToolUse rewrites noisy Bash commands to pipe through `head -N` via `updatedInput`. Rules are learned by the curator from real usage, not hardcoded.
+- **Command rewriting** — PreToolUse routes noisy shell output through RTK when available and blocks known raw-output commands in enforce mode when RTK is missing.
 - **Read-after-modify detection** — detects when you read a file that was just edited or written, nudges that the diff is already in context
 - **Read dedup tracking** — files read 3+ times in a session get a soft nudge
 - **Co-edit nudges** — learned from observation data: when you edit file X, PreToolUse reminds you that you usually also touch file Y
 - **Hot file awareness** — curator identifies files read in 50%+ of sessions; SessionStart flags them as "likely in context" to reduce re-reads
 - **Working set recovery** — on compact, SessionStart injects the files you were actively editing so you resume without re-reading everything
 - **Stuck loop detection** — if the same file is edited 5+ times in one session, PreToolUse nudges to reconsider the approach
+- **RTK token guard** — optional `rtk` integration can rewrite or block noisy shell commands before raw output enters Claude Code or Codex context. Configure with `eagle-mem config set token_guard.rtk auto|off|enforce`.
 
 ### Anti-Regression
 
@@ -103,6 +105,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 by Claude Code and Codex
 
 ## Commands
 
@@ -113,11 +116,12 @@ Eagle Mem prevents Claude from repeating past mistakes:
 | `eagle-mem uninstall` | Remove hooks and optionally delete data |
 | `eagle-mem search` | Search past sessions, memories, and code |
 | `eagle-mem health` | Diagnose pipeline health and background automation |
-| `eagle-mem config` | View or change LLM provider settings |
+| `eagle-mem config` | View or change LLM provider and token-guard settings |
 | `eagle-mem guard` | Manage regression guardrails for files |
 | `eagle-mem overview` | Build or view project overview |
-| `eagle-mem memories` | View/sync Claude Code memories |
+| `eagle-mem memories` | View/sync agent memories |
 | `eagle-mem tasks` | View mirrored tasks |
+| `eagle-mem orchestrate` | Coordinate durable worker lanes across agents |
 | `eagle-mem curate` | Run curator (co-edits, hot files, guardrails) |
 | `eagle-mem feature` | Track and verify features |
 | `eagle-mem prune` | Clean old sessions and stale data |
@@ -130,7 +134,7 @@ Eagle Mem prevents Claude from repeating past mistakes:
 eagle-mem search "auth bug"        # keyword search across summaries
 eagle-mem search --timeline        # recent sessions in chronological order
 eagle-mem search --overview        # project overview
-eagle-mem search --memories        # mirrored Claude Code memories
+eagle-mem search --memories        # mirrored agent memories
 eagle-mem search --tasks           # in-flight tasks (pending/in-progress)
 eagle-mem search --files           # most frequently modified files
 eagle-mem search --stats           # project statistics
@@ -149,6 +153,32 @@ Verification is tied to the current git diff fingerprint. If the same diff was a
 
 Dry-run validation stays unblocked. For example, `gh pr create --dry-run` and `npm publish --dry-run` are treated as validation. Explicit real commands such as `npm publish --dry-run=false` are treated as release boundaries and will enforce pending feature verification.
 
+### 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.
+
+By default Eagle Mem uses the opposite-agent worker model:
+
+- Codex coordinator -> Claude Code worker using `claude-opus-4-7` at `xhigh`
+- Claude Code coordinator -> Codex worker using `gpt-5.5` at `xhigh`
+
+Worker models, effort, route, and worktree behavior are configurable in `~/.eagle-mem/config.toml` under `[orchestration]`.
+
+```bash
+eagle-mem orchestrate init "Ship auth cleanup"
+eagle-mem orchestrate lane add api --agent codex --desc "API fixes + tests" --validate "npm test"
+eagle-mem orchestrate lane add docs --agent claude-code --desc "README and release notes"
+eagle-mem orchestrate spawn api
+eagle-mem orchestrate sync
+eagle-mem orchestrate complete
+eagle-mem orchestrate handoff --write docs/handoff-context.md
+```
+
+`spawn` creates a git worktree, writes a self-contained worker prompt, launches the selected worker CLI, captures its log/exit status under `~/.eagle-mem/orchestrations/`, and updates lane/task state when the worker finishes. Worker hooks export the original Eagle Mem project name, so observations and summaries created inside worktrees still attach to the main project memory.
+Use `lane complete` or `lane block` manually only when work happened outside the wrapper or the worker needs an explicit correction.
+
+Each lane is stored in `orchestration_lanes` and mirrored into `agent_tasks`, so the next Claude Code or Codex session sees what is pending, who owns it, which worktree/log belongs to it, and how to validate it.
+
 ### Shared Claude Code + Codex Memory
 
 Both agents write to `~/.eagle-mem/memory.db`:
@@ -160,14 +190,15 @@ Both agents write to `~/.eagle-mem/memory.db`:
 
 That means opening the same project in Claude Code and Codex does not create two isolated memory worlds. They recall the same project history while preserving the source of each memory.
 
-## Skills (Inside Claude Code)
+## Skills (Inside Claude Code and Codex)
 
 | Skill | What It Does |
 |-------|-------------|
 | `/eagle-mem-search` | Search memory and past sessions — Claude interprets results in context |
 | `/eagle-mem-overview` | Build a rich project briefing from README, entry points, and git history |
-| `/eagle-mem-memories` | View and search mirrored Claude Code memories and plans |
+| `/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 and Codex |
 
 ## Data
 
@@ -188,10 +219,12 @@ Single SQLite database at `~/.eagle-mem/memory.db` (WAL mode, FTS5 full-text sea
 | `feature_dependencies` | Inter-feature dependency relationships |
 | `feature_smoke_tests` | Smoke test definitions for feature verification |
 | `pending_feature_verifications` | Release blockers created when files tied to features change |
+| `orchestrations` | Durable multi-agent work plans per project |
+| `orchestration_lanes` | Worker lane ownership, status, validation, worktree, and notes |
 | `eagle_meta` | Internal metadata (last scan, last curate, etc.) |
-| `claude_memories` | Mirror of Claude Code auto-memories |
-| `claude_plans` | Mirror of Claude Code plans |
-| `claude_tasks` | Mirror of Claude Code tasks |
+| `agent_memories` | Mirror of agent memory files, with source attribution |
+| `agent_plans` | Mirror of agent plan files, with source attribution |
+| `agent_tasks` | Mirror of agent task records, with source attribution |
 
 ### Project Identity
 
@@ -207,9 +240,20 @@ Some features (curator auto-enrichment, overview generation) can use an LLM for
 
 ```bash
 eagle-mem config
+eagle-mem config set provider.type agent_cli
+eagle-mem config set agent_cli.preferred current
 ```
 
-Supported providers: Ollama (auto-detected), Anthropic, OpenAI. Eagle Mem works fully without a provider — LLM features gracefully degrade to heuristic fallbacks.
+Provider preference is local-first: Ollama is auto-detected when running, then Eagle Mem can use the installed Codex/Claude CLI via `agent_cli` before falling back to explicit Anthropic/OpenAI API providers. Eagle Mem works fully without a provider — LLM features gracefully degrade to heuristic fallbacks.
+
+RTK is configured separately from the LLM provider:
+
+```bash
+eagle-mem config set token_guard.rtk auto      # default: use RTK when available
+eagle-mem config set token_guard.rtk enforce   # block known raw-output commands if RTK is missing
+eagle-mem config set token_guard.rtk off       # disable RTK behavior
+eagle-mem config set token_guard.raw_bash block
+```
 
 ## License
 

package/bin/eagle-mem

@@ -26,6 +26,7 @@ case "$command" in
     overview)   bash "$SCRIPTS_DIR/overview.sh" "$@" ;;
     memories)   bash "$SCRIPTS_DIR/memories.sh" "$@" ;;
     tasks)      bash "$SCRIPTS_DIR/tasks.sh" "$@" ;;
+    orchestrate) bash "$SCRIPTS_DIR/orchestrate.sh" "$@" ;;
     curate)     bash "$SCRIPTS_DIR/curate.sh" "$@" ;;
     feature)    bash "$SCRIPTS_DIR/feature.sh" "$@" ;;
     prune)      bash "$SCRIPTS_DIR/prune.sh" "$@" ;;

package/db/028_agent_artifact_tables.sql

@@ -0,0 +1,124 @@
+-- Migration 028: Promote mirrored artifact tables from Claude-specific names
+-- to agent-generic names. The original names were correct when Eagle Mem only
+-- mirrored Claude Code artifacts; Codex support made the stored data model
+-- multi-agent. Keep read-only legacy views so older ad-hoc SELECT queries do
+-- not break immediately.
+
+DROP TRIGGER IF EXISTS claude_memories_ai;
+DROP TRIGGER IF EXISTS claude_memories_ad;
+DROP TRIGGER IF EXISTS claude_memories_au;
+DROP TRIGGER IF EXISTS claude_plans_ai;
+DROP TRIGGER IF EXISTS claude_plans_ad;
+DROP TRIGGER IF EXISTS claude_plans_au;
+DROP TRIGGER IF EXISTS claude_tasks_ai;
+DROP TRIGGER IF EXISTS claude_tasks_ad;
+DROP TRIGGER IF EXISTS claude_tasks_au;
+
+DROP TABLE IF EXISTS claude_memories_fts;
+DROP TABLE IF EXISTS claude_plans_fts;
+DROP TABLE IF EXISTS claude_tasks_fts;
+
+ALTER TABLE claude_memories RENAME TO agent_memories;
+ALTER TABLE claude_plans RENAME TO agent_plans;
+ALTER TABLE claude_tasks RENAME TO agent_tasks;
+
+DROP INDEX IF EXISTS idx_claude_memories_project;
+DROP INDEX IF EXISTS idx_claude_memories_type;
+DROP INDEX IF EXISTS idx_claude_memories_origin_agent;
+DROP INDEX IF EXISTS idx_claude_plans_project;
+DROP INDEX IF EXISTS idx_claude_plans_origin_agent;
+DROP INDEX IF EXISTS idx_claude_tasks_project;
+DROP INDEX IF EXISTS idx_claude_tasks_session;
+DROP INDEX IF EXISTS idx_claude_tasks_status;
+DROP INDEX IF EXISTS idx_claude_tasks_origin_agent;
+
+CREATE INDEX IF NOT EXISTS idx_agent_memories_project ON agent_memories(project);
+CREATE INDEX IF NOT EXISTS idx_agent_memories_type ON agent_memories(memory_type);
+CREATE INDEX IF NOT EXISTS idx_agent_memories_origin_agent ON agent_memories(origin_agent);
+CREATE INDEX IF NOT EXISTS idx_agent_plans_project ON agent_plans(project);
+CREATE INDEX IF NOT EXISTS idx_agent_plans_origin_agent ON agent_plans(origin_agent);
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_project ON agent_tasks(project);
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_session ON agent_tasks(source_session_id);
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_status ON agent_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_origin_agent ON agent_tasks(origin_agent);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS agent_memories_fts USING fts5(
+    memory_name,
+    description,
+    content,
+    content='agent_memories',
+    content_rowid='id'
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS agent_plans_fts USING fts5(
+    title,
+    content,
+    content='agent_plans',
+    content_rowid='id'
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS agent_tasks_fts USING fts5(
+    subject,
+    description,
+    content='agent_tasks',
+    content_rowid='id'
+);
+
+INSERT INTO agent_memories_fts(agent_memories_fts) VALUES('rebuild');
+INSERT INTO agent_plans_fts(agent_plans_fts) VALUES('rebuild');
+INSERT INTO agent_tasks_fts(agent_tasks_fts) VALUES('rebuild');
+
+CREATE TRIGGER IF NOT EXISTS agent_memories_ai AFTER INSERT ON agent_memories BEGIN
+    INSERT INTO agent_memories_fts(rowid, memory_name, description, content)
+    VALUES (new.id, new.memory_name, new.description, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_memories_ad AFTER DELETE ON agent_memories BEGIN
+    INSERT INTO agent_memories_fts(agent_memories_fts, rowid, memory_name, description, content)
+    VALUES ('delete', old.id, old.memory_name, old.description, old.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_memories_au AFTER UPDATE ON agent_memories BEGIN
+    INSERT INTO agent_memories_fts(agent_memories_fts, rowid, memory_name, description, content)
+    VALUES ('delete', old.id, old.memory_name, old.description, old.content);
+    INSERT INTO agent_memories_fts(rowid, memory_name, description, content)
+    VALUES (new.id, new.memory_name, new.description, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_plans_ai AFTER INSERT ON agent_plans BEGIN
+    INSERT INTO agent_plans_fts(rowid, title, content)
+    VALUES (new.id, new.title, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_plans_ad AFTER DELETE ON agent_plans BEGIN
+    INSERT INTO agent_plans_fts(agent_plans_fts, rowid, title, content)
+    VALUES ('delete', old.id, old.title, old.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_plans_au AFTER UPDATE ON agent_plans BEGIN
+    INSERT INTO agent_plans_fts(agent_plans_fts, rowid, title, content)
+    VALUES ('delete', old.id, old.title, old.content);
+    INSERT INTO agent_plans_fts(rowid, title, content)
+    VALUES (new.id, new.title, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_tasks_ai AFTER INSERT ON agent_tasks BEGIN
+    INSERT INTO agent_tasks_fts(rowid, subject, description)
+    VALUES (new.id, new.subject, new.description);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_tasks_ad AFTER DELETE ON agent_tasks BEGIN
+    INSERT INTO agent_tasks_fts(agent_tasks_fts, rowid, subject, description)
+    VALUES ('delete', old.id, old.subject, old.description);
+END;
+
+CREATE TRIGGER IF NOT EXISTS agent_tasks_au AFTER UPDATE ON agent_tasks BEGIN
+    INSERT INTO agent_tasks_fts(agent_tasks_fts, rowid, subject, description)
+    VALUES ('delete', old.id, old.subject, old.description);
+    INSERT INTO agent_tasks_fts(rowid, subject, description)
+    VALUES (new.id, new.subject, new.description);
+END;
+
+CREATE VIEW IF NOT EXISTS claude_memories AS SELECT * FROM agent_memories;
+CREATE VIEW IF NOT EXISTS claude_plans AS SELECT * FROM agent_plans;
+CREATE VIEW IF NOT EXISTS claude_tasks AS SELECT * FROM agent_tasks;

package/db/029_orchestration_lanes.sql

@@ -0,0 +1,45 @@
+-- Migration 029: Orchestrator/worker lane tracking.
+-- Stores durable multi-agent work plans so Claude Code and Codex can share
+-- lane ownership, status, validation commands, and handoff context.
+
+CREATE TABLE IF NOT EXISTS orchestrations (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    project      TEXT NOT NULL,
+    name         TEXT NOT NULL,
+    goal         TEXT,
+    status       TEXT NOT NULL DEFAULT 'active'
+                 CHECK (status IN ('active', 'completed', 'cancelled')),
+    baseline_ref TEXT,
+    created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE(project, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_orchestrations_project_status
+    ON orchestrations(project, status);
+
+CREATE TABLE IF NOT EXISTS orchestration_lanes (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    orchestration_id INTEGER NOT NULL REFERENCES orchestrations(id) ON DELETE CASCADE,
+    project          TEXT NOT NULL,
+    lane_key         TEXT NOT NULL,
+    title            TEXT NOT NULL,
+    description      TEXT,
+    agent            TEXT NOT NULL DEFAULT 'codex',
+    worktree_path    TEXT,
+    validation       TEXT,
+    status           TEXT NOT NULL DEFAULT 'pending'
+                     CHECK (status IN ('pending', 'in_progress', 'blocked', 'completed', 'cancelled')),
+    source_task_id   TEXT,
+    notes            TEXT,
+    created_at       TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at       TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE(orchestration_id, lane_key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_orchestration
+    ON orchestration_lanes(orchestration_id);
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_project_status
+    ON orchestration_lanes(project, status);
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_agent
+    ON orchestration_lanes(agent);

package/db/030_orchestration_lane_scope.sql

@@ -0,0 +1,88 @@
+-- Migration 030: Scope orchestration lane identity to each orchestration.
+-- Early 029 builds made lane_key unique per project, which allowed a lane
+-- named "api" in one named orchestration to overwrite the same key in another.
+
+DROP INDEX IF EXISTS idx_orchestration_lanes_orchestration;
+DROP INDEX IF EXISTS idx_orchestration_lanes_project_status;
+DROP INDEX IF EXISTS idx_orchestration_lanes_agent;
+
+CREATE TABLE IF NOT EXISTS orchestration_lanes_new (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    orchestration_id INTEGER NOT NULL REFERENCES orchestrations(id) ON DELETE CASCADE,
+    project          TEXT NOT NULL,
+    lane_key         TEXT NOT NULL,
+    title            TEXT NOT NULL,
+    description      TEXT,
+    agent            TEXT NOT NULL DEFAULT 'codex',
+    worktree_path    TEXT,
+    validation       TEXT,
+    status           TEXT NOT NULL DEFAULT 'pending'
+                     CHECK (status IN ('pending', 'in_progress', 'blocked', 'completed', 'cancelled')),
+    source_task_id   TEXT,
+    notes            TEXT,
+    created_at       TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at       TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE(orchestration_id, lane_key)
+);
+
+INSERT OR IGNORE INTO orchestration_lanes_new (
+    id, orchestration_id, project, lane_key, title, description, agent,
+    worktree_path, validation, status, source_task_id, notes, created_at, updated_at
+)
+SELECT
+    id, orchestration_id, project, lane_key, title, description, agent,
+    worktree_path, validation, status, source_task_id, notes, created_at, updated_at
+FROM orchestration_lanes;
+
+DROP TABLE orchestration_lanes;
+ALTER TABLE orchestration_lanes_new RENAME TO orchestration_lanes;
+
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_orchestration
+    ON orchestration_lanes(orchestration_id);
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_project_status
+    ON orchestration_lanes(project, status);
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_agent
+    ON orchestration_lanes(agent);
+
+UPDATE orchestration_lanes
+SET source_task_id = 'lane-' || (
+        SELECT name FROM orchestrations WHERE orchestrations.id = orchestration_lanes.orchestration_id
+    ) || '-' || lane_key
+WHERE source_task_id IS NULL
+   OR source_task_id = ''
+   OR source_task_id = 'lane-' || lane_key;
+
+UPDATE agent_tasks
+SET source_task_id = (
+        SELECT l.source_task_id
+        FROM orchestration_lanes l
+        JOIN orchestrations o ON o.id = l.orchestration_id
+        WHERE l.project = agent_tasks.project
+          AND (
+              agent_tasks.file_path = 'orchestration-lane://' || l.project || '/' || l.lane_key
+              OR agent_tasks.file_path = 'orchestration-lane://' || l.project || '/' || o.name || '/' || l.lane_key
+          )
+        LIMIT 1
+    ),
+    file_path = (
+        SELECT 'orchestration-lane://' || l.project || '/' || o.name || '/' || l.lane_key
+        FROM orchestration_lanes l
+        JOIN orchestrations o ON o.id = l.orchestration_id
+        WHERE l.project = agent_tasks.project
+          AND (
+              agent_tasks.file_path = 'orchestration-lane://' || l.project || '/' || l.lane_key
+              OR agent_tasks.file_path = 'orchestration-lane://' || l.project || '/' || o.name || '/' || l.lane_key
+          )
+        LIMIT 1
+    )
+WHERE source_session_id = 'orchestration'
+  AND EXISTS (
+      SELECT 1
+      FROM orchestration_lanes l
+      JOIN orchestrations o ON o.id = l.orchestration_id
+      WHERE l.project = agent_tasks.project
+        AND (
+            agent_tasks.file_path = 'orchestration-lane://' || l.project || '/' || l.lane_key
+            OR agent_tasks.file_path = 'orchestration-lane://' || l.project || '/' || o.name || '/' || l.lane_key
+        )
+  );

package/db/031_orchestration_workers.sql

@@ -0,0 +1,20 @@
+-- Migration 031: Worker execution metadata for orchestration lanes.
+-- Keeps worker routing, worktree, process, and log state durable so Claude Code
+-- and Codex can hand off lane execution safely.
+
+ALTER TABLE orchestration_lanes ADD COLUMN branch_name TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_agent TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_model TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_effort TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_pid INTEGER;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_log_path TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_exit_path TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_prompt_path TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_command TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_started_at TEXT;
+ALTER TABLE orchestration_lanes ADD COLUMN worker_finished_at TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_worker_pid
+    ON orchestration_lanes(worker_pid);
+CREATE INDEX IF NOT EXISTS idx_orchestration_lanes_branch
+    ON orchestration_lanes(branch_name);

package/db/032_orchestration_run_keys.sql

@@ -0,0 +1,9 @@
+-- Migration 032: Stable run identity for reusable orchestration names.
+-- A project may reuse the default orchestration name ("main") for multiple
+-- goals, so worker branches and worktrees need a per-run key.
+
+ALTER TABLE orchestrations ADD COLUMN run_key TEXT;
+
+UPDATE orchestrations
+SET run_key = 'r' || id
+WHERE run_key IS NULL OR run_key = '';

package/hooks/post-tool-use.sh

@@ -5,6 +5,7 @@
 # Captures observations + dispatches to extracted responsibilities
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -54,7 +55,7 @@ case "$hook_event" in
             agent_sql=$(eagle_sql_escape "$agent")
 
             eagle_db_pipe <<SQL
-INSERT INTO claude_tasks (project, source_session_id, source_task_id, file_path, subject, description, status, origin_agent)
+INSERT INTO agent_tasks (project, source_session_id, source_task_id, file_path, subject, description, status, origin_agent)
 VALUES ('$proj_sql', '$sid_sql', '$tid_sql', '$fp_sql', '$subj_sql', '$desc_sql', '$stat_sql', '$agent_sql')
 ON CONFLICT(file_path) DO UPDATE SET
     subject     = excluded.subject,

package/hooks/pre-tool-use.sh

@@ -10,6 +10,7 @@
 # 6. Stuck loop detection (repeated edits to same file)
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -90,9 +91,11 @@ Pending checks:"
 
     # ─── RTK command rewrite / enforcement ─────────────────
 
+    rtk_mode=$(eagle_token_guard_rtk_mode)
+    raw_bash_mode=$(eagle_token_guard_raw_bash_mode)
     rtk_cmd=$(eagle_rtk_rewrite_command "$cmd")
     if [ -n "$rtk_cmd" ]; then
-        if [ "$agent" = "codex" ] && ! eagle_raw_bash_unlock_active; then
+        if [ "$agent" = "codex" ] && [ "$raw_bash_mode" != "allow" ] && ! eagle_raw_bash_unlock_active; then
             reason="Eagle Mem token guard blocked raw shell output.
 
 Use RTK so large output is compact before it enters context:
@@ -116,6 +119,27 @@ Temporary escape hatch for one-off raw output:
             updated_input=$(echo "$input" | jq --arg cmd "$rtk_cmd" '.tool_input + {"command":$cmd}')
             context+="Eagle Mem token guard: rewrote raw shell command through RTK to reduce context load: ${rtk_cmd}. "
         fi
+    elif [ "$rtk_mode" = "enforce" ] && ! command -v rtk >/dev/null 2>&1 && eagle_raw_output_command_needs_guard "$cmd" && ! eagle_raw_bash_unlock_active; then
+        reason="Eagle Mem token guard is set to enforce, but RTK is not installed or not on PATH.
+
+This command can dump raw output into agent context:
+  $cmd
+
+Install RTK or disable enforcement:
+  eagle-mem config set token_guard.rtk auto
+
+Temporary escape hatch:
+  touch $EAGLE_RAW_BASH_UNLOCK"
+        jq -nc --arg reason "$reason" '{
+            "decision":"block",
+            "reason":$reason,
+            "hookSpecificOutput":{
+                "hookEventName":"PreToolUse",
+                "permissionDecision":"deny",
+                "permissionDecisionReason":$reason
+            }
+        }'
+        exit 0
     fi
 
     # ─── Feature verification context for non-blocked pushes ───

package/hooks/session-end.sh

@@ -5,6 +5,7 @@
 # Marks the session as completed
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -31,7 +32,7 @@ if eagle_validate_session_id "$session_id"; then
     if [ -d "$task_dir" ]; then
         for task_file in "$task_dir"/*.json; do
             [ ! -f "$task_file" ] && continue
-            eagle_capture_claude_task "$task_file" "$session_id" "$project" "$agent"
+            eagle_capture_agent_task "$task_file" "$session_id" "$project" "$agent"
         done
         eagle_log "INFO" "SessionEnd: re-synced tasks from $task_dir"
     fi