eagle-mem 4.10.13 → 4.12.0

package/docs/agent-compatibility/codex.md

@@ -0,0 +1,57 @@
+# Codex Compatibility
+
+Last verified: 2026-06-10
+
+## 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.
+
+## Session Capture Behavior
+
+- Codex replies stay prose-only; Eagle Mem never asks Codex to print summary blocks, XML, or hook payloads. The `Stop` hook captures a summary from the Codex rollout transcript automatically.
+- For a richer structured capture, Codex may run `eagle-mem session save --session-id <session_id> --agent codex ...` once at wrap-up (injected by `SessionStart` and the `AGENTS.md` section). This sets `capture_source = agent`, which is authoritative: later Stop-hook heuristics only fill empty fields and background enrichment is skipped, so the capture is never clobbered.
+- Modified-file lists are most reliable when Codex passes `--files-modified` explicitly; the transcript heuristic is Claude-shaped and may not populate file lists from Codex rollout tool calls.
+
+## 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.

package/docs/agent-compatibility/opencode.md

@@ -0,0 +1,72 @@
+# OpenCode Compatibility
+
+Last verified: 2026-06-10
+
+## Official Sources
+
+- Plugins reference: https://opencode.ai/docs/plugins/
+- Config reference: https://opencode.ai/docs/config/
+- Config schema: https://opencode.ai/config.json
+
+## Installed Surface Verified Locally
+
+- OpenCode CLI: `opencode --version` reported `1.14.24`.
+- OpenCode plugin package: `@opencode-ai/plugin@1.14.24`.
+- Resolved config path: `~/.config/opencode/opencode.json`.
+- Global plugin directory: `~/.config/opencode/plugins/`.
+
+## Behavior Relied On
+
+- OpenCode local plugins are JavaScript or TypeScript modules placed in `.opencode/plugins/` for project scope or `~/.config/opencode/plugins/` for global scope.
+- Files in those plugin directories are loaded automatically at startup.
+- NPM plugins are declared with the top-level `plugin` array in `opencode.json`, but Eagle Mem uses the global local-plugin directory so it does not need to mutate the user plugin array.
+- Plugin functions receive a context object with `project`, `directory`, `worktree`, `client`, and `$`, then return a hooks object.
+- The plugin event bus includes `session.created`, `session.updated`, `session.idle`, `session.compacted`, `session.deleted`, `message.updated`, `message.part.updated`, and `todo.updated`.
+- Direct hook keys include `chat.message`, `tool.execute.before`, `tool.execute.after`, `shell.env`, and `experimental.session.compacting`.
+- `tool.execute.before` can deny a tool call by throwing an error and can mutate `output.args` before execution.
+- `tool.execute.after` receives tool output fields that can be annotated for the model.
+- `experimental.session.compacting` fires before compaction and can push additional strings into `output.context`.
+- `opencode --pure` runs without external plugins; doctor checks should report that Eagle Mem OpenCode support depends on non-pure OpenCode sessions.
+
+## Eagle Mem Mapping
+
+- `chat.message` maps to Eagle Mem `SessionStart` once per session and `UserPromptSubmit` on each user message.
+- `tool.execute.before` maps to Eagle Mem `PreToolUse`; denial becomes a thrown OpenCode plugin error and `updatedInput` mutates `output.args`.
+- `tool.execute.after` maps to Eagle Mem `PostToolUse`; additional context is appended to the tool output so the agent can see guardrail or stale-memory hints.
+- `todo.updated` maps OpenCode todos into Eagle Mem task records through synthetic `TaskCreated` and `TaskUpdate` hook payloads.
+- `session.idle` maps to Eagle Mem `Stop` using the latest assistant text accumulated from message events.
+- `session.deleted` maps to Eagle Mem `SessionEnd`.
+- `experimental.session.compacting` maps to Eagle Mem compact recall by running `SessionStart` with `source=compact` and appending the returned context.
+- Session capture follows the shared clean-capture flow: the agent may run `eagle-mem session save --session-id <id> ...` at wrap-up (sets `capture_source = agent`, authoritative) and keep replies prose-only. The `session.idle` → `Stop` path then only fills gaps and never clobbers an agent-authored row.
+
+## Eagle Mem Files Depending On This
+
+- `integrations/opencode_eagle_mem_plugin.js`
+- `lib/opencode-hooks.sh`
+- `lib/common.sh`
+- `scripts/install.sh`
+- `scripts/update.sh`
+- `scripts/uninstall.sh`
+- `scripts/doctor.sh`
+- `scripts/test.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/opencode-chat-message.json`
+- `tests/fixtures/agent-hooks/opencode-tool-execute-before.json`
+- `tests/fixtures/agent-hooks/opencode-tool-execute-after.json`
+- `tests/fixtures/agent-hooks/opencode-todo-updated.json`
+- `tests/fixtures/agent-hooks/opencode-session-compacting.json`
+- `tests/test_agent_compatibility_docs_gate.sh`
+- `tests/test_opencode_hooks_config.sh`
+- `tests/test_opencode_plugin_adapter.sh`
+
+## Reverification Notes
+
+When editing OpenCode support, re-read the plugins and config docs first. If OpenCode changes plugin load order, local plugin directories, hook names, `tool.execute.*` mutation semantics, `chat.message` payloads, or compaction hooks, update these fixtures before implementation.

