eagle-mem 4.10.13 → 4.12.0

package/scripts/session.sh

@@ -19,21 +19,30 @@ show_help() {
     echo -e "    eagle-mem session ${CYAN}save <text>${RESET}"
     echo ""
     echo -e "  ${BOLD}Options for save:${RESET}"
-    echo -e "    ${CYAN}--summary${RESET} <text>       Summary to store"
+    echo -e "    ${CYAN}--completed${RESET} <text>     What was accomplished (alias: --summary)"
     echo -e "    ${CYAN}--request${RESET} <text>       User request that caused the work"
+    echo -e "    ${CYAN}--investigated${RESET} <text>  What was explored or analyzed"
     echo -e "    ${CYAN}--learned${RESET} <text>       Non-obvious discoveries"
     echo -e "    ${CYAN}--decisions${RESET} <text>     Decisions and why"
     echo -e "    ${CYAN}--gotchas${RESET} <text>       Surprises or pitfalls"
     echo -e "    ${CYAN}--next-steps${RESET} <text>    Follow-up work"
-    echo -e "    ${CYAN}--key-files${RESET} <text>     Important files"
+    echo -e "    ${CYAN}--key-files${RESET} <text>     Important files (path — role)"
+    echo -e "    ${CYAN}--files-read${RESET} <list>    Comma-separated files read"
+    echo -e "    ${CYAN}--files-modified${RESET} <list> Comma-separated files modified"
+    echo -e "    ${CYAN}--affected-features${RESET} <text>  Features touched (need re-verify)"
+    echo -e "    ${CYAN}--verified-features${RESET} <text>  Features verified this session"
+    echo -e "    ${CYAN}--regression-risks${RESET} <text>   Known risks introduced"
     echo -e "    ${CYAN}--notes${RESET} <text>         Extra notes"
+    echo -e "    ${CYAN}--session-id${RESET} <id>      Live session id (merges into the active row;"
+    echo -e "                              omit for a standalone manual save)"
     echo -e "    ${CYAN}-p, --project${RESET} <name>   Project name (default: current git root)"
-    echo -e "    ${CYAN}--agent${RESET} <name>         Source agent: codex or claude-code"
+    echo -e "    ${CYAN}--agent${RESET} <name>         Source: claude-code, codex, antigravity, opencode, grok"
     echo -e "    ${CYAN}--cwd${RESET} <path>           Working directory for project detection"
     echo -e "    ${CYAN}--json${RESET}                 Output JSON"
     echo ""
-    echo -e "  ${DIM}This command is mainly for agent fallbacks. Normal sessions are captured${RESET}"
-    echo -e "  ${DIM}automatically by hooks when Claude Code or Codex stops a turn.${RESET}"
+    echo -e "  ${DIM}Agents use this to capture a clean, branded session summary without printing${RESET}"
+    echo -e "  ${DIM}raw blocks. Pass --session-id <id> to merge into the live session row. Stop${RESET}"
+    echo -e "  ${DIM}hooks still capture automatically as a safety net when no save is made.${RESET}"
     echo ""
 }
 
@@ -49,24 +58,48 @@ json_string() {
     jq -Rn --arg v "${1:-}" '$v'
 }
 
