eagle-mem 4.14.0 → 4.15.0

package/CHANGELOG.md

@@ -4,6 +4,35 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.15.0 PreCompact Synchronous Capture
+
+A new lifecycle hook that captures a rich session summary **before** Claude Code compacts the context window — closing the auto-compaction gap.
+
+- **Why.** Eagle Mem already survived compaction via per-turn `Stop` capture + `SessionStart(source=compact)` rehydration. But the *rich* (LLM-enriched) summary is produced by a `nohup` background job (`scripts/enrich-summary.sh`) the `Stop` hook fires, so on auto-compaction it can land *after* the window collapses rather than before. `PreCompact` was listed as relied-upon in the compatibility doc but had no implementation.
+- **What.** New `hooks/pre-compact.sh` runs on the `PreCompact` event (both `manual` and `auto` matchers, since PreCompact's matcher *is* the trigger). It resolves the project, **skips** when an agent-authored `eagle-mem session save` already exists (that capture is richer and already survives), extracts the recent assistant transcript text, and runs `scripts/enrich-summary.sh` **synchronously** so the enriched summary is persisted before compaction. PreCompact fires rarely, so it can afford the LLM call the fast `Stop` path defers for speed.
+- **Safety.** It is side-effect-only per the hooks contract (it *can* block via exit 2 but **never does** — it always `exit 0`), never overwrites an agent row (`enrich-summary.sh` is fill-only over `capture_source = agent`), redacts before sending transcript text to a provider, and degrades to a no-op when no provider is configured (the `Stop` heuristic summary already covers that case). No change to `Stop`, `enrich-summary.sh`, or any stdin/stdout/exit contract.
+- **Registration.** `lib/hooks.sh:eagle_register_claude_hooks` (the single source of truth `install.sh` and `update.sh` both call) cleans then registers `PreCompact` for `manual` and `auto`. `eagle-mem update` adds it to existing installs automatically.
+
+New coverage: `tests/test_precompact_capture.sh` (synchronous enrichment via a stubbed provider, agent-summary no-clobber, no-provider graceful path, never-blocks, both matchers) and `tests/fixtures/agent-hooks/claude-pre-compact.json`. Compatibility evidence: `docs/agent-compatibility/claude-code.md`.
+
+---
+
+## v4.14.1 busy_timeout Echo Fix
+
+A latent data-corruption and statusline-display bug, introduced when `busy_timeout` protection was added to three hot SQLite paths (the 2026-06-10 data-integrity hardening). No new feature; pure correctness.
+
+- **Root cause.** Setting the busy timeout with an inline value-form `PRAGMA busy_timeout=10000;` run in the *same* `sqlite3` invocation as a `SELECT` makes SQLite echo the timeout value (`10000`) as the **first output row**. Any caller that reads the first line then mis-reads `10000` as query data.
+- **Impact (all three fixed).**
+  - `scripts/statusline-em.sh`: the HUD parsed the echoed `10000` as the session count, rendering `Sessions: 10000`, `Memories: 0`, `Last: never`.
+  - `lib/common.sh` `eagle_get_session_project_light`: returned `10000` as the project, **mis-filing sessions under a phantom `10000` project key** (the data-corruption vector).
+  - `lib/common.sh` `eagle_project_has_table_row`: the echoed value failed the `= "1"` test, so it **always reported "no row"**, breaking ancestor-project repair.
+- **Fix.** All three set the timeout via the silent `-cmd ".timeout 10000"` dot-command, which emits no row. No SQL behavior, hook contract, statusline schema, or output format changes — only the timeout-set mechanism. `db/migrate.sh` (uses `tail -n1`) and the `.output`-bracketed setups in `lib/db-core.sh` were already echo-safe and are unchanged.
+- **No data migration needed for most installs.** The corruption only accrues while running unpatched code, and only affects session→project tags. The release ships the durable source fix so `eagle-mem update` can no longer reintroduce the bug.
+
+New coverage: `tests/test_busy_timeout_echo.sh` (reproduces the failure — buggy form returns `10000`/always-false — plus a structural guard against re-introducing the inline value-PRAGMA-before-SELECT shape). Compatibility evidence: `docs/agent-compatibility/claude-code.md`.
+
+---
+
 ## v4.14.0 Governance Parity & Curator Provenance
 
 Two trust-surface features that close the remaining governance gaps from the v4.13.0 review.

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

@@ -1,6 +1,6 @@
 # Claude Code Compatibility
 
-Last verified: 2026-06-10
+Last verified: 2026-06-13
 
 ## Official Sources
 
@@ -28,6 +28,7 @@ Last verified: 2026-06-10
 - The installer adds `permissions.allow: ["Bash(eagle-mem session save:*)"]` to Claude settings so the capture runs without a permission prompt. The instruction must use that exact command prefix (no leading path, no `cd &&`) for the permission to match.
 - Agent-authored captures are authoritative (`capture_source = agent`). The `Stop` hook still parses any `<eagle-summary>` block for backward compatibility, but when an agent row already exists its heuristics only fill empty fields and background enrichment is skipped — neither can clobber agent data.
 - `UserPromptSubmit` context-pressure nudges (≥20 / ≥30 turns) also point at `eagle-mem session save`, not the raw block.
+- `PreCompact` (matchers `manual` and `auto`) runs `hooks/pre-compact.sh`, which captures a rich summary **synchronously before** the window collapses. Routine `Stop` defers LLM enrichment to a `nohup` background job (`scripts/enrich-summary.sh`) for speed; PreCompact fires rarely, so it runs that same enricher inline, guaranteeing the rich summary is persisted before compaction rather than racing it. It never blocks compaction (always exits 0) and never overwrites an agent-authored `eagle-mem session save` (it skips when `capture_source = agent`). The compacted window is then rehydrated by `SessionStart(source=compact)`.
 - On install/update the managed `## Eagle Mem — Persistent Memory` section in `~/.claude/CLAUDE.md` is rewritten to this CLI-first doctrine whenever it predates it. Detection keys on the absence of the current section's `session save --session-id` sentinel (v4.12.1 fixed a `grep -F` escaping bug that left the section — and therefore the clean-capture behavior — un-updated). Covered by `tests/test_claude_md_capture_doctrine.sh`.
 
 ## Eagle Mem Files Depending On This
@@ -41,6 +42,7 @@ Last verified: 2026-06-10
 - `hooks/user-prompt-submit.sh`
 - `hooks/pre-tool-use.sh`
 - `hooks/post-tool-use.sh`
+- `hooks/pre-compact.sh`
 - `hooks/stop.sh`
 - `hooks/session-end.sh`
 
@@ -48,9 +50,11 @@ Last verified: 2026-06-10
 
 - `tests/fixtures/agent-hooks/claude-user-prompt-submit.json`
 - `tests/fixtures/agent-hooks/claude-statusline.json`
+- `tests/fixtures/agent-hooks/claude-pre-compact.json`
 - `tests/test_agent_compatibility_docs_gate.sh`
 - `tests/test_recall_observability.sh`
 - `tests/test_compaction_survival_matrix.sh`
+- `tests/test_precompact_capture.sh`
 - `tests/test_trust_surfaces.sh`
 
 ## Reverification Notes
@@ -84,3 +88,21 @@ Phase 4 token-economy hardening added a generous global size ceiling on the reca
 
 Covered by `tests/test_context_budget.sh`.
 
+### Evidence: busy_timeout echo fix (2026-06-13)
+
+Corrects a regression introduced by the 2026-06-10 data-integrity note above. Setting the SQLite busy timeout with an inline value-form `PRAGMA busy_timeout=10000;` run in the *same* `sqlite3` invocation as a `SELECT` echoes the timeout value (`10000`) as the first output row. Any caller that reads the first row then misreads `10000` as data. The earlier note's claim that "statusline output rendering [is] unchanged" was therefore wrong — the statusline showed `Sessions: 10000`, `Memories: 0`. The fix sets the timeout via the silent `-cmd ".timeout 10000"` dot-command (no echoed row); no Claude Code contract changes (hook events, statusline stdin schema, and stdout/exit semantics are all unchanged). Specifically:
+
+- `scripts/statusline-em.sh`: the stats query drops the inline `PRAGMA busy_timeout=10000;` prefix and passes `-cmd ".timeout 10000"` to `sqlite3` instead, so `IFS='|' read` parses the real `sessions|memories|last` row rather than the echoed `10000`.
+- `lib/common.sh`: `eagle_get_session_project_light` (was returning `10000` as the project, mis-filing sessions under a phantom `10000` project key) and `eagle_project_has_table_row` (whose `= "1"` test always failed on the echoed value, so ancestor-project repair always saw "no row") use the same `-cmd ".timeout"` form.
+
+Covered by `tests/test_busy_timeout_echo.sh` (reproduces the failure: the buggy form returns `10000`/always-false; also a structural guard against re-introducing the inline value-PRAGMA-before-SELECT shape).
+
+### Evidence: PreCompact synchronous capture (2026-06-13)
+
+`PreCompact` was previously listed under "Behavior Relied On" but had no implementation — Eagle Mem relied solely on per-turn `Stop` capture plus `SessionStart(source=compact)` rehydration. That covers compaction survival, but the rich (LLM-enriched) summary is produced by a `nohup` background job (`scripts/enrich-summary.sh`) the `Stop` hook fires, so for auto-compaction it can land *after* the window collapses rather than before. Verified against the hooks reference (https://code.claude.com/docs/en/hooks): `PreCompact` receives `session_id`, `transcript_path`, `cwd`, `hook_event_name`, `trigger` (`manual`|`auto`); its matcher is the trigger; it can block (exit 2) but cannot inject `additionalContext` into the compacted window. So the new hook is side-effect-only and uses the boundary purely to persist a rich summary first.
+
+- `hooks/pre-compact.sh` (new): on `PreCompact` it resolves the project, skips when an agent-authored summary already exists (`capture_source = agent`), extracts the recent assistant transcript text, and runs `scripts/enrich-summary.sh` **synchronously** so the enriched summary is written before compaction. It always `exit 0` (never blocks compaction) and emits a `compaction_capture` event. No change to `Stop`, `enrich-summary.sh`, or any stdin/stdout/exit contract.
+- `lib/hooks.sh`: `eagle_register_claude_hooks` cleans then registers `PreCompact` for both the `manual` and `auto` matchers (the trigger-as-matcher contract), so auto-compaction is covered. `install.sh` and `update.sh` both call this single registration site.
+
+Covered by `tests/test_precompact_capture.sh` (synchronous enrichment via a stubbed provider, agent-summary no-clobber, no-provider graceful path, never-blocks, and both matchers registered) and `tests/fixtures/agent-hooks/claude-pre-compact.json`.
+

package/hooks/pre-compact.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — PreCompact hook
+# Fires before Claude Code compacts the context window (manual or auto).
+#
+# PreCompact is a side-effect-only event: per the Claude Code hooks contract it
+# can block compaction but CANNOT inject context into the compacted window — that
+# is SessionStart(source=compact)'s job. What it CAN do is guarantee a rich
+# session summary is persisted *before* the window collapses, instead of racing
+# the async background enricher that the Stop hook queues with nohup.
+#
+# So this hook runs scripts/enrich-summary.sh SYNCHRONOUSLY. PreCompact fires
+# rarely (once per compaction), so it can afford the LLM enrichment call that the
+# fast Stop path deliberately defers for speed. It NEVER blocks compaction (always
+# exits 0) and NEVER overwrites an agent-authored `eagle-mem session save`, which
+# is already the richest capture and already survives compaction via SessionStart.
+# ═══════════════════════════════════════════════════════════
+set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPT_DIR/../lib"
+
+. "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
+
+eagle_ensure_db
+
+input=$(eagle_read_stdin)
+[ -z "$input" ] && exit 0
+
+IFS=$'\x1f' read -r session_id cwd transcript_path trigger <<< \
+    "$(echo "$input" | jq -r '[.session_id, .cwd, .transcript_path, .trigger] | map(. // "") | join("")')"
+agent=$(eagle_agent_source_from_json "$input")
+
+[ -z "$session_id" ] && exit 0
+
+project=$(eagle_project_from_hook_input "$input")
+[ -z "$project" ] && exit 0
+
+eagle_hook_observability_begin "$input" "PreCompact"
+eagle_log "INFO" "PreCompact: trigger=${trigger:-unknown} session=$session_id project=$project — capturing summary before compaction"
+
+# Bound any synchronous work. The agent_cli provider shells out to a nested
+# claude/codex CLI with NO internal timeout (provider.sh bounds only the
+# curl-based API calls), so a hung provider could otherwise stall compaction up
+# to the Claude Code hook timeout and be killed mid-write. We cap it and proceed;
+# a missed synchronous enrichment is still covered by Stop's background path and
+# the next SessionStart. Portable across macOS (timeout may be absent).
+EAGLE_PRECOMPACT_TIMEOUT="${EAGLE_MEM_PRECOMPACT_TIMEOUT:-45}"
+eagle_run_bounded() {
+    local secs="$1"; shift
+    if command -v timeout >/dev/null 2>&1; then
+        timeout "${secs}s" "$@"
+    elif command -v gtimeout >/dev/null 2>&1; then
+        gtimeout "${secs}s" "$@"
+    else
+        "$@" &
+        local pid=$!
+        ( sleep "$secs"; kill -TERM "$pid" 2>/dev/null ) >/dev/null 2>&1 &
+        local watcher=$!
+        wait "$pid" 2>/dev/null
+        local rc=$?
+        kill -TERM "$watcher" 2>/dev/null
+        return "$rc"
+    fi
+}
+
+# Session may not exist yet if SessionStart didn't fire (or fired for a sibling).
+eagle_upsert_session "$session_id" "$project" "$cwd" "" "" "$agent"
+
+emit_capture_event() {
+    local captured="$1" mode="$2"
+    eagle_insert_event "$project" "$session_id" "$agent" "compaction_capture" "" "PreCompact" "ok" \
+        "$(jq -nc --arg trigger "${trigger:-}" --arg mode "$mode" --argjson captured "$captured" \
+            '{trigger:$trigger, captured:$captured, mode:$mode}')" >/dev/null 2>&1 || true
+    eagle_hook_observability_set_detail \
+        "$(jq -nc --arg trigger "${trigger:-}" --arg mode "$mode" --argjson captured "$captured" \
+            '{trigger:$trigger, captured:$captured, mode:$mode}')"
+}
+
+# An agent-authored `eagle-mem session save` is the richest possible capture and
+# is authoritative. If one already exists for this session it already survives
+# compaction (SessionStart reloads it), so don't spend an LLM call or risk a
+# write race against it.
+existing_source=$(eagle_summary_capture_source "$session_id" 2>/dev/null || true)
+if [ "$existing_source" = "agent" ]; then
+    eagle_log "INFO" "PreCompact: agent-authored summary already present for session=$session_id — skipping enrichment"
+    emit_capture_event false "agent-summary-present"
+    eagle_hook_observability_complete 0
+    exit 0
+fi
+
+# Latest assistant text from the transcript (Claude format). The same surface the
+# Stop hook hands the enricher; enrich-summary.sh bounds it to a tail excerpt
+# before sending it to the provider.
+text_content=""
+if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
+    text_content=$(jq -r -s '
+        [.[] | select(.type == "assistant")]
+        | (.[-5:] // [])
+        | [.[] | .message.content[]? | select(.type == "text") | .text]
+        | join("\n")
+    ' "$transcript_path" 2>/dev/null)
+fi
+
+captured=false
+mode="no-text"
+if [ -n "$text_content" ]; then
+    provider=$(eagle_config_get "provider" "type" "none" 2>/dev/null)
+    if [ "$provider" = "none" ]; then
+        # No provider — the Stop hook's heuristic summary already covers this
+        # session and survives compaction; nothing richer to do here.
+        mode="no-provider"
+        eagle_log "INFO" "PreCompact: no provider configured — Stop heuristic summary covers session=$session_id"
+    else
+        mkdir -p "$EAGLE_MEM_DIR/tmp" 2>/dev/null || true
+        enrich_job=$(mktemp "$EAGLE_MEM_DIR/tmp/precompact-enrich.XXXXXX.json" 2>/dev/null)
+        if [ -n "$enrich_job" ]; then
+            # Redact secrets BEFORE persisting/sending the transcript text.
+            enrich_text=$(printf '%s' "$text_content" | eagle_redact)
+            jq -cn \
+                --arg session_id "$session_id" \
+                --arg project "$project" \
+                --arg agent "$agent" \
+                --arg text "$enrich_text" \
+                '{session_id:$session_id, project:$project, agent:$agent, text:$text}' > "$enrich_job"
+
+            enrich_script="$SCRIPT_DIR/../scripts/enrich-summary.sh"
+            if [ -f "$enrich_script" ]; then
+                # SYNCHRONOUS (not nohup): the point of PreCompact is to land the
+                # rich summary before the window collapses. enrich-summary.sh
+                # respects capture_source precedence (fill-only over an agent row),
+                # exits 0 on provider/LLM failure, and removes its own job file.
+                # Time-bounded so a hung provider can never stall compaction.
+                eagle_run_bounded "$EAGLE_PRECOMPACT_TIMEOUT" \
+                    env EAGLE_MEM_DISABLE_HOOKS=1 EAGLE_AGENT_SOURCE="$agent" EAGLE_AGENT_CWD="$cwd" \
+                    bash "$enrich_script" "$enrich_job" >/dev/null 2>&1
+                erc=$?
+                # Clean up the job file if enrich-summary was killed mid-run (it
+                # removes its own on a normal exit).
+                rm -f "$enrich_job" 2>/dev/null || true
+                if [ "$erc" -eq 0 ]; then
+                    captured=true
+                    mode="enriched"
+                    eagle_log "INFO" "PreCompact: synchronous enrichment complete for session=$session_id provider=$provider"
+                else
+                    mode="enrich-timeout-or-error"
+                    eagle_log "WARN" "PreCompact: synchronous enrichment did not complete (rc=$erc) for session=$session_id — Stop background path will cover it"
+                fi
+            else
+                rm -f "$enrich_job" 2>/dev/null || true
+                mode="enricher-missing"
+                eagle_log "WARN" "PreCompact: enrichment script missing: $enrich_script"
+            fi
+        fi
+    fi
+fi
+
+emit_capture_event "$captured" "$mode"
+eagle_hook_observability_complete 0
+exit 0

package/lib/common.sh

@@ -456,9 +456,12 @@ eagle_get_session_project_light() {
 
     local sid_sql project
     sid_sql=$(eagle_sql_escape "$session_id")
-    # busy_timeout so a momentary SQLITE_BUSY waits for the lock instead of
-    # exiting non-zero and being misread as "session has no project" (fail-open).
-    project=$("$sqlite_bin" "$EAGLE_MEM_DB" "PRAGMA busy_timeout=10000; SELECT project FROM sessions WHERE id = '$sid_sql' AND project != '' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
+    # busy_timeout (via the silent `-cmd ".timeout"` dot-command, NOT an inline
+    # `PRAGMA busy_timeout=N;`) so a momentary SQLITE_BUSY waits for the lock
+    # instead of exiting non-zero and being misread as "session has no project"
+    # (fail-open). An inline value-setting PRAGMA echoes its value ("10000") as
+    # the first output row, which `awk 'NF{...}'` would then return as the project.
+    project=$("$sqlite_bin" -cmd ".timeout 10000" "$EAGLE_MEM_DB" "SELECT project FROM sessions WHERE id = '$sid_sql' AND project != '' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
     [ -n "$project" ] || return 1
     printf '%s\n' "$project"
 }
@@ -481,9 +484,12 @@ eagle_project_has_table_row() {
 
     local project_sql found
     project_sql=$(eagle_sql_escape "$project")
-    # busy_timeout so a momentary SQLITE_BUSY waits for the lock instead of
-    # exiting non-zero and being misread as "row doesn't exist" (fail-open).
-    found=$("$sqlite_bin" "$EAGLE_MEM_DB" "PRAGMA busy_timeout=10000; SELECT 1 FROM $table WHERE project = '$project_sql' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
+    # busy_timeout (via the silent `-cmd ".timeout"` dot-command, NOT an inline
+    # `PRAGMA busy_timeout=N;`) so a momentary SQLITE_BUSY waits for the lock
+    # instead of exiting non-zero and being misread as "row doesn't exist"
+    # (fail-open). An inline value-setting PRAGMA echoes its value ("10000") as
+    # the first output row, which would then fail the `= "1"` test below.
+    found=$("$sqlite_bin" -cmd ".timeout 10000" "$EAGLE_MEM_DB" "SELECT 1 FROM $table WHERE project = '$project_sql' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
     [ "$found" = "1" ]
 }
 

package/lib/hooks.sh

@@ -116,6 +116,7 @@ eagle_register_claude_hooks() {
     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_clean_hook_entries "$settings" "PreCompact" "$EAGLE_MEM_DIR/hooks/pre-compact.sh"
 
     # ${V:+label} expands to the label only in verbose mode; otherwise to "",
     # which makes eagle_patch_hook silent (it only prints when given a description).
@@ -127,6 +128,11 @@ eagle_register_claude_hooks() {
     eagle_patch_hook "$settings" "SessionEnd" "" "$EAGLE_MEM_DIR/hooks/session-end.sh" "${V:+SessionEnd hook}"
     eagle_patch_hook "$settings" "UserPromptSubmit" "" "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh" "${V:+UserPromptSubmit hook}"
     eagle_patch_hook "$settings" "PreToolUse" "Bash|Read|Edit|Write" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" "${V:+PreToolUse hook}"
+    # PreCompact's matcher is the trigger itself ("manual" | "auto"); register both
+    # so auto-compaction — the gap users actually hit — also captures before the
+    # window collapses. The hook reads `trigger` from stdin for telemetry.
+    eagle_patch_hook "$settings" "PreCompact" "manual" "$EAGLE_MEM_DIR/hooks/pre-compact.sh" "${V:+PreCompact hook (manual)}"
+    eagle_patch_hook "$settings" "PreCompact" "auto" "$EAGLE_MEM_DIR/hooks/pre-compact.sh" "${V:+PreCompact hook (auto)}"
 
     # Allow agent-issued session capture to run without a permission prompt.
     if eagle_patch_permission_allow "$settings" "Bash(eagle-mem session save:*)"; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code, Codex, OpenCode, Grok, and Google Antigravity",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/statusline-em.sh

@@ -65,11 +65,13 @@ eagle_mem_statusline_stats() {
     project_scope=$(eagle_recall_project_scope_from_cwd "${current_dir:-$project_dir}" "$project_key")
     project_condition=$(eagle_sql_project_scope_condition "project" "$project_scope")
 
-    # busy_timeout so a momentary SQLITE_BUSY (this is the hottest standalone
-    # query during live sessions) waits for the lock instead of exiting non-zero,
-    # which would otherwise escalate to an integrity-status mislabel below.
-    stats=$("$sqlite_bin" "$em_db" "PRAGMA busy_timeout=10000;
-        SELECT
+    # busy_timeout (via the silent `-cmd ".timeout"` dot-command, NOT an inline
+    # `PRAGMA busy_timeout=N;`) so a momentary SQLITE_BUSY (this is the hottest
+    # standalone query during live sessions) waits for the lock instead of exiting
+    # non-zero, which would otherwise escalate to an integrity-status mislabel below.
+    # An inline value-setting PRAGMA echoes "10000" as the first output row, which
+    # the `IFS='|' read` below would parse as sessions=10000, memories=0, last=never.
+    stats=$("$sqlite_bin" -cmd ".timeout 10000" "$em_db" "SELECT
         COUNT(*) || '|' ||
         (SELECT COUNT(*) FROM agent_memories WHERE $project_condition) || '|' ||
         COALESCE(MAX(COALESCE(last_activity_at, started_at)), 'never')

package/scripts/test.sh

@@ -96,6 +96,8 @@ run_check "Test Runner No-Abort (failing check does not kill the suite under set
 run_check "Antigravity Hook (native Python SDK lifecycle, mocked)" "( command -v python3 >/dev/null 2>&1 || exit 2; python3 \"$SCRIPTS_DIR/../tests/test_antigravity_hook.py\" )"
 run_check "Release Gate Parity (eagle-mem gate: blocks pending, fails open, pre-push install)" "bash \"$SCRIPTS_DIR/../tests/test_release_gate_prepush.sh\""
 run_check "Command Rule Provenance (curator rules tagged + trust_learned_rules gate)" "bash \"$SCRIPTS_DIR/../tests/test_command_rule_provenance.sh\""
+run_check "busy_timeout Echo (no PRAGMA value leaks into project/row/statusline reads)" "bash \"$SCRIPTS_DIR/../tests/test_busy_timeout_echo.sh\""
+run_check "PreCompact Capture (synchronous rich summary before compaction, both matchers, no agent clobber)" "bash \"$SCRIPTS_DIR/../tests/test_precompact_capture.sh\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then

package/scripts/uninstall.sh

@@ -40,7 +40,7 @@ fi
 
 if [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
     settings_backup=$(eagle_backup_user_file "$SETTINGS" 2>/dev/null || true)
-    for event in SessionStart Stop PostToolUse PreToolUse SessionEnd UserPromptSubmit; do
+    for event in SessionStart Stop PostToolUse PreToolUse PreCompact SessionEnd UserPromptSubmit TaskCreated TaskCompleted; do
         if jq -e ".hooks.${event}" "$SETTINGS" &>/dev/null; then
             tmp=$(mktemp)
             jq ".hooks.${event} = [.hooks.${event}[]? | select(any(.hooks[]?; .command | contains(\"eagle-mem\")) | not)]" "$SETTINGS" > "$tmp" && mv "$tmp" "$SETTINGS"

package/tests/fixtures/agent-hooks/claude-pre-compact.json

@@ -0,0 +1,7 @@
+{
+  "session_id": "claude-precompact-fixture-session",
+  "transcript_path": "/tmp/eagle-mem-precompact-fixture.jsonl",
+  "cwd": "/tmp/eagle-mem-precompact-fixture",
+  "hook_event_name": "PreCompact",
+  "trigger": "auto"
+}

package/tests/test_busy_timeout_echo.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — busy_timeout echo regression test
+#
+# Root cause guarded here: an inline value-setting `PRAGMA busy_timeout=N;`
+# run in the SAME sqlite3 invocation as a SELECT echoes its value ("10000")
+# as the FIRST output row. Any caller that reads the first line then mis-reads
+# the timeout value as data:
+#   - eagle_get_session_project_light -> returns "10000" as the project,
+#     mis-filing every session under a phantom "10000" project.
+#   - eagle_project_has_table_row -> `[ "10000" = "1" ]` is false, so it
+#     ALWAYS reports "no row", breaking ancestor-project repair.
+#   - statusline stats -> `IFS='|' read` parses "10000" as sessions, 0 memories.
+# The fix sets the timeout via the silent `-cmd ".timeout"` dot-command, which
+# emits no output. This test reproduces the failure (buggy code returns 10000
+# / always-false) and structurally guards against re-introducing the shape.
+# ═══════════════════════════════════════════════════════════
+set -uo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+tmp_dir=$(mktemp -d)
+trap 'rm -rf "$tmp_dir"' EXIT
+
+export EAGLE_MEM_DIR="$tmp_dir/em"
+export EAGLE_AGENT_SOURCE="claude-code"
+export EAGLE_MEM_DISABLE_HOOKS=1
+mkdir -p "$EAGLE_MEM_DIR"
+
+pass=0; fail=0
+ok()  { echo "  ok: $1"; pass=$((pass+1)); }
+bad() { echo "  FAIL: $1" >&2; fail=$((fail+1)); }
+
+bash "$ROOT_DIR/db/migrate.sh" >/dev/null 2>&1
+
+. "$ROOT_DIR/lib/common.sh"
+. "$ROOT_DIR/lib/db.sh"
+
+# ── eagle_get_session_project_light returns the real project ────────────────
+SID="sess-busy-timeout-001"
+PROJ="personal_projects/eagle-mem"
+eagle_upsert_session "$SID" "$PROJ" "$tmp_dir" "" "test" "claude-code"
+
+got=$(eagle_get_session_project_light "$SID")
+if [ "$got" = "10000" ]; then
+    bad "eagle_get_session_project_light returned the busy_timeout echo ('10000') as the project"
+elif [ "$got" = "$PROJ" ]; then
+    ok "eagle_get_session_project_light returns the real project ('$got')"
+else
+    bad "eagle_get_session_project_light returned unexpected value: '$got' (expected '$PROJ')"
+fi
+
+# Unknown session must resolve to nothing (rc=1), never the echo value.
+if unknown=$(eagle_get_session_project_light "sess-does-not-exist-999"); then
+    bad "eagle_get_session_project_light succeeded for unknown session, returned '$unknown'"
+else
+    ok "eagle_get_session_project_light fails closed for unknown session"
+fi
+
+# ── eagle_project_has_table_row: true for present, false for absent ──────────
+if eagle_project_has_table_row "sessions" "$PROJ"; then
+    ok "eagle_project_has_table_row finds the existing project row"
+else
+    bad "eagle_project_has_table_row reports 'no row' for a project that HAS a row (busy_timeout echo broke the '= 1' test)"
+fi
+
+if eagle_project_has_table_row "sessions" "no/such/project-xyz"; then
+    bad "eagle_project_has_table_row reports a row for a project with none"
+else
+    ok "eagle_project_has_table_row correctly reports no row for an absent project"
+fi
+
+# ── Structural guard: no inline value-setting PRAGMA before a parsed SELECT ──
+# (comment lines are stripped so the explanatory comments above don't match)
+common_hit=$(grep -vE '^[[:space:]]*#' "$ROOT_DIR/lib/common.sh" | grep -nE 'busy_timeout=[0-9]+;[[:space:]]*SELECT' || true)
+if [ -n "$common_hit" ]; then
+    bad "lib/common.sh re-introduced an inline 'PRAGMA busy_timeout=N; SELECT' (echoes the value): $common_hit"
+else
+    ok "lib/common.sh has no inline value-setting PRAGMA before a SELECT"
+fi
+
+statusline_hit=$(grep -vE '^[[:space:]]*#' "$ROOT_DIR/scripts/statusline-em.sh" | grep -nE 'busy_timeout' || true)
+if [ -n "$statusline_hit" ]; then
+    bad "scripts/statusline-em.sh re-introduced an inline PRAGMA busy_timeout (use -cmd \".timeout\"): $statusline_hit"
+else
+    ok "scripts/statusline-em.sh sets the timeout via the silent -cmd \".timeout\" dot-command"
+fi
+
+echo
+echo "busy_timeout echo regression: $pass passed, $fail failed"
+[ "$fail" -eq 0 ]

package/tests/test_precompact_capture.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — PreCompact capture regression test
+#
+# Guards the contract of hooks/pre-compact.sh (synchronous rich capture before
+# Claude Code compacts the window):
+#   1. Registers for BOTH "manual" and "auto" matchers (auto is the real gap).
+#   2. With a provider, runs enrich-summary.sh SYNCHRONOUSLY so the rich summary
+#      is persisted before compaction (capture_source = enrich).
+#   3. Never overwrites an agent-authored summary (capture_source = agent).
+#   4. Degrades gracefully with no provider, and ALWAYS exits 0 (never blocks
+#      compaction — it must never exit 2).
+# ═══════════════════════════════════════════════════════════
+set -uo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+tmp_dir=$(mktemp -d)
+trap 'rm -rf "$tmp_dir"' EXIT
+
+export EAGLE_MEM_DIR="$tmp_dir/em"
+export EAGLE_AGENT_SOURCE="claude-code"
+mkdir -p "$EAGLE_MEM_DIR"
+
+pass=0; fail=0
+ok()  { echo "  ok: $1"; pass=$((pass+1)); }
+bad() { echo "  FAIL: $1" >&2; fail=$((fail+1)); }
+
+bash "$ROOT_DIR/db/migrate.sh" >/dev/null 2>&1
+
+. "$ROOT_DIR/lib/common.sh"
+. "$ROOT_DIR/lib/db.sh"
+. "$ROOT_DIR/lib/hooks.sh"
+
+PRECOMPACT="$ROOT_DIR/hooks/pre-compact.sh"
+
+# A minimal Claude-format transcript with assistant text for the enricher.
+transcript="$tmp_dir/transcript.jsonl"
+{
+    printf '%s\n' '{"type":"user","message":{"content":"build a precompact hook"}}'
+    printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"I implemented the PreCompact hook with synchronous enrichment before compaction."}]}}'
+} > "$transcript"
+
+mk_input() {
+    local sid="$1" trigger="$2"
+    jq -nc \
+        --arg sid "$sid" \
+        --arg cwd "$tmp_dir/work" \
+        --arg tp "$transcript" \
+        --arg trig "$trigger" \
+        '{session_id:$sid, cwd:$cwd, transcript_path:$tp, hook_event_name:"PreCompact", trigger:$trig}'
+}
+
+# Resolve the project the hook will derive, so parent-side inserts line up.
+PROJ=$(eagle_project_from_hook_input "$(mk_input "probe" "auto")")
+[ -n "$PROJ" ] || PROJ="precompact/test"
+
+# ── 1. Registration: both matchers ──────────────────────────────────────────
+settings="$tmp_dir/settings.json"
+echo '{}' > "$settings"
+eagle_register_claude_hooks "$settings" >/dev/null 2>&1
+manual_cmd=$(jq -r '.hooks.PreCompact[]? | select(.matcher=="manual") | .hooks[].command' "$settings" 2>/dev/null)
+auto_cmd=$(jq -r '.hooks.PreCompact[]? | select(.matcher=="auto") | .hooks[].command' "$settings" 2>/dev/null)
+if echo "$manual_cmd" | grep -q 'pre-compact.sh'; then
+    ok "PreCompact registered for matcher 'manual'"
+else
+    bad "PreCompact not registered for matcher 'manual'"
+fi
+if echo "$auto_cmd" | grep -q 'pre-compact.sh'; then
+    ok "PreCompact registered for matcher 'auto' (auto-compaction covered)"
+else
+    bad "PreCompact not registered for matcher 'auto'"
+fi
+
+# ── 2. No provider: graceful, exits 0, writes no enriched summary ────────────
+SID2="precompact-noprovider-001"
+eagle_upsert_session "$SID2" "$PROJ" "$tmp_dir/work" "" "test" "claude-code"
+mk_input "$SID2" "auto" | bash "$PRECOMPACT"; rc2=$?
+if [ "$rc2" -eq 0 ]; then
+    ok "no-provider run exits 0 (never blocks compaction)"
+else
+    bad "no-provider run exited $rc2 (must be 0; exit 2 would block compaction)"
+fi
+src2=$(eagle_summary_capture_source "$SID2" 2>/dev/null || true)
+if [ -z "$src2" ]; then
+    ok "no-provider run writes no summary (Stop already covers it)"
+else
+    bad "no-provider run unexpectedly wrote a summary (capture_source='$src2')"
+fi
+
+# ── 3. Agent-authored summary is never clobbered ────────────────────────────
+SID3="precompact-agentrow-001"
+eagle_upsert_session "$SID3" "$PROJ" "$tmp_dir/work" "" "test" "claude-code"
+eagle_insert_summary "$SID3" "$PROJ" "agent req" "" "" "AGENT_ORIGINAL_COMPLETED" "" "[]" "[]" "" "" "" "" "claude-code" "agent" >/dev/null 2>&1
+mk_input "$SID3" "manual" | bash "$PRECOMPACT"; rc3=$?
+src3=$(eagle_summary_capture_source "$SID3" 2>/dev/null || true)
+comp3=$(eagle_db "SELECT completed FROM summaries WHERE session_id = '$(eagle_sql_escape "$SID3")' LIMIT 1;" 2>/dev/null)
+if [ "$rc3" -eq 0 ] && [ "$src3" = "agent" ] && [ "$comp3" = "AGENT_ORIGINAL_COMPLETED" ]; then
+    ok "agent-authored summary preserved (capture_source=agent, content intact)"
+else
+    bad "agent summary perturbed: rc=$rc3 source='$src3' completed='$comp3'"
+fi
+
+# ── 4. With a provider: synchronous enrichment writes a rich summary ─────────
+fake_bin="$tmp_dir/bin"
+mkdir -p "$fake_bin"
+cat > "$fake_bin/claude" <<'SH'
+#!/usr/bin/env bash
+cat <<'OUT'
+REQUEST:
+Build a PreCompact hook for Eagle Mem
+COMPLETED:
+Added PRECOMPACT_SYNC_CAPTURE before the window collapses
+DECISIONS:
+- Reused enrich-summary synchronously — why: guarantee rich capture before compaction
+GOTCHAS:
+- PreCompact cannot inject context, only side effects
+KEY_FILES:
+hooks/pre-compact.sh
+OUT
+SH
+chmod +x "$fake_bin/claude"
+cat > "$EAGLE_MEM_DIR/config.toml" <<'TOML'
+[provider]
+type = "agent_cli"
+fallback = "auto"
+
+[agent_cli]
+preferred = "claude"
+codex_model = ""
+claude_model = ""
+TOML
+
+SID4="precompact-enrich-001"
+eagle_upsert_session "$SID4" "$PROJ" "$tmp_dir/work" "" "test" "claude-code"
+mk_input "$SID4" "manual" | PATH="$fake_bin:$PATH" bash "$PRECOMPACT"; rc4=$?
+src4=$(eagle_summary_capture_source "$SID4" 2>/dev/null || true)
+comp4=$(eagle_db "SELECT completed FROM summaries WHERE session_id = '$(eagle_sql_escape "$SID4")' LIMIT 1;" 2>/dev/null)
+if [ "$rc4" -eq 0 ]; then
+    ok "provider run exits 0"
+else
+    bad "provider run exited $rc4 (must be 0)"
+fi
+if [ "$src4" = "enrich" ] && echo "$comp4" | grep -q 'PRECOMPACT_SYNC_CAPTURE'; then
+    ok "synchronous enrichment wrote a rich summary before compaction (capture_source=enrich)"
+else
+    bad "synchronous enrichment did not write the expected summary: source='$src4' completed='$comp4'"
+fi
+
+# ── 5. Structural guard: hook never exits 2 (would block compaction) ─────────
+if grep -nE '^[[:space:]]*exit[[:space:]]+2' "$PRECOMPACT" >/dev/null 2>&1; then
+    bad "pre-compact.sh contains 'exit 2' — PreCompact must never block compaction"
+else
+    ok "pre-compact.sh has no 'exit 2' (cannot block compaction)"
+fi
+
+echo
+echo "precompact capture: $pass passed, $fail failed"
+[ "$fail" -eq 0 ]