package/hooks/post-tool-use.sh

@@ -122,6 +122,7 @@ esac
 
 project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
+eagle_hook_observability_begin "$input" "PostToolUse"
 
 # Ensure session row exists before inserting observations (FK constraint).
 # PostToolUse can race SessionStart — the session row might not exist yet.
@@ -249,5 +250,12 @@ eagle_posttool_decision_surface "$tool_name" "$fp" "$project" "$agent"
 if ! eagle_insert_observation "$session_id" "$project" "$tool_name" "$tool_summary" "$files_read" "$files_modified" "$output_bytes" "$output_lines" "$command_category" "$agent"; then
     eagle_log "ERROR" "PostToolUse: observation insert failed for session=$session_id tool=$tool_name"
 fi
+eagle_hook_observability_set_detail "$(jq -nc \
+    --arg tool "$tool_name" \
+    --arg summary "$tool_summary" \
+    --arg files_read "$files_read" \
+    --arg files_modified "$files_modified" \
+    '{tool_name:$tool, summary:$summary, files_read:($files_read | fromjson? // []), files_modified:($files_modified | fromjson? // [])}')"
+eagle_hook_observability_complete 0
 
 exit 0

package/hooks/pre-tool-use.sh

@@ -33,6 +33,7 @@ esac
 [ ! -f "$EAGLE_MEM_DB" ] && exit 0
 project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
+eagle_hook_observability_begin "$input" "PreToolUse"
 
 context=""
 updated_input=""
@@ -382,15 +383,23 @@ Use the existing context, run a narrower search, or bypass once with:
     ;;
 esac
 
-[ -z "$context" ] && [ -z "$updated_input" ] && exit 0
+if [ -z "$context" ] && [ -z "$updated_input" ]; then
+    eagle_hook_observability_set_detail "$(jq -nc --arg tool "$tool_name" --arg action "no_action" '{tool_name:$tool, action:$action}')"
+    eagle_hook_observability_complete 0
+    exit 0
+fi
 
 # Codex PreToolUse now natively receives both blocking decisions and advisory context.
 # Removing the old early-exit to align Codex's pre-tool capabilities with Claude and Antigravity.
 
 if [ -n "$updated_input" ]; then
+    eagle_hook_observability_set_detail "$(jq -nc --arg tool "$tool_name" --arg action "updated_input" '{tool_name:$tool, action:$action}')"
+    eagle_hook_observability_complete 0
     jq -nc --arg ctx "$context" --argjson ui "$updated_input" \
         '{"hookSpecificOutput":{"hookEventName":"PreToolUse","updatedInput":$ui,"additionalContext":$ctx}}'
 else
+    eagle_hook_observability_set_detail "$(jq -nc --arg tool "$tool_name" --arg action "additional_context" '{tool_name:$tool, action:$action}')"
+    eagle_hook_observability_complete 0
     jq -nc --arg ctx "$context" '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":$ctx}}'
 fi
 

package/hooks/session-end.sh