+# Comma-separated list → JSON array (matches hooks/stop.sh storage shape).
+# Safe under set -e: empty input yields [] without a failing pipeline.
+# Slurp the whole value (-s) so embedded newlines split into items rather than
+# emitting one JSON array per line (which would corrupt the stored column).
+csv_to_json_array() {
+    local raw="${1:-}"
+    [ -z "$raw" ] && { echo '[]'; return 0; }
+    printf '%s' "$raw" | jq -Rsc 'split("[,\n]"; "") | map(gsub("^\\s+|\\s+$";"")) | map(select(. != ""))'
+}
+
+# Count items in a field separated by ';' or newlines (for the capture banner).
+count_items() {
+    local text="${1:-}"
+    [ -z "$text" ] && { echo 0; return 0; }
+    printf '%s' "$text" | awk 'BEGIN{RS="[;\n]"} {gsub(/^[ \t]+|[ \t]+$/,""); if($0!="") n++} END{print n+0}'
+}
+
 save_session() {
     local summary=""
-    local request="Manual session save"
+    local request=""
+    local investigated=""
     local learned=""
     local decisions=""
     local gotchas=""
     local next_steps=""
     local key_files=""
+    local files_read_raw=""
+    local files_modified_raw=""
+    local affected_features=""
+    local verified_features=""
+    local regression_risks=""
     local notes=""
     local project=""
     local cwd
     cwd="$(pwd)"
     local agent=""
+    local cli_session_id=""
     local json_output=false
 
     while [ $# -gt 0 ]; do
         case "$1" in
-            --summary)
+            --summary|--completed)
                 require_value "$1" "${2:-}"
                 summary="$2"
                 shift 2
@@ -76,6 +109,11 @@ save_session() {
                 request="$2"
                 shift 2
                 ;;
+            --investigated)
+                require_value "$1" "${2:-}"
+                investigated="$2"
+                shift 2
+                ;;
             --learned)
                 require_value "$1" "${2:-}"
                 learned="$2"
@@ -101,11 +139,41 @@ save_session() {
                 key_files="$2"
                 shift 2
                 ;;
+            --files-read)
+                require_value "$1" "${2:-}"
+                files_read_raw="$2"
+                shift 2
+                ;;
+            --files-modified)
+                require_value "$1" "${2:-}"
+                files_modified_raw="$2"
+                shift 2
+                ;;
+            --affected-features)
+                require_value "$1" "${2:-}"
+                affected_features="$2"
+                shift 2
+                ;;
+            --verified-features)
+                require_value "$1" "${2:-}"
+                verified_features="$2"
+                shift 2
+                ;;
+            --regression-risks)
+                require_value "$1" "${2:-}"
+                regression_risks="$2"
+                shift 2
+                ;;
             --notes)
                 require_value "$1" "${2:-}"
                 notes="$2"
                 shift 2
                 ;;
+            --session-id)
+                require_value "$1" "${2:-}"
+                cli_session_id="$2"
+                shift 2
+                ;;
             --project|-p)
                 require_value "$1" "${2:-}"
                 project="$2"
@@ -147,11 +215,25 @@ save_session() {
         esac
     done
 
-    if [ -z "$summary" ]; then
-        eagle_err "Nothing to save. Pass --summary <text>."
+    if [ -z "$summary" ] && [ -z "$learned" ] && [ -z "$decisions" ] && [ -z "$gotchas" ] \
+        && [ -z "$next_steps" ] && [ -z "$key_files" ] && [ -z "$investigated" ] \
+        && [ -z "$files_read_raw" ] && [ -z "$files_modified_raw" ] \
+        && [ -z "$affected_features" ] && [ -z "$verified_features" ] && [ -z "$regression_risks" ]; then
+        eagle_err "Nothing to save. Pass --completed/--summary (or another field)."
         exit 1
     fi
 
+    if [ -n "$cli_session_id" ] && ! eagle_validate_session_id "$cli_session_id"; then
+        eagle_err "Invalid --session-id (allowed: letters, digits, '_', '-', max 128 chars)."
+        exit 1
+    fi
+
+    # For a live session, prefer its recorded project so a save issued from a
+    # subdirectory (whose cwd derives a different key) does not trigger an
+    # unintended project rekey of the active session.
+    if [ -z "$project" ] && [ -n "$cli_session_id" ] && [ -f "${EAGLE_MEM_DB:-}" ]; then
+        project=$(eagle_db "SELECT project FROM sessions WHERE id='$(eagle_sql_escape "$cli_session_id")' LIMIT 1;" 2>/dev/null || true)
+    fi
     [ -z "$project" ] && project=$(eagle_project_from_cwd "$cwd")
     if [ -z "$project" ]; then
         eagle_err "Could not determine project. Re-run with --project <name>."
@@ -165,44 +247,99 @@ save_session() {
             codex|openai-codex) agent="codex" ;;
             claude|claude-code|cloud-code) agent="claude-code" ;;
             antigravity*|google-antigravity*|google_antigravity*) agent="antigravity" ;;
