eagle-mem 4.7.1 → 4.8.1

package/README.md

@@ -1,16 +1,29 @@
 ```
 ======================================
        Eagle Mem
-  context that survives /compact
+ shared memory | guardrails | lanes
 ======================================
 ```
 
 # Eagle Mem
 
-**Context that survives `/compact`.**
+**Shared memory, release guardrails, and worker lanes for Claude Code and Codex.**
 
-**v4.7.1 hardens first-class Codex support and enforced anti-regression checks.**
-Claude Code and Codex can now share the same local Eagle Mem database, while every captured row records which agent created it.
+Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code and Codex the same local memory, 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.8.1 ships the communication refresh for the new architecture:** cross-agent orchestration, compact Codex hook recall, enforced anti-regression checks, configurable RTK token guardrails, and a memory-sync fix for large memory files.
+
+**Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
+[Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |
+[About](https://eagleisbatman.github.io/eagle-mem/about.html)
+
+## Why People Install It
+
+- **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** - Codex and Claude Code 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
 
@@ -18,9 +31,17 @@ Claude Code and Codex start every session with amnesia. They don't remember what
 
 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.
 
-## The Solution
+## The Product
+
+Eagle Mem is a local runtime layer for AI coding agents. It adds three things that ordinary agent sessions do not have by default:
+
+| Layer | What users feel | What Eagle Mem does |
+|-------|-----------------|---------------------|
+| **Recall** | "The agent remembers this repo." | Loads project overviews, summaries, decisions, memories, tasks, plans, and relevant indexed code. |
+| **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. |
 
-Eagle Mem is a recall and regression-control layer for Claude Code and Codex. Every session starts with context from previous sessions — summaries, decisions, memories, tasks, project overviews, and relevant code — injected automatically via hooks. Both agents share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code` or `Codex`.
+Both agents share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code` or `Codex`.
 
 **Zero per-instance overhead.** No daemon, no vector DB, no MCP server. Just bash scripts, sqlite3 (WAL mode, FTS5 full-text search), and jq.
 
@@ -70,6 +91,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 +107,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 +126,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,17 +137,22 @@ 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 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 |
 | `eagle-mem scan` | Scan codebase and generate overview |
 | `eagle-mem index` | Index source files for FTS5 code search |
 
+### v4.8.1 Patch
+
+`eagle-mem memories sync` is now safe on large Claude Code/Codex memory files. The memory mirror parser no longer uses early-exit pipelines under `pipefail`, avoiding exit `141` during sync.
+
 ### Search Modes
 
 ```bash
@@ -149,6 +178,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,7 +215,7 @@ 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 |
 |-------|-------------|
@@ -168,6 +223,7 @@ That means opening the same project in Claude Code and Codex does not create two
 | `/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 and Codex |
 
 ## Data
 
@@ -188,6 +244,8 @@ 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.) |
 | `agent_memories` | Mirror of agent memory files, with source attribution |
 | `agent_plans` | Mirror of agent plan files, with source attribution |
@@ -213,6 +271,15 @@ eagle-mem config set agent_cli.preferred current
 
 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
 
 MIT

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/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/pre-tool-use.sh

@@ -91,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:
@@ -117,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-start.sh

@@ -27,6 +27,8 @@ source_type=$(echo "$input" | jq -r '.source // empty')
 model=$(echo "$input" | jq -r '.model // empty')
 agent=$(eagle_agent_source_from_json "$input")
 agent_label=$(eagle_agent_label "$agent")
+codex_compact=0
+[ "$agent" = "codex" ] && codex_compact=1
 
 [ -z "$session_id" ] && exit 0
 
@@ -131,8 +133,7 @@ if [ "$stat_tasks_done" -gt 0 ]; then
     task_parts+="${stat_tasks_done} completed"
 fi
 
-stat_last_display="${stat_last_summary:0:60}"
-[ ${#stat_last_summary} -gt 60 ] && stat_last_display+="..."
+stat_last_display=$(eagle_trim_text "$stat_last_summary" 60)
 
 eagle_banner="======================================
        Eagle Mem Recall Ready
@@ -178,9 +179,9 @@ fi
 
 overview=$(eagle_get_overview "$project")
 if [ -n "$overview" ]; then
-    if [ ${#overview} -gt 500 ]; then
-        overview="${overview:0:497}..."
-    fi
+    overview_limit=500
+    [ "$codex_compact" -eq 1 ] && overview_limit=320
+    overview=$(eagle_trim_text "$overview" "$overview_limit")
     context+="
 === Eagle Mem: Project Overview ===
 $overview
@@ -196,8 +197,10 @@ fi
 
 if [ "$source_type" = "compact" ] || [ "$source_type" = "clear" ]; then
     _summary_limit=1
+elif [ "$codex_compact" -eq 1 ]; then
+    _summary_limit=1
 else
-    _summary_limit=3
+    _summary_limit=2
 fi
 
 recent=$(eagle_get_recent_summaries "$project" "$_summary_limit")
@@ -209,6 +212,21 @@ if [ -n "$recent" ]; then
     while IFS='|' read -r request completed learned next_steps created_at decisions gotchas key_files summary_agent; do
         [ -z "$request" ] && [ -z "$completed" ] && continue
         summary_agent_label=$(eagle_agent_label "$summary_agent")
+        request=$(eagle_trim_text "$request" 160)
+        completed=$(eagle_trim_text "$completed" 220)
+        learned=$(eagle_trim_text "$learned" 180)
+        decisions=$(eagle_trim_text "$decisions" 160)
+        gotchas=$(eagle_trim_text "$gotchas" 160)
+        key_files=$(eagle_trim_text "$key_files" 160)
+        next_steps=$(eagle_trim_text "$next_steps" 160)
+        if [ "$codex_compact" -eq 1 ]; then
+            request=$(eagle_trim_text "$request" 120)
+            completed=$(eagle_trim_text "$completed" 160)
+            learned=$(eagle_trim_text "$learned" 120)
+            decisions=""
+            key_files=""
+            next_steps=""
+        fi
         context+="
 --- $created_at ---"
         [ -n "$summary_agent" ] && context+="
@@ -234,12 +252,14 @@ fi
 
 # ─── Memories (skip if none) ─────────────────────────────
 
+memory_limit=3
+[ "$codex_compact" -eq 1 ] && memory_limit=2
 memories=$(eagle_db "SELECT memory_name, memory_type, description, file_path, updated_at, origin_agent,
     CAST(julianday('now') - julianday(updated_at) AS INTEGER) as days_ago
     FROM agent_memories
     WHERE project = '$p_esc'
     ORDER BY updated_at DESC
-    LIMIT 5;")
+    LIMIT $memory_limit;")
 if [ -n "$memories" ]; then
     context+="
 === Eagle Mem: Stored Memories ===
@@ -247,6 +267,7 @@ if [ -n "$memories" ]; then
     while IFS='|' read -r mname mtype mdesc _fpath _updated morigin days_ago; do
         [ -z "$mname" ] && continue
         origin_label=$(eagle_agent_label "$morigin")
+        mdesc=$(eagle_trim_text "$mdesc" 180)
         age_label=""
         if [ -n "$days_ago" ] && [ "$days_ago" -gt 0 ] 2>/dev/null; then
             if [ "$days_ago" -eq 1 ]; then
@@ -279,14 +300,17 @@ fi
 
 # ─── Tasks (skip if none) ────────────────────────────────
 
+task_limit=5
+[ "$codex_compact" -eq 1 ] && task_limit=3
 synced_tasks=$(eagle_db "SELECT subject, status, blocked_by, origin_agent FROM agent_tasks
     WHERE project = '$p_esc'
     AND status IN ('in_progress', 'pending')
+    AND source_session_id != 'orchestration'
     AND updated_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-7 days')
     ORDER BY
         CASE status WHEN 'in_progress' THEN 0 ELSE 1 END,
         updated_at DESC
-    LIMIT 10;")
+    LIMIT $task_limit;")
 if [ -n "$synced_tasks" ]; then
     context+="
 === Eagle Mem: Tasks ===
@@ -303,10 +327,54 @@ if [ -n "$synced_tasks" ]; then
     done <<< "$synced_tasks"
 fi
 
+# ─── Orchestration lanes (skip if none) ───────────────────
+
+lane_limit=8
+[ "$codex_compact" -eq 1 ] && lane_limit=4
+orchestration_lanes=$(eagle_db "SELECT o.name, o.goal, l.lane_key, l.title,
+        COALESCE(REPLACE(REPLACE(l.description, char(10), ' '), '|', '/'), ''),
+        l.agent, l.status, l.validation, l.worktree_path, l.notes
+    FROM orchestration_lanes l
+    JOIN orchestrations o ON o.id = l.orchestration_id
+    WHERE l.project = '$p_esc'
+      AND o.status = 'active'
+      AND l.status IN ('in_progress', 'pending', 'blocked')
+    ORDER BY
+        CASE l.status WHEN 'in_progress' THEN 0 WHEN 'blocked' THEN 1 ELSE 2 END,
+        l.updated_at DESC
+    LIMIT $lane_limit;" 2>/dev/null)
+if [ -n "$orchestration_lanes" ]; then
+    context+="
+=== Eagle Mem: Orchestration Lanes ===
+"
+    while IFS='|' read -r oname ogoal lkey ltitle ldesc lagent lstatus lvalidation lworktree lnotes; do
+        [ -z "$lkey" ] && continue
+        origin_label=$(eagle_agent_label "$lagent")
+        context+="  - [$lstatus][$origin_label] $lkey: $ltitle"
+        if [ -n "$ldesc" ]; then
+            desc_limit=220
+            [ "$codex_compact" -eq 1 ] && desc_limit=120
+            context+=" | scope: $(eagle_trim_text "$ldesc" "$desc_limit")"
+        fi
+        [ -n "$oname" ] && context+=" | plan: $oname"
+        [ -n "$lvalidation" ] && context+=" | validate: $lvalidation"
+        [ -n "$lworktree" ] && context+=" | worktree: $lworktree"
+        [ -n "$lnotes" ] && context+=" | notes: $lnotes"
+        context+="
+"
+    done <<< "$orchestration_lanes"
+    context+="You, the active agent, must run 'eagle-mem orchestrate' before taking lane work. Do not ask the user to run these commands. Update lane status when work starts, blocks, or completes.
+"
+fi
+
 # ─── Pending feature verifications ───────────────────────
 
-pending_features=$(eagle_list_pending_feature_verifications "$project" 10 2>/dev/null)
+pending_limit=5
+[ "$codex_compact" -eq 1 ] && pending_limit=3
+pending_features=$(eagle_list_pending_feature_verifications "$project" "$pending_limit" 2>/dev/null)
 if [ -n "$pending_features" ]; then
+    pending_total=$(eagle_db "SELECT COUNT(*) FROM pending_feature_verifications WHERE project = '$p_esc' AND status = 'pending';" 2>/dev/null)
+    pending_total=${pending_total:-0}
     context+="
 === Eagle Mem: Pending Feature Verification ===
 Release-boundary commands are blocked until these are verified or waived.
@@ -321,6 +389,10 @@ Release-boundary commands are blocked until these are verified or waived.
         context+="
 "
     done <<< "$pending_features"
+    if [ "$pending_total" -gt "$pending_limit" ] 2>/dev/null; then
+        context+="  - ... $((pending_total - pending_limit)) more pending; run: eagle-mem feature pending
+"
+    fi
     context+="Resolve with: eagle-mem feature verify <name> --notes \"what passed\"; or eagle-mem feature waive <id> --reason \"why safe\".
 "
 fi
@@ -334,9 +406,14 @@ if [ -n "$hot_files" ]; then
 Frequently read — re-read sparingly if unchanged.
 "
     IFS=',' read -ra hf_arr <<< "$hot_files"
+    hf_count=0
+    hot_file_limit=8
+    [ "$codex_compact" -eq 1 ] && hot_file_limit=5
     for hf in "${hf_arr[@]}"; do
+        [ "$hf_count" -ge "$hot_file_limit" ] && break
         [ -n "$hf" ] && context+="  - $(basename "$hf")
 "
+        hf_count=$((hf_count + 1))
     done
 fi
 
@@ -359,7 +436,12 @@ fi
 
 # ─── Instructions (compressed) ───────────────────────────
 
-if [ "$source_type" = "compact" ] || [ "$source_type" = "clear" ]; then
+if [ "$agent" = "codex" ]; then
+    context+="
+=== Eagle Mem: Active ===
+Memory active for '$project'. Emit <eagle-summary> in final responses with request, completed, learned, decisions, gotchas, next_steps, key_files, files_read, files_modified, affected_features, verified_features, and regression_risks.
+"
+elif [ "$source_type" = "compact" ] || [ "$source_type" = "clear" ]; then
     context+="
 === Eagle Mem: Active ===
 Memory active. Attribute recalled context to Eagle Mem. Do not revert PostToolUse-surfaced decisions without asking. Emit <eagle-summary> before final response.

package/hooks/stop.sh

@@ -57,14 +57,22 @@ request=""
 heuristic_reads=""
 heuristic_writes=""
 
-if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
-    request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null \
-        | grep -v '<local-command-caveat>' \
+eagle_clean_request_candidates() {
+    grep -v '<local-command-caveat>' \
         | grep -v '<system-reminder>' \
         | grep -v '<command-name>' \
         | grep -v '<command-message>' \
         | grep -v '^\[{' \
-        | head -1 | cut -c1-500)
+        | grep -v '^# AGENTS.md instructions' \
+        | grep -v '^<environment_context>' \
+        | awk 'NF' \
+        | tail -1 \
+        | cut -c1-500
+}
+
+if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
+    request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null \
+        | eagle_clean_request_candidates)
 
     if [ -z "$request" ]; then
         request=$(jq -r '
@@ -74,19 +82,12 @@ if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
               elif type == "array" then [.[]? | select(.type == "input_text" or .type == "text") | .text] | join(" ")
               else "" end
         ' "$transcript_path" 2>/dev/null \
-            | grep -v '<local-command-caveat>' \
-            | grep -v '<system-reminder>' \
-            | grep -v '<command-name>' \
-            | grep -v '<command-message>' \
-            | grep -v '^\[{' \
-            | head -1 | cut -c1-500)
+            | eagle_clean_request_candidates)
     fi
 
     if [ -z "$request" ]; then
         request=$(jq -r 'select(.type == "event_msg" and .payload.type == "user_message") | .payload.message // empty' "$transcript_path" 2>/dev/null \
-            | grep -v '<local-command-caveat>' \
-            | grep -v '<system-reminder>' \
-            | head -1 | cut -c1-500)
+            | eagle_clean_request_candidates)
     fi
 
     heuristic_reads=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)