@@ -24,6 +24,7 @@ agent=$(eagle_agent_source_from_json "$input")
 cwd=$(echo "$input" | jq -r '.cwd // empty')
 project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
+eagle_hook_observability_begin "$input" "SessionEnd"
 
 # Final sweep: re-capture all task files to catch status changes
 # Claude Code may update task status without triggering PostToolUse
@@ -40,6 +41,8 @@ fi
 
 eagle_end_session "$session_id"
 eagle_log "INFO" "SessionEnd: session=$session_id marked completed"
+eagle_hook_observability_set_detail "$(jq -nc --arg action "session_completed" '{action:$action}')"
+eagle_hook_observability_complete 0
 
 # Prune observations older than 90 days (keeps DB size bounded)
 eagle_prune_observations 90 "$project"

package/hooks/session-start.sh

@@ -35,6 +35,7 @@ codex_compact=0
 
 project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
+eagle_hook_observability_begin "$input" "SessionStart"
 
 p_esc=$(eagle_sql_escape "$project")
 recall_scope=$(eagle_recall_project_scope_from_cwd "$cwd" "$project")
@@ -624,38 +625,35 @@ fi
 if [ "$agent" = "codex" ]; then
     context+="
 === Eagle Mem: Active ===
-Memory active for '$project'. Keep user-facing Codex replies clean: do not print Eagle Mem summary capture blocks, XML, JSON hook payloads, or internal templates unless the user explicitly asks. The Stop hook captures summaries from the transcript automatically.
+Memory active for '$project'. Keep user-facing Codex replies clean: do not print Eagle Mem summary capture blocks, XML, JSON hook payloads, or internal templates unless the user explicitly asks. The Stop hook captures summaries from the transcript automatically. When you wrap up substantive work, you may persist a richer structured capture by running once: eagle-mem session save --session-id $session_id --agent codex --completed \"...\" --decisions \"choice — why\" --gotchas \"...\" --files-modified \"a.ts,b.ts\" (fill what applies). Keep the visible reply prose-only.
 "
 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.
+Memory active. Attribute recalled context to Eagle Mem. Do not revert PostToolUse-surfaced decisions without asking. Before your final response, capture the session quietly via the Bash tool (pre-approved): eagle-mem session save --session-id $session_id --completed \"...\" --decisions \"choice — why\" --gotchas \"...\" (fill what applies, omit the rest). Then give a short human recap — NEVER print <eagle-summary> tags or raw field lists.
 "
 else
     context+="
 === Eagle Mem: Active ===
 Memory active for '$project'. Scan, index, prune, and self-learning run automatically — never ask the user to run these. Attribute recalled context: \"Eagle Mem recalls:\" Do not revert PostToolUse-surfaced decisions without user request. No raw secrets in summaries. If you contradict a loaded memory, update the memory file.
 
-Before your final response, emit:
-<eagle-summary>
-request: [what user asked]
-completed: [what shipped]
-learned: [non-obvious discoveries]
-decisions: [choice — why]
-gotchas: [what surprised]
-next_steps: [concrete actions]
-key_files: [path — role]
-files_read: [path, ...]
-files_modified: [path, ...]
-affected_features: [feature, ...]
-verified_features: [feature, ...]
-regression_risks: [risk, ...]
-</eagle-summary>
+Session capture is clean: NEVER print <eagle-summary> tags, XML, or raw field lists (request:/completed:/...) in your visible reply. When you wrap up substantive work (shipped a change, made decisions worth remembering, the user signals done, or Eagle Mem warns of context pressure), capture it by running this ONCE via the Bash tool — it is pre-approved and prints only a short confirmation. Fill the flags you have; omit the rest:
+
+  eagle-mem session save --session-id $session_id --request \"...\" --completed \"...\" --learned \"...\" --decisions \"choice — why; choice — why\" --gotchas \"...\" --next-steps \"...\" --key-files \"path — role\" --files-modified \"a.ts,b.ts\" --affected-features \"...\" --verified-features \"...\" --regression-risks \"...\"
+
+Then end with a brief, human recap of the session in prose, followed by one line:
+**Eagle Mem** | Session captured — N decisions, M gotchas
 "
 fi
 
 if [ -n "$context" ]; then