+            opencode) agent="opencode" ;;
+            grok|grok-cli) agent="grok" ;;
             *)
-                eagle_err "--agent must be codex, claude-code, or antigravity"
+                eagle_err "--agent must be codex, claude-code, antigravity, opencode, or grok"
                 exit 1
                 ;;
         esac
     fi
 
+    # Default request only for manual (non-session-id) saves; for a live
+    # session leave it empty so the Stop hook's real request is preserved.
+    if [ -z "$request" ] && [ -z "$cli_session_id" ]; then
+        request="Manual session save"
+    fi
+
+    local files_read files_modified
+    files_read=$(csv_to_json_array "$files_read_raw")
+    files_modified=$(csv_to_json_array "$files_modified_raw")
+
     summary=$(printf '%s' "$summary" | eagle_redact)
     request=$(printf '%s' "$request" | eagle_redact)
+    investigated=$(printf '%s' "$investigated" | eagle_redact)
     learned=$(printf '%s' "$learned" | eagle_redact)
     decisions=$(printf '%s' "$decisions" | eagle_redact)
     gotchas=$(printf '%s' "$gotchas" | eagle_redact)
     next_steps=$(printf '%s' "$next_steps" | eagle_redact)
     key_files=$(printf '%s' "$key_files" | eagle_redact)
     notes=$(printf '%s' "$notes" | eagle_redact)
+    affected_features=$(printf '%s' "$affected_features" | eagle_redact)
+    verified_features=$(printf '%s' "$verified_features" | eagle_redact)
+    regression_risks=$(printf '%s' "$regression_risks" | eagle_redact)
+
+    # Fold feature-tracking fields into notes (same shape as hooks/stop.sh)
+    local regression_notes=""
+    [ -n "$affected_features" ] && regression_notes+="affected_features: $affected_features"
+    if [ -n "$verified_features" ]; then
+        [ -n "$regression_notes" ] && regression_notes+="; "
+        regression_notes+="verified_features: $verified_features"
+    fi
+    if [ -n "$regression_risks" ]; then
+        [ -n "$regression_notes" ] && regression_notes+="; "
+        regression_notes+="regression_risks: $regression_risks"
+    fi
+    if [ -n "$regression_notes" ]; then
+        if [ -n "$notes" ]; then
+            notes="${notes}; ${regression_notes}"
+        else
+            notes="$regression_notes"
+        fi
+    fi
 
     eagle_ensure_db
 
-    local stamp session_id
-    stamp=$(date -u +%Y%m%dT%H%M%SZ)
-    session_id="manual-${stamp}-$$-${RANDOM:-0}"
+    local session_id end_after_save=1
+    if [ -n "$cli_session_id" ]; then
+        # Live session: ensure the row exists and stays active. Empty source/cwd
+        # preserve whatever SessionStart already recorded; do NOT end the session.
+        session_id="$cli_session_id"
+        end_after_save=0
+        eagle_upsert_session "$session_id" "$project" "" "" "" "$agent"
+    else
+        local stamp
+        stamp=$(date -u +%Y%m%dT%H%M%SZ)
+        session_id="manual-${stamp}-$$-${RANDOM:-0}"
+        eagle_upsert_session "$session_id" "$project" "$cwd" "" "manual" "$agent"
+    fi
+
+    # capture_source=agent: agent-authored capture is authoritative and must not
+    # be clobbered by later Stop-hook heuristics or background enrichment.
+    eagle_insert_summary "$session_id" "$project" "$request" "$investigated" "$learned" "$summary" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files" "$agent" "agent"
+
+    [ "$end_after_save" = "1" ] && eagle_end_session "$session_id"
 