+    eagle_hook_observability_set_detail "$(jq -nc \
+        --arg source_type "$source_type" \
+        --arg recall_scope "$recall_scope" \
+        --argjson injected_chars "${#context}" \
+        '{source_type:$source_type, recall_scope:$recall_scope, injected_chars:$injected_chars}')"
     eagle_emit_context_for_agent "$agent" "SessionStart" "$context"
 fi
+eagle_hook_observability_complete 0
 
 exit 0

package/hooks/stop.sh

@@ -31,6 +31,7 @@ agent=$(eagle_agent_source_from_json "$input")
 
 project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
+eagle_hook_observability_begin "$input" "Stop"
 
 eagle_log "INFO" "Stop: session=$session_id project=$project transcript=$transcript_path agent=$agent"
 
@@ -237,7 +238,7 @@ if [ "$needs_enrichment" -eq 1 ]; then
     # lifecycle timeouts and make the hook look broken to users.
     if [ "${EAGLE_MEM_STOP_ENRICH:-0}" != "1" ]; then
         defer_enrichment=1
-        eagle_log "INFO" "Stop: LLM enrichment skipped — fast hook path (provider=$provider)"
+        eagle_log "INFO" "Stop: LLM enrichment skipped on fast hook path; provider=$provider"
     elif [ "$provider" != "none" ] && [ -n "$text_content" ]; then
         excerpt=$(echo "$text_content" | tail -c 3000)
 
@@ -395,16 +396,44 @@ if [ -n "$regression_notes" ]; then
 fi
 
 # ─── Write to database ─────────────────────────────────────
+#
+# Capture-source precedence:
+#   - A parsed <eagle-summary> block this turn is agent-authored → write 'agent'.
+#   - An existing 'agent' row (CLI `eagle-mem session save` or an earlier block)
+#     is authoritative → fill empty gaps only, never overwrite with heuristics.
+#   - Otherwise this is a heuristic capture → normal 'hook' write.
+# agent_authored also gates background enrichment so it can't clobber later.
+
+existing_source=$(eagle_summary_capture_source "$session_id" 2>/dev/null || true)
+agent_authored=0
+[ -n "$summary_block" ] && agent_authored=1
+[ "$existing_source" = "agent" ] && agent_authored=1
 
 if [ -n "$request" ] || [ -n "$completed" ] || [ -n "$learned" ]; then
-    if eagle_insert_summary "$session_id" "$project" "$request" "$investigated" "$learned" "$completed" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files" "$agent"; then
-        eagle_log "INFO" "Stop: summary saved for session=$session_id"
+    write_rc=0
+    if [ -n "$summary_block" ]; then
+        eagle_insert_summary "$session_id" "$project" "$request" "$investigated" "$learned" "$completed" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files" "$agent" "agent" || write_rc=$?
+    elif [ "$existing_source" = "agent" ]; then
+        eagle_insert_summary_fill_only "$session_id" "$project" "$request" "$investigated" "$learned" "$completed" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files" "$agent" "hook" || write_rc=$?
+    else
+        eagle_insert_summary "$session_id" "$project" "$request" "$investigated" "$learned" "$completed" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files" "$agent" "hook" || write_rc=$?
+    fi
+    if [ "$write_rc" -eq 0 ]; then
+        eagle_log "INFO" "Stop: summary saved for session=$session_id (prior_source=${existing_source:-none}, block=$([ -n "$summary_block" ] && echo yes || echo no))"
+        eagle_insert_event "$project" "$session_id" "$agent" "memory_created" "" "Stop" "ok" "$(jq -nc --arg source "summary" '{source:$source}')" >/dev/null 2>&1 || true
     else
         eagle_log "ERROR" "Stop: summary insert FAILED for session=$session_id — check DB constraints"
     fi
 fi
-
-if [ "$defer_enrichment" -eq 1 ] && [ "${EAGLE_MEM_STOP_BACKGROUND_ENRICH:-1}" = "1" ] && [ -n "$text_content" ]; then
+eagle_hook_observability_set_detail "$(jq -nc \
+    --argjson files_read "$files_read" \
+    --argjson files_modified "$files_modified" \
+    --arg request "$request" \
+    --arg completed "$completed" \
+    '{request_chars:($request | length), completed_chars:($completed | length), files_read:$files_read, files_modified:$files_modified}')"
+eagle_hook_observability_complete 0
+
+if [ "$defer_enrichment" -eq 1 ] && [ "${EAGLE_MEM_STOP_BACKGROUND_ENRICH:-1}" = "1" ] && [ -n "$text_content" ] && [ "$agent_authored" -eq 0 ]; then
     mkdir -p "$EAGLE_MEM_DIR/tmp" 2>/dev/null || true
     enrich_job=$(mktemp "$EAGLE_MEM_DIR/tmp/summary-enrich.XXXXXX.json" 2>/dev/null)
     if [ -n "$enrich_job" ]; then

package/hooks/user-prompt-submit.sh

@@ -30,11 +30,22 @@ recall_scope=$(eagle_recall_project_scope_from_cwd "$cwd" "$project")
 [ -z "$recall_scope" ] && recall_scope="$project"
 codex_compact=0
 [ "$agent" = "codex" ] && codex_compact=1
+eagle_hook_observability_begin "$input" "UserPromptSubmit"
 
 # ─── Context pressure detection (turn counter since last compact) ──
 # Must run before any early exits so every prompt is counted
 
 context=""