-    eagle_upsert_session "$session_id" "$project" "$cwd" "" "manual" "$agent"
-    eagle_insert_summary "$session_id" "$project" "$request" "" "$learned" "$summary" "$next_steps" "[]" "[]" "$notes" "$decisions" "$gotchas" "$key_files" "$agent"
-    eagle_end_session "$session_id"
+    local n_dec n_got dec_word got_word
+    n_dec=$(count_items "$decisions")
+    n_got=$(count_items "$gotchas")
+    [ "$n_dec" = "1" ] && dec_word="decision" || dec_word="decisions"
+    [ "$n_got" = "1" ] && got_word="gotcha" || got_word="gotchas"
 
     if [ "$json_output" = true ]; then
         printf '{'
         printf '"session_id":%s,' "$(json_string "$session_id")"
         printf '"project":%s,' "$(json_string "$project")"
         printf '"agent":%s,' "$(json_string "$agent")"
+        printf '"decisions":%s,' "$n_dec"
+        printf '"gotchas":%s,' "$n_got"
         printf '"summary":%s' "$(json_string "$summary")"
         printf '}\n'
     else
-        eagle_ok "Session summary saved"
+        printf '  %bEagle Mem%b | Session captured — %s %s, %s %s\n' \
+            "$CYAN" "$RESET" "$n_dec" "$dec_word" "$n_got" "$got_word"
         eagle_kv "Project:" "$project"
         eagle_kv "Source:" "$(eagle_agent_label "$agent")"
-        eagle_kv "Session:" "$session_id"
     fi
 }
 

package/scripts/statusline-em.sh