+summary_matches=0
+memory_matches=0
+code_matches=0
+summary_refs="[]"
+memory_refs="[]"
+code_refs="[]"
+
+count_pipe_rows() {
+    awk -F'|' '($1 != "" || $2 != "") { c++ } END { print c + 0 }'
+}
 
 if [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
     counter_file="$EAGLE_MEM_DIR/.turn-counter.${session_id}"
@@ -56,8 +67,9 @@ Eagle Mem context pressure: critical ($turn_count turns since compact)
         else
             context+="
 === Eagle Mem: Context Pressure Critical ($turn_count turns since compact) ===
-IMMEDIATELY emit a detailed <eagle-summary> covering ALL work this session.
-Tell the user to run /compact NOW to avoid losing context.
+IMMEDIATELY capture ALL work this session by running (pre-approved, quiet):
+eagle-mem session save --session-id $session_id --completed \"...\" --decisions \"choice — why\" --gotchas \"...\" --learned \"...\" --next-steps \"...\" --key-files \"path — role\"
+Then tell the user to run /compact NOW. Do NOT print <eagle-summary> tags or raw field lists.
 "
         fi
         echo "$turn_count" > "$EAGLE_MEM_DIR/.context-pressure"
@@ -72,8 +84,9 @@ Eagle Mem context pressure: high ($turn_count turns since compact)
         else
             context+="
 === Eagle Mem: Context Pressure High ($turn_count turns since compact) ===
-Include a thorough <eagle-summary> in your next response — capture all decisions, gotchas, and learned context before compaction.
-Suggest the user run /compact to free context for continued work.
+Capture your work before compaction by running (pre-approved, quiet):
+eagle-mem session save --session-id $session_id --completed \"...\" --decisions \"choice — why\" --gotchas \"...\" --learned \"...\"
+Then suggest the user run /compact. Do NOT print <eagle-summary> tags or raw field lists.
 "
         fi
         echo "$turn_count" > "$EAGLE_MEM_DIR/.context-pressure"
@@ -85,6 +98,9 @@ fi
 # Skip short prompts — not enough signal for meaningful search
 word_count=$(echo "$user_prompt" | wc -w | tr -d ' ')
 if [ "$word_count" -lt 3 ]; then
+    eagle_insert_recall_event "$session_id" "$recall_scope" "$cwd" "$agent" "$user_prompt" "" 0 0 0 "${#context}" "skipped_short_prompt" "" >/dev/null 2>&1 || true
+    eagle_hook_observability_set_detail "$(jq -nc --arg recall_status "skipped_short_prompt" --argjson injected_chars "${#context}" '{recall_status:$recall_status, injected_chars:$injected_chars}')"
+    eagle_hook_observability_complete 0
     eagle_emit_context_for_agent "$agent" "UserPromptSubmit" "$context"
     exit 0
 fi
@@ -105,6 +121,9 @@ fts_query=$(echo "$user_prompt" | tr -cs '[:alnum:]' ' ' | tr '[:upper:]' '[:low
     }')
 
 if [ -z "$fts_query" ]; then
+    eagle_insert_recall_event "$session_id" "$recall_scope" "$cwd" "$agent" "$user_prompt" "" 0 0 0 "${#context}" "skipped_no_query" "" >/dev/null 2>&1 || true
+    eagle_hook_observability_set_detail "$(jq -nc --arg recall_status "skipped_no_query" --argjson injected_chars "${#context}" '{recall_status:$recall_status, injected_chars:$injected_chars}')"
+    eagle_hook_observability_complete 0
     eagle_emit_context_for_agent "$agent" "UserPromptSubmit" "$context"
     exit 0
 fi
@@ -113,19 +132,27 @@ fi
 
 lower_prompt=$(printf '%s' "$user_prompt" | tr '[:upper:]' '[:lower:]')
 if printf '%s\n' "$lower_prompt" | grep -Eq '(orchestrat|worker|parallel|multi-agent|multi agent|split|lane|scope out|plan and get started|broad|full codebase|release|publish|ship)'; then
+    auto_orchestration=$(eagle_auto_orchestrate_from_prompt "$project" "$session_id" "$agent" "$user_prompt" "$cwd" "broad_prompt" 2>/dev/null || true)
+    if [ -n "$auto_orchestration" ]; then
+        IFS='|' read -r auto_name auto_id auto_lane_count _auto_lanes_json <<< "$auto_orchestration"
+        context+="
+Eagle Mem orchestration: detected broad work and created durable orchestration '$auto_name' with $auto_lane_count lanes.
+- Inspect it with: eagle-mem orchestrate --name $auto_name
+- Lanes already exist as durable tasks; update them instead of relying on memory alone.
+"
+    fi
     if [ "$codex_compact" -eq 1 ]; then
         context+="
 Eagle Mem orchestration:
-- For broad work, you run eagle-mem orchestrate yourself.
-- Use durable lanes, opposite-agent workers, and concise user-visible status.
+- Continue from the durable lanes Eagle already created.
+- Keep lane/task status current as work progresses.
 "
     else
         context+="=== Eagle Mem: Orchestration Protocol ===
-If this request is broad enough to split into worker lanes, YOU run the orchestration commands. Do not ask the user to run them.
+Eagle has already detected broad work and registered durable orchestration state.
 
 Use:
-  eagle-mem orchestrate init \"<goal>\"
-  eagle-mem orchestrate lane add <key> --agent codex|claude-code --desc \"<self-contained scope>\" --validate \"<command>\"
+  eagle-mem orchestrate --name auto
   eagle-mem orchestrate lane start|block|complete <key>
 
 Keep this mostly invisible to the user; surface only concise status or handoff when useful.
@@ -146,6 +173,8 @@ memory_limit=3
 
 results=$(eagle_search_summaries "$fts_query" "$recall_scope" "$summary_limit")
 memory_results=$(eagle_search_agent_memories "$fts_query" "$recall_scope" "$memory_limit" 2>/dev/null || true)
+summary_matches=$(printf '%s\n' "$results" | count_pipe_rows)
+memory_matches=$(printf '%s\n' "$memory_results" | count_pipe_rows)
 
 if [ -n "$results" ] || [ -n "$memory_results" ]; then
     if [ "$codex_compact" -eq 1 ]; then
@@ -195,6 +224,13 @@ Eagle Mem recalls:
             context+="
 "
         fi
+        summary_refs=$(printf '%s' "$summary_refs" | jq -c \
+            --arg created_at "$created_at" \
+            --arg agent "$summary_agent" \
+            --arg request "$req" \
+            --arg completed "$completed" \
+            --arg learned "$learned" \
+            '. + [{created_at:$created_at, agent:$agent, request:$request, completed:$completed, learned:$learned}]' 2>/dev/null || printf '[]')
     done <<< "$results"
 
     while IFS='|' read -r mname mtype mdesc msnippet _mfile _mupdated morigin; do
@@ -219,6 +255,12 @@ Eagle Mem recalls:
             context+="
 "
         fi
+        memory_refs=$(printf '%s' "$memory_refs" | jq -c \
+            --arg name "$mname" \
+            --arg type "$mtype" \
+            --arg description "$mdesc" \
+            --arg agent "$morigin" \
+            '. + [{name:$name, type:$type, description:$description, agent:$agent}]' 2>/dev/null || printf '[]')
     done <<< "$memory_results"
 fi
 
@@ -226,6 +268,7 @@ fi
 has_chunks=$(eagle_count_code_chunks "$project")
 if [ "${has_chunks:-0}" -gt 0 ]; then
     code_results=$(eagle_search_code_chunks "$fts_query" "$project" "$code_limit")
+    code_matches=$(printf '%s\n' "$code_results" | count_pipe_rows)
 
     if [ -n "$code_results" ]; then
         if [ "$codex_compact" -eq 1 ]; then
@@ -246,11 +289,27 @@ Relevant code:
             [ -n "$lang" ] && context+=" ($lang)"
             context+="
 "
+            code_refs=$(printf '%s' "$code_refs" | jq -c \
+                --arg file "$fpath" \
+                --arg start_line "$sline" \
+                --arg end_line "$eline" \
+                --arg language "$lang" \
+                '. + [{file:$file, start_line:$start_line, end_line:$end_line, language:$language}]' 2>/dev/null || printf '[]')
         done <<< "$code_results"
     fi
 fi
 
-[ -z "$context" ] && exit 0
+if [ -z "$context" ]; then
+    eagle_insert_recall_event "$session_id" "$recall_scope" "$cwd" "$agent" "$user_prompt" "$fts_query" "$summary_matches" "$memory_matches" "$code_matches" 0 "no_context" "" "$summary_refs" "$memory_refs" "$code_refs" >/dev/null 2>&1 || true
+    eagle_hook_observability_set_detail "$(jq -nc \
+        --arg recall_status "no_context" \
+        --argjson summary_matches "${summary_matches:-0}" \
+        --argjson memory_matches "${memory_matches:-0}" \
+        --argjson code_matches "${code_matches:-0}" \
+        '{recall_status:$recall_status, summary_matches:$summary_matches, memory_matches:$memory_matches, code_matches:$code_matches, injected_chars:0}')"
+    eagle_hook_observability_complete 0
+    exit 0
+fi
 
 if [ "$codex_compact" -eq 1 ]; then
     context+="
@@ -264,5 +323,21 @@ IMPORTANT: If directly useful, start with one short Eagle Mem attribution line,
 "
 fi
 
+eagle_insert_recall_event "$session_id" "$recall_scope" "$cwd" "$agent" "$user_prompt" "$fts_query" "$summary_matches" "$memory_matches" "$code_matches" "${#context}" "ok" "" "$summary_refs" "$memory_refs" "$code_refs" >/dev/null 2>&1 || true
+eagle_insert_event "$recall_scope" "$session_id" "$agent" "context_injected" "" "UserPromptSubmit" "ok" "$(jq -nc \
+    --argjson summary_matches "${summary_matches:-0}" \
+    --argjson memory_matches "${memory_matches:-0}" \
+    --argjson code_matches "${code_matches:-0}" \
+    --argjson injected_chars "${#context}" \
+    '{summary_matches:$summary_matches, memory_matches:$memory_matches, code_matches:$code_matches, injected_chars:$injected_chars}')" >/dev/null 2>&1 || true
+eagle_hook_observability_set_detail "$(jq -nc \
+    --arg recall_status "ok" \
+    --argjson summary_matches "${summary_matches:-0}" \
+    --argjson memory_matches "${memory_matches:-0}" \
+    --argjson code_matches "${code_matches:-0}" \
+    --argjson injected_chars "${#context}" \
+    '{recall_status:$recall_status, summary_matches:$summary_matches, memory_matches:$memory_matches, code_matches:$code_matches, injected_chars:$injected_chars}')"
+eagle_hook_observability_complete 0
+
 eagle_emit_context_for_agent "$agent" "UserPromptSubmit" "$context"
 exit 0