@@ -41,10 +41,11 @@ eagle_mem_statusline_stats() {
     local session_id="${2:-}"
     local statusline_input="${3:-}"
     local current_dir="${4:-}"
-    local em_db="$HOME/.eagle-mem/memory.db"
+    local em_db="${EAGLE_MEM_DIR:-$HOME/.eagle-mem}/memory.db"
     [ -f "$em_db" ] || return
 
     _eagle_statusline_load_common
+    em_db="$EAGLE_MEM_DB"
 
     local sqlite_bin
     sqlite_bin=$(eagle_sqlite_path)
@@ -58,7 +59,7 @@ eagle_mem_statusline_stats() {
     [ -z "$project_dir" ] && project_dir="$(pwd)"
     [ -z "$current_dir" ] && current_dir="$project_dir"
 
-    local project_key project_scope project_condition stats sessions memories last_raw turns version latest
+    local project_key project_scope project_condition stats stats_rc sessions memories last_raw turns version latest db_status db_detail
     project_key=$(eagle_project_from_statusline_input "$statusline_input" "$project_dir" "$current_dir" "$session_id")
     [ -n "$project_key" ] || return
     project_scope=$(eagle_recall_project_scope_from_cwd "${current_dir:-$project_dir}" "$project_key")
@@ -70,6 +71,20 @@ eagle_mem_statusline_stats() {
         COALESCE(MAX(COALESCE(last_activity_at, started_at)), 'never')
         FROM sessions
         WHERE $project_condition;" 2>/dev/null)
+    stats_rc=$?
+    db_status="ok"
+    db_detail="ok"
+    if [ "$stats_rc" -ne 0 ] || [ -z "$stats" ]; then
+        local integrity_check
+        integrity_check=$(eagle_db_integrity_status "$em_db" 2>/dev/null || true)
+        db_status="${integrity_check%%|*}"
+        db_detail="${integrity_check#*|}"
+        [ -n "$db_status" ] || db_status="error"
+        [ -n "$db_detail" ] || db_detail="database query failed"
+        if [ "$db_status" != "ok" ]; then
+            stats="__DB_ERROR__|0|db_error"
+        fi
+    fi
     IFS='|' read -r sessions memories last_raw <<< "${stats:-0|0|never}"
     sessions=${sessions:-0}
     memories=${memories:-0}
@@ -92,15 +107,20 @@ eagle_mem_statusline_stats() {
     [ -z "$version" ] && version="?"
     [ -z "$latest" ] && latest="$version"
 
-    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$project_key" "$version" "$latest" "$sessions" "$memories" "$turns" "$last_raw"
+    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$project_key" "$version" "$latest" "$sessions" "$memories" "$turns" "$last_raw" "$db_status"
 }
 
 eagle_mem_statusline() {
-    local stats project_key version latest sessions memories turns last_raw
+    local stats project_key version latest sessions memories turns last_raw db_status
     stats=$(eagle_mem_statusline_stats "${1:-}" "${2:-}" "${3:-}" "${4:-}") || return
-    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw <<< "$stats"
+    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw db_status <<< "$stats"
 
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
+    if [ "${db_status:-ok}" != "ok" ]; then
+        printf "%bEagle%b %bv%s%b | %bDB error%b | turn %b%s%b" \
+            "$CYAN" "$R" "$WHT" "$version" "$DIM" "$WHT" "$DIM" "$WHT" "${turns:-0}" "$R"
+        return
+    fi
     printf "%bEagle%b %bv%s%b | %b%s%b sessions | %b%s%b memories | turn %b%s%b" \
         "$CYAN" "$R" \
         "$WHT" "$version" "$DIM" \
@@ -110,9 +130,9 @@ eagle_mem_statusline() {
 }
 
 eagle_mem_statusline_hud() {
-    local stats project_key version latest sessions memories turns last_raw last_label
+    local stats project_key version latest sessions memories turns last_raw last_label db_status
     stats=$(eagle_mem_statusline_stats "${1:-}" "${2:-}" "${3:-}" "${4:-}") || return
-    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw <<< "$stats"
+    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw db_status <<< "$stats"
     last_label=$(_eagle_statusline_relative_time "$last_raw")
 
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
@@ -136,6 +156,13 @@ eagle_mem_statusline_hud() {
         em_ver="${em_ver} ${GRN}✓${R}"
     fi
 
+    if [ "${db_status:-ok}" != "ok" ]; then
+        printf "%bEagle Mem%b %b %b│%b %bDatabase:%b %bERROR%b %b│%b %bTurns:%b %b%s/30%b %b(%s)%b" \
+            "$CYAN" "$R" "$em_ver" "$DIM" "$R" "$DIM" "$R" "$RED" "$R" "$DIM" "$R" \
+            "$DIM" "$R" "$turn_color" "$turns" "$R" "$turn_color" "$pressure_label" "$R"
+        return
+    fi
+
     printf "%bEagle Mem%b %b %b│%b %bSessions:%b %b%s%b %b│%b %bMemories:%b %b%s%b %b│%b %bTurns:%b %b%s/30%b %b(%s)%b %b│%b %bUpdated:%b %b%s%b" \
         "$CYAN" "$R" "$em_ver" \
         "$DIM" "$R" "$DIM" "$R" "$WHT" "${sessions:-0}" "$R" "$DIM" "$R" \

package/scripts/tasks.sh

@@ -71,6 +71,40 @@ project_sql=$(eagle_sql_escape "$project")
 [ -z "$agent" ] && agent=$(eagle_agent_source)
 agent_sql=$(eagle_sql_escape "$agent")
 
+tasks_fail() {
+    local error_code="$1"
+    local message="$2"
+    local db_status="${3:-unknown}"
+    local db_detail="${4:-}"
+
+    if [ "$json_output" = true ]; then
+        jq -nc \
+            --arg status "error" \
+            --arg command "tasks" \
+            --arg action "$action" \
+            --arg error "$error_code" \
+            --arg message "$message" \
+            --arg project "$project" \
+            --arg db_status "$db_status" \
+            --arg db_detail "$db_detail" \
+            '{status:$status, command:$command, action:$action, error:$error, message:$message,
+              project:$project, database:{integrity:{status:$db_status, detail:$db_detail}}}'
+    else
+        eagle_err "$message"
+        [ -n "$db_detail" ] && eagle_dim "  $db_detail"
+    fi
+    exit 1
+}
+
+db_integrity_check=$(eagle_db_integrity_status "$EAGLE_MEM_DB" 2>/dev/null || true)
+db_integrity_status="${db_integrity_check%%|*}"
+db_integrity_detail="${db_integrity_check#*|}"
+[ -n "$db_integrity_status" ] || db_integrity_status="unknown"
+[ -n "$db_integrity_detail" ] || db_integrity_detail="not checked"
+if [ "$db_integrity_status" != "ok" ]; then
+    tasks_fail "database_integrity" "Database integrity check failed; durable tasks are unavailable." "$db_integrity_status" "$db_integrity_detail"
+fi
+
 # ─── List tasks ───────────────────────────────────────────
 
 tasks_list() {

package/scripts/test.sh

@@ -55,6 +55,19 @@ run_check "Graph Memory Rebuild (isolated regression suite)" "bash \"$SCRIPTS_DI
 run_check "Dream Cycle Memory Graph Wiring (isolated regression suite)" "bash \"$SCRIPTS_DIR/../tests/test_curate_graph_memories.sh\""
 run_check "Reliability Guards (provider fallback, logs, autoscan, read scoring)" "bash \"$SCRIPTS_DIR/../tests/test_reliability_guards.sh\""
 run_check "Feature Verification Gate (monorepo path collisions)" "bash \"$SCRIPTS_DIR/../tests/test_feature_verification_gate.sh\""
+run_check "Compaction Survival Matrix (summary, memory, task, feature, recall, graph)" "bash \"$SCRIPTS_DIR/../tests/test_compaction_survival_matrix.sh\""
+run_check "Auto Orchestration Detection (broad prompt creates lanes/tasks)" "bash \"$SCRIPTS_DIR/../tests/test_auto_orchestration_detection.sh\""
+run_check "Agent Compatibility Docs Gate (official-doc verified hook contracts)" "bash \"$SCRIPTS_DIR/../tests/test_agent_compatibility_docs_gate.sh\""
+run_check "Claude Stop Hook Registration (bash wrapper)" "bash \"$SCRIPTS_DIR/../tests/test_claude_stop_hook_registration.sh\""
+run_check "Codex Hooks Config (canonical features.hooks flag)" "bash \"$SCRIPTS_DIR/../tests/test_codex_hooks_config.sh\""
+run_check "OpenCode Hooks Config (global plugin and skill registration)" "bash \"$SCRIPTS_DIR/../tests/test_opencode_hooks_config.sh\""
+run_check "OpenCode Plugin Adapter (hook normalization)" "bash \"$SCRIPTS_DIR/../tests/test_opencode_plugin_adapter.sh\""
+run_check "Rust Migration Plan (compatibility-first contract)" "bash \"$SCRIPTS_DIR/../tests/test_rust_migration_plan.sh\""
+run_check "Database Repair (safe preview and recovery failure path)" "bash \"$SCRIPTS_DIR/../tests/test_repair.sh\""
+run_check "Trust Surfaces (DB integrity, JSON errors, statusline)" "bash \"$SCRIPTS_DIR/../tests/test_trust_surfaces.sh\""
+run_check "Recall Observability (UserPromptSubmit recall event)" "bash \"$SCRIPTS_DIR/../tests/test_recall_observability.sh\""
+run_check "Eagle Event Log (hook/action observability)" "bash \"$SCRIPTS_DIR/../tests/test_eagle_events.sh\""
+run_check "Dashboard Surface (local HTML memory view)" "bash \"$SCRIPTS_DIR/../tests/test_dashboard.sh\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then

package/scripts/uninstall.sh

@@ -11,6 +11,7 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$SCRIPTS_DIR/style.sh"
 . "$LIB_DIR/common.sh"
 . "$LIB_DIR/codex-hooks.sh"
+. "$LIB_DIR/opencode-hooks.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
 dry_run=false
@@ -66,6 +67,12 @@ else
     eagle_warn "Could not patch Codex hooks.json (jq not found or file missing)"
 fi
 
+if eagle_remove_opencode_plugin; then
+    eagle_ok "OpenCode plugin removed"
+else
+    eagle_info "OpenCode plugin not present or not Eagle Mem-owned"
+fi
+
 # ─── Remove instruction blocks and statusline integration ───
 
 claude_md="$HOME/.claude/CLAUDE.md"
@@ -132,6 +139,8 @@ if [ -d "$EAGLE_GROK_SKILLS_DIR" ]; then
     done
 fi
 
+eagle_remove_opencode_skills >/dev/null 2>&1 || true
+
 # ─── Optionally wipe data ─────────────────────────────────
 
 if [ -d "$EAGLE_MEM_DIR" ]; then

package/scripts/update.sh

@@ -16,11 +16,13 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$LIB_DIR/updater.sh"
 . "$LIB_DIR/hooks.sh"
 . "$LIB_DIR/codex-hooks.sh"
+. "$LIB_DIR/opencode-hooks.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
 claude_found=false
 codex_found=false
 grok_found=false
+opencode_found=false
 
 eagle_header "Update"
 
@@ -43,8 +45,11 @@ fi
 if [ -d "$EAGLE_GROK_DIR" ]; then
     grok_found=true
 fi
+if eagle_opencode_detected; then
+    opencode_found=true
+fi
 
-eagle_runtime_change_plan "update" "$PACKAGE_DIR" "$claude_found" "$codex_found"
+eagle_runtime_change_plan "update" "$PACKAGE_DIR" "$claude_found" "$codex_found" "$opencode_found"
 
 # ─── Update files ──────────────────────────────────────────
 
@@ -82,11 +87,12 @@ fi
 
 if [ "$claude_found" = true ] && [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
     # Clean old registrations before re-registering (handles matcher changes across versions)
+    eagle_clean_hook_entries "$SETTINGS" "Stop" "$EAGLE_MEM_DIR/hooks/stop.sh"
     eagle_clean_hook_entries "$SETTINGS" "PostToolUse" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     eagle_clean_hook_entries "$SETTINGS" "PreToolUse" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
 
     eagle_patch_hook "$SETTINGS" "SessionStart" "" "$EAGLE_MEM_DIR/hooks/session-start.sh"
-    eagle_patch_hook "$SETTINGS" "Stop" "" "$EAGLE_MEM_DIR/hooks/stop.sh"
+    eagle_patch_hook "$SETTINGS" "Stop" "" "bash \"$EAGLE_MEM_DIR/hooks/stop.sh\""
     eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskUpdate" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     eagle_patch_hook "$SETTINGS" "TaskCreated" "" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     eagle_patch_hook "$SETTINGS" "TaskCompleted" "" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
@@ -94,6 +100,9 @@ if [ "$claude_found" = true ] && [ -f "$SETTINGS" ] && command -v jq &>/dev/null
     eagle_patch_hook "$SETTINGS" "UserPromptSubmit" "" "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh"
     eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash|Read|Edit|Write" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
 
+    # Allow agent-issued session capture to run without a permission prompt
+    eagle_patch_permission_allow "$SETTINGS" "Bash(eagle-mem session save:*)"
+
     eagle_ok "Hooks registered"
 fi
 
@@ -104,6 +113,12 @@ elif [ "$codex_found" = false ]; then
     eagle_info "Codex hooks skipped ${DIM}(Codex not detected)${RESET}"
 fi
 
+if [ "$opencode_found" = true ]; then
+    eagle_install_opencode_plugin "$PACKAGE_DIR" "0"
+else
+    eagle_info "OpenCode plugin skipped ${DIM}(OpenCode not detected)${RESET}"
+fi
+
 # ─── Update skill symlinks ────────────────────────────────
 
 if [ "$claude_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
@@ -164,6 +179,10 @@ if [ "$grok_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
     eagle_ok "Grok skills updated"
 fi
 
+if [ "$opencode_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
+    eagle_install_opencode_skills "$PACKAGE_DIR" "0"
+fi
+
 # ─── Refresh generated Claude statusline wrapper ───────────
 
 statusline_wrapper="$EAGLE_MEM_DIR/scripts/statusline-wrapper.sh"

package/tests/fixtures/agent-hooks/claude-statusline.json

@@ -0,0 +1,32 @@
+{
+  "hook_event_name": "Status",
+  "session_id": "claude-status-fixture",
+  "transcript_path": "/tmp/eagle-mem/claude-status-fixture.jsonl",
+  "cwd": "/tmp/eagle-mem/project",
+  "model": {
+    "id": "claude-opus-4-1",
+    "display_name": "Opus"
+  },
+  "workspace": {
+    "current_dir": "/tmp/eagle-mem/project",
+    "project_dir": "/tmp/eagle-mem/project"
+  },
+  "version": "2.1.145",
+  "output_style": {
+    "name": "default"
+  },
+  "cost": {
+    "total_cost_usd": 0.01234,
+    "total_duration_ms": 45000,
+    "total_api_duration_ms": 2300,
+    "total_lines_added": 12,
+    "total_lines_removed": 2
+  },
+  "thinking": {
+    "enabled": true
+  },
+  "effort": {
+    "level": "xhigh"
+  }
+}
+

package/tests/fixtures/agent-hooks/claude-user-prompt-submit.json

@@ -0,0 +1,9 @@
+{
+  "session_id": "claude-session-fixture",
+  "transcript_path": "/tmp/eagle-mem/claude-session-fixture.jsonl",
+  "cwd": "/tmp/eagle-mem/project",
+  "permission_mode": "default",
+  "hook_event_name": "UserPromptSubmit",
+  "prompt": "Review the OAuth memory before editing auth files"
+}
+

package/tests/fixtures/agent-hooks/codex-pre-tool-use.json

@@ -0,0 +1,10 @@
+{
+  "session_id": "codex-session-fixture",
+  "cwd": "/tmp/eagle-mem/project",
+  "hook_event_name": "PreToolUse",
+  "tool_name": "Bash",
+  "tool_input": {
+    "command": "git status --short"
+  }
+}
+

package/tests/fixtures/agent-hooks/codex-user-prompt-submit.json

@@ -0,0 +1,7 @@
+{
+  "session_id": "codex-session-fixture",
+  "cwd": "/tmp/eagle-mem/project",
+  "hook_event_name": "UserPromptSubmit",
+  "prompt": "Review the OAuth memory before editing auth files"
+}
+

package/tests/fixtures/agent-hooks/opencode-chat-message.json

@@ -0,0 +1,36 @@
+{
+  "sessionID": "opencode-session-fixture",
+  "input": {
+    "sessionID": "opencode-session-fixture",
+    "agent": "build",
+    "model": {
+      "providerID": "openai",
+      "modelID": "gpt-5"
+    },
+    "messageID": "opencode-user-message-fixture"
+  },
+  "output": {
+    "message": {
+      "id": "opencode-user-message-fixture",
+      "sessionID": "opencode-session-fixture",
+      "role": "user",
+      "time": {
+        "created": 1780372800000
+      },
+      "agent": "build",
+      "model": {
+        "providerID": "openai",
+        "modelID": "gpt-5"
+      }
+    },
+    "parts": [
+      {
+        "id": "opencode-text-part-fixture",
+        "sessionID": "opencode-session-fixture",
+        "messageID": "opencode-user-message-fixture",
+        "type": "text",
+        "text": "Review the OAuth memory before editing auth files"
+      }
+    ]
+  }
+}

package/tests/fixtures/agent-hooks/opencode-session-compacting.json

@@ -0,0 +1,9 @@
+{
+  "input": {
+    "sessionID": "opencode-session-fixture"
+  },
+  "output": {
+    "context": [],
+    "prompt": null
+  }
+}