eagle-mem 4.10.13 → 4.11.0

package/tests/test_opencode_plugin_adapter.sh

@@ -0,0 +1,202 @@
+#!/usr/bin/env bash
+# Regression coverage for the OpenCode local plugin bridge.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-opencode-plugin.XXXXXX")
+trap 'rm -rf "$tmp_dir"' EXIT
+
+export HOME="$tmp_dir/home"
+export EAGLE_MEM_DIR="$tmp_dir/eagle-mem"
+export PROJECT_DIR="$tmp_dir/project"
+mkdir -p "$HOME" "$EAGLE_MEM_DIR/hooks" "$PROJECT_DIR" "$tmp_dir/module"
+
+fail() {
+    echo "opencode plugin adapter test failed: $*" >&2
+    exit 1
+}
+
+for required in jq node; do
+    command -v "$required" >/dev/null 2>&1 || fail "missing required command: $required"
+done
+
+cp "$ROOT_DIR/integrations/opencode_eagle_mem_plugin.js" "$tmp_dir/module/eagle-mem-plugin.js"
+printf '%s\n' '{"type":"module"}' > "$tmp_dir/module/package.json"
+export PLUGIN_PATH="$tmp_dir/module/eagle-mem-plugin.js"
+
+cat > "$EAGLE_MEM_DIR/hooks/session-start.sh" <<'HOOK'
+#!/usr/bin/env bash
+set -euo pipefail
+payload=$(cat)
+printf '%s\n' "$payload" | jq -c . >> "$EAGLE_MEM_DIR/session-start.jsonl"
+source=$(printf '%s\n' "$payload" | jq -r '.source // "startup"')
+jq -nc --arg ctx "session context: $source" '{"hookSpecificOutput":{"additionalContext":$ctx}}'
+HOOK
+
+cat > "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh" <<'HOOK'
+#!/usr/bin/env bash
+set -euo pipefail
+payload=$(cat)
+printf '%s\n' "$payload" | jq -c . >> "$EAGLE_MEM_DIR/user-prompt-submit.jsonl"
+jq -nc '{"hookSpecificOutput":{"additionalContext":"recall context"}}'
+HOOK
+
+cat > "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" <<'HOOK'
+#!/usr/bin/env bash
+set -euo pipefail
+payload=$(cat)
+printf '%s\n' "$payload" | jq -c . >> "$EAGLE_MEM_DIR/pre-tool-use.jsonl"
+command_value=$(printf '%s\n' "$payload" | jq -r '.tool_input.command // ""')
+if [ "$command_value" = "deny" ]; then
+    jq -nc '{"hookSpecificOutput":{"permissionDecision":"deny","permissionDecisionReason":"blocked by test"}}'
+elif [ "$command_value" = "raw" ]; then
+    jq -nc '{"hookSpecificOutput":{"updatedInput":{"command":"safe"}}}'
+else
+    jq -nc '{"hookSpecificOutput":{}}'
+fi
+HOOK
+
+cat > "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" <<'HOOK'
+#!/usr/bin/env bash
+set -euo pipefail
+payload=$(cat)
+printf '%s\n' "$payload" | jq -c . >> "$EAGLE_MEM_DIR/post-tool-use.jsonl"
+tool_name=$(printf '%s\n' "$payload" | jq -r '.tool_name // ""')
+if [ "$tool_name" = "Read" ]; then
+    jq -nc '{"hookSpecificOutput":{"additionalContext":"post context"}}'
+else
+    jq -nc '{"hookSpecificOutput":{}}'
+fi
+HOOK
+
+cat > "$EAGLE_MEM_DIR/hooks/stop.sh" <<'HOOK'
+#!/usr/bin/env bash
+set -euo pipefail
+cat | jq -c . >> "$EAGLE_MEM_DIR/stop.jsonl"
+jq -nc '{"hookSpecificOutput":{}}'
+HOOK
+
+cat > "$EAGLE_MEM_DIR/hooks/session-end.sh" <<'HOOK'
+#!/usr/bin/env bash
+set -euo pipefail
+cat | jq -c . >> "$EAGLE_MEM_DIR/session-end.jsonl"
+jq -nc '{"hookSpecificOutput":{}}'
+HOOK
+
+node --input-type=module <<'NODE'
+import assert from "node:assert/strict";
+import { pathToFileURL } from "node:url";
+
+const pluginUrl = pathToFileURL(process.env.PLUGIN_PATH).href;
+const mod = await import(pluginUrl);
+const hooks = await mod.default({
+  project: { name: "opencode-fixture-project" },
+  directory: process.env.PROJECT_DIR,
+  worktree: process.env.PROJECT_DIR,
+});
+
+const chatOutput = {
+  message: {
+    id: "message-user-1",
+    sessionID: "session-1",
+    role: "user",
+    time: { created: 1 },
+    agent: "build",
+    model: { providerID: "openai", modelID: "gpt-5" },
+  },
+  parts: [
+    {
+      id: "part-user-1",
+      sessionID: "session-1",
+      messageID: "message-user-1",
+      type: "text",
+      text: "Review auth memory",
+    },
+  ],
+};
+
+await hooks["chat.message"]({ sessionID: "session-1" }, chatOutput);
+assert(chatOutput.parts.some((part) => part.text.includes("session context: startup")));
+assert(chatOutput.parts.some((part) => part.text.includes("recall context")));
+
+const beforeOutput = { args: { command: "raw" } };
+await hooks["tool.execute.before"]({ tool: "bash", sessionID: "session-1", callID: "call-1" }, beforeOutput);
+assert.equal(beforeOutput.args.command, "safe");
+
+await assert.rejects(
+  () => hooks["tool.execute.before"]({ tool: "bash", sessionID: "session-1", callID: "call-2" }, { args: { command: "deny" } }),
+  /blocked by test/,
+);
+
+const afterOutput = { title: "Read", output: "file body", metadata: {} };
+await hooks["tool.execute.after"](
+  { tool: "read", sessionID: "session-1", callID: "call-3", args: { filePath: "/tmp/auth.ts" } },
+  afterOutput,
+);
+assert(afterOutput.output.includes("post context"));
+assert.equal(afterOutput.metadata.eagleMemContext, "post context");
+
+await hooks.event({
+  event: {
+    type: "todo.updated",
+    properties: {
+      sessionID: "session-1",
+      todos: [{ content: "Ship OpenCode", status: "in_progress", priority: "high" }],
+    },
+  },
+});
+
+const compactOutput = {};
+await hooks["experimental.session.compacting"]({ sessionID: "session-1" }, compactOutput);
+assert(compactOutput.context.some((entry) => entry.includes("Eagle Mem Compaction Context")));
+
+await hooks.event({
+  event: {
+    type: "message.updated",
+    properties: {
+      sessionID: "session-1",
+      info: { id: "message-assistant-1", sessionID: "session-1", role: "assistant" },
+    },
+  },
+});
+await hooks.event({
+  event: {
+    type: "message.part.updated",
+    properties: {
+      sessionID: "session-1",
+      part: { messageID: "message-assistant-1", sessionID: "session-1", type: "text", text: "Assistant done" },
+      time: 1,
+    },
+  },
+});
+await hooks.event({ event: { type: "session.idle", properties: { sessionID: "session-1" } } });
+await hooks.event({ event: { type: "session.deleted", properties: { sessionID: "session-1" } } });
+
+const shellOutput = {};
+await hooks["shell.env"]({}, shellOutput);
+assert.equal(shellOutput.env.EAGLE_AGENT_SOURCE, "opencode");
+assert.equal(shellOutput.env.EAGLE_MEM_DIR, process.env.EAGLE_MEM_DIR);
+NODE
+
+jq -e 'select(.hook_event_name == "UserPromptSubmit" and .prompt == "Review auth memory" and .agent == "opencode")' "$EAGLE_MEM_DIR/user-prompt-submit.jsonl" >/dev/null \
+    || fail "UserPromptSubmit payload did not preserve the raw prompt"
+
+jq -e 'select(.hook_event_name == "PreToolUse" and .tool_name == "Bash" and .tool_input.command == "raw" and .agent == "opencode")' "$EAGLE_MEM_DIR/pre-tool-use.jsonl" >/dev/null \
+    || fail "PreToolUse payload did not normalize bash command input"
+
+jq -e 'select(.hook_event_name == "PostToolUse" and .tool_name == "Read" and .tool_input.file_path == "/tmp/auth.ts")' "$EAGLE_MEM_DIR/post-tool-use.jsonl" >/dev/null \
+    || fail "PostToolUse payload did not normalize read filePath input"
+
+jq -e 'select(.hook_event_name == "TaskCreated" and .task_subject == "Ship OpenCode")' "$EAGLE_MEM_DIR/post-tool-use.jsonl" >/dev/null \
+    || fail "todo.updated did not emit a synthetic TaskCreated payload"
+
+jq -e 'select(.tool_name == "TaskUpdate" and .tool_input.status == "in_progress")' "$EAGLE_MEM_DIR/post-tool-use.jsonl" >/dev/null \
+    || fail "todo.updated did not emit a TaskUpdate payload"
+
+jq -e 'select(.hook_event_name == "Stop" and .last_assistant_message == "Assistant done")' "$EAGLE_MEM_DIR/stop.jsonl" >/dev/null \
+    || fail "session.idle did not emit Stop with latest assistant text"
+
+jq -e 'select(.hook_event_name == "SessionEnd")' "$EAGLE_MEM_DIR/session-end.jsonl" >/dev/null \
+    || fail "session.deleted did not emit SessionEnd"
+
+echo "opencode plugin adapter test passed"

package/tests/test_recall_observability.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# UserPromptSubmit should persist recall observability facts: what matched and
+# how much context was injected.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-recall-observability.XXXXXX")
+trap 'rm -rf "$tmp_dir"' EXIT
+
+export HOME="$tmp_dir/home"
+export EAGLE_MEM_DIR="$tmp_dir/eagle-mem"
+mkdir -p "$HOME" "$EAGLE_MEM_DIR"
+
+. "$ROOT_DIR/lib/common.sh"
+"$ROOT_DIR/db/migrate.sh" >/dev/null
+. "$ROOT_DIR/lib/db.sh"
+
+repo="$tmp_dir/repo"
+mkdir -p "$repo"
+project="project-recall"
+
+eagle_upsert_session "seed-summary-session" "$project" "$repo" "test-model" "test" "codex" >/dev/null
+eagle_insert_summary \
+    "seed-summary-session" \
+    "$project" \
+    "Implement oauth token refresh" \
+    "Read auth client" \
+    "OAuth refresh needs rotating tokens" \
+    "Added oauth refresh guard" \
+    "" \
+    "[]" \
+    "[]" \
+    "oauth recall note" \
+    "Do not regress token refresh" \
+    "" \
+    "auth/client.ts" \
+    "codex" >/dev/null
+
+memory_file="$tmp_dir/oauth-memory.md"
+cat > "$memory_file" <<'EOF'
+---
+name: OAuth Memory
+description: OAuth token refresh decision
+type: decision
+originSessionId: seed-summary-session
+---
+OAuth token refresh must rotate credentials and preserve retry safety.
+EOF
+eagle_capture_agent_memory "$memory_file" "seed-summary-session" "$project" "codex" >/dev/null
+
+eagle_db "INSERT INTO code_chunks (project, file_path, language, start_line, end_line, content, mtime)
+          VALUES ('$project', 'auth/client.ts', 'typescript', 1, 20,
+                  'export function refreshOauthToken() { /* oauth token refresh */ return rotateCredentials(); }',
+                  123);" >/dev/null
+
+hook_input=$(jq -nc \
+    --arg sid "recall-hook-session" \
+    --arg cwd "$repo" \
+    --arg prompt "Please review oauth token refresh before editing auth client" \
+    '{session_id:$sid, cwd:$cwd, prompt:$prompt}')
+
+hook_output=$(EAGLE_MEM_PROJECT="$project" EAGLE_MEM_DIR="$EAGLE_MEM_DIR" bash "$ROOT_DIR/hooks/user-prompt-submit.sh" <<< "$hook_input")
+case "$hook_output" in
+    *"Eagle Mem recalls"*|*"Relevant code"*) ;;
+    *)
+        echo "UserPromptSubmit did not inject recall context" >&2
+        echo "$hook_output" >&2
+        exit 1
+        ;;
+esac
+
+event_json=$(eagle_db_json "SELECT session_id, project, agent, fts_query, summary_matches, memory_matches,
+                                   code_matches, summary_refs, memory_refs, code_refs,
+                                   injected_chars, injected_token_estimate, status
+                            FROM recall_events
+                            WHERE session_id = 'recall-hook-session'
+                            ORDER BY id DESC
+                            LIMIT 1;")
+
+printf '%s' "$event_json" | jq -e '
+    length == 1
+    and .[0].project == "project-recall"
+    and .[0].status == "ok"
+    and .[0].summary_matches >= 1
+    and .[0].memory_matches >= 1
+    and .[0].code_matches >= 1
+    and ((.[0].summary_refs | fromjson) | length >= 1)
+    and ((.[0].memory_refs | fromjson) | length >= 1)
+    and ((.[0].code_refs | fromjson) | length >= 1)
+    and .[0].injected_chars > 0
+    and .[0].injected_token_estimate > 0
+' >/dev/null || {
+    echo "recall event did not capture expected match counts" >&2
+    echo "$event_json" >&2
+    exit 1
+}
+
+inspect_json=$(cd "$repo" && EAGLE_MEM_DIR="$EAGLE_MEM_DIR" "$ROOT_DIR/bin/eagle-mem" inspect recall --project "$project" --json)
+printf '%s' "$inspect_json" | jq -e '
+    .status == "ok"
+    and .action == "recall"
+    and (.events | length >= 1)
+' >/dev/null || {
+    echo "inspect recall --json did not return recall events" >&2
+    echo "$inspect_json" >&2
+    exit 1
+}
+
+inspect_last=$(cd "$repo" && EAGLE_MEM_DIR="$EAGLE_MEM_DIR" "$ROOT_DIR/bin/eagle-mem" inspect recall --project "$project" --last)
+case "$inspect_last" in
+    *"Recall Inspector"*summaries=1*memories=1*code=1*) ;;
+    *)
+        echo "inspect recall --last did not render recall counts" >&2
+        echo "$inspect_last" >&2
+        exit 1
+        ;;
+esac
+
+replay_json=$(cd "$repo" && EAGLE_MEM_DIR="$EAGLE_MEM_DIR" "$ROOT_DIR/bin/eagle-mem" replay recall-hook-session --json)
+printf '%s' "$replay_json" | jq -e '
+    .status == "ok"
+    and .session_id == "recall-hook-session"
+    and (.recall_events | length == 1)
+    and (.recall_events[0].summary_refs | length >= 1)
+    and (.recall_events[0].memory_refs | length >= 1)
+    and (.recall_events[0].code_refs | length >= 1)
+' >/dev/null || {
+    echo "replay --json did not return recall refs" >&2
+    echo "$replay_json" >&2
+    exit 1
+}
+
+replay_last=$(cd "$repo" && EAGLE_MEM_DIR="$EAGLE_MEM_DIR" "$ROOT_DIR/bin/eagle-mem" replay --project "$project" --last)
+case "$replay_last" in
+    *"Replay"*recall-hook-session*"Retrieved refs"*auth/client.ts*) ;;
+    *)
+        echo "replay --last did not render retrieved refs" >&2
+        echo "$replay_last" >&2
+        exit 1
+        ;;
+esac
+
+echo "recall observability regressions passed"

package/tests/test_repair.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Repair command regressions: DB errors need an actionable and safe recovery path.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+EAGLE_BIN="$ROOT_DIR/bin/eagle-mem"
+
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-repair.XXXXXX")
+trap 'rm -rf "$tmp_dir"' EXIT
+
+assert_json() {
+    local json="$1" filter="$2" message="$3"
+    if ! printf '%s' "$json" | jq -e "$filter" >/dev/null; then
+        echo "$message" >&2
+        echo "$json" >&2
+        exit 1
+    fi
+}
+
+healthy_home="$tmp_dir/healthy"
+mkdir -p "$healthy_home"
+EAGLE_MEM_DIR="$healthy_home" "$ROOT_DIR/db/migrate.sh" >/dev/null
+
+healthy_json=$(EAGLE_MEM_DIR="$healthy_home" "$EAGLE_BIN" repair --json)
+assert_json "$healthy_json" '.status == "ok" and .database.integrity.status == "ok"' "repair should no-op on a healthy DB"
+
+corrupt_home="$tmp_dir/corrupt"
+mkdir -p "$corrupt_home"
+printf 'not a sqlite database\n' > "$corrupt_home/memory.db"
+before_hash=$(shasum -a 256 "$corrupt_home/memory.db" | awk '{print $1}')
+
+dry_json=$(EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" repair --dry-run --json)
+assert_json "$dry_json" '.status == "needs_repair" and .database.integrity.status == "error"' "repair dry-run should produce an actionable repair plan"
+after_dry_hash=$(shasum -a 256 "$corrupt_home/memory.db" | awk '{print $1}')
+[ "$before_hash" = "$after_dry_hash" ] || {
+    echo "repair --dry-run must not modify the DB" >&2
+    exit 1
+}
+
+set +e
+yes_json=$(EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" repair --yes --json 2>/dev/null)
+yes_rc=$?
+set -e
+[ "$yes_rc" -ne 0 ] || {
+    echo "repair --yes should not replace unrecoverable garbage with an empty DB" >&2
+    echo "$yes_json" >&2
+    exit 1
+}
+assert_json "$yes_json" '.status == "error" and (.message | test("left untouched")) and .backup_path != ""' "repair --yes should back up and keep unrecoverable DB untouched"
+
+after_yes_hash=$(shasum -a 256 "$corrupt_home/memory.db" | awk '{print $1}')
+[ "$before_hash" = "$after_yes_hash" ] || {
+    echo "unrecoverable repair should leave original DB bytes untouched" >&2
+    exit 1
+}
+
+backup_count=$(find "$corrupt_home/backups" -type f -name 'memory-*.db' 2>/dev/null | wc -l | tr -d ' ')
+[ "$backup_count" -ge 1 ] || {
+    echo "repair --yes should create a backup before recovery attempts" >&2
+    exit 1
+}
+
+echo "repair regressions passed"

package/tests/test_rust_migration_plan.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# Static guard for the compatibility-first Rust migration plan.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+PLAN="$ROOT_DIR/MIGRATION.md"
+
+fail() {
+    echo "rust migration plan check failed: $*" >&2
+    exit 1
+}
+
+require_contains() {
+    local pattern="$1"
+    local label="$2"
+    if ! grep -Eq "$pattern" "$PLAN"; then
+        fail "MIGRATION.md does not mention $label"
+    fi
+}
+
+[ -f "$PLAN" ] || fail "missing MIGRATION.md"
+
+require_contains "~/.eagle-mem/memory\\.db" "the existing user database path"
+require_contains "compatibility wrapper" "the Bash compatibility wrapper"
+require_contains "additive migrations" "additive migrations"
+require_contains "never deleted|Never mutate|Never make destructive" "data preservation"
+require_contains "eagle_events" "structured observability events"
+require_contains "ratatui" "Rust TUI library"
+require_contains "crossterm" "Rust terminal backend"
+require_contains "rusqlite|sqlx" "SQLite Rust library options"
+require_contains "Phase 0" "Phase 0"
+require_contains "Phase 1" "Phase 1"
+require_contains "Phase 2" "Phase 2"
+require_contains "Phase 3" "Phase 3"
+require_contains "Phase 4" "Phase 4"
+require_contains "Phase 5" "Phase 5"
+require_contains "Phase 6" "Phase 6"
+require_contains "Phase 7" "Phase 7"
+
+for crate in eagle-core eagle-db eagle-hooks eagle-cli eagle-tui; do
+    require_contains "$crate" "crate $crate"
+done
+
+for table in \
+    sessions observations summaries summaries_fts overviews code_chunks code_chunks_fts \
+    agent_memories agent_tasks features feature_files pending_feature_verifications \
+    graph_nodes graph_edges orchestrations orchestration_lanes recall_events \
+    orchestration_auto_events eagle_meta
+do
+    require_contains "\\b$table\\b" "table $table"
+done
+
+for command in \
+    install update uninstall search health doctor repair inspect replay dashboard logs \
+    config updates statusline guard overview graph session sessions memories tasks \
+    orchestrate curate feature grok-bootstrap test compaction prune scan index help version
+do
+    require_contains "\`$command\`|^(- )?$command$| $command" "command $command"
+done
+
+for event in \
+    hook_started hook_completed memory_created memory_retrieved context_injected \
+    compact_started compact_completed index_started index_completed lane_created \
+    task_created task_completed graph_rebuilt dashboard_generated replay_generated
+do
+    require_contains "$event" "event $event"
+done
+
+require_contains "Rust disabled" "Rust disabled test mode"
+require_contains "Rust enabled" "Rust enabled test mode"
+require_contains "sanitized" "sanitized migrated DB fixtures"
+require_contains "docs/agent-compatibility" "agent compatibility docs integration"
+
+echo "rust migration plan check passed"
+

package/tests/test_trust_surfaces.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# Trust surface regressions: corrupted DBs must be visible, not mistaken for
+# empty memory state.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+EAGLE_BIN="$ROOT_DIR/bin/eagle-mem"
+
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-trust-surfaces.XXXXXX")
+trap 'rm -rf "$tmp_dir"' EXIT
+
+assert_contains() {
+    local haystack="$1" needle="$2" message="$3"
+    case "$haystack" in
+        *"$needle"*) ;;
+        *)
+            echo "$message" >&2
+            echo "Expected to find: $needle" >&2
+            echo "Actual: $haystack" >&2
+            exit 1
+            ;;
+    esac
+}
+
+assert_json() {
+    local json="$1" filter="$2" message="$3"
+    if ! printf '%s' "$json" | jq -e "$filter" >/dev/null; then
+        echo "$message" >&2
+        echo "$json" >&2
+        exit 1
+    fi
+}
+
+strip_ansi() {
+    sed -E $'s/\x1b\\[[0-9;]*m//g'
+}
+
+repo="$tmp_dir/repo"
+mkdir -p "$repo"
+
+healthy_home="$tmp_dir/healthy"
+mkdir -p "$healthy_home"
+EAGLE_MEM_DIR="$healthy_home" "$ROOT_DIR/db/migrate.sh" >/dev/null
+
+doctor_ok=$(EAGLE_MEM_DIR="$healthy_home" "$EAGLE_BIN" doctor --json)
+assert_json "$doctor_ok" '.database.integrity.status == "ok"' "doctor should report healthy DB integrity"
+
+compaction_ok=$(cd "$repo" && EAGLE_MEM_DIR="$healthy_home" "$EAGLE_BIN" compaction --json)
+assert_json "$compaction_ok" '.status == "ok" and .database.integrity.status == "ok" and .readiness == "weak"' "compaction --json should emit structured healthy output"
+
+stats_ok=$(cd "$repo" && EAGLE_MEM_DIR="$healthy_home" "$EAGLE_BIN" search --stats --json)
+assert_json "$stats_ok" '.status == "ok" and .database.integrity.status == "ok" and (.sessions | type == "number")' "search --stats --json should emit structured healthy output"
+
+statusline_ok=$(cd "$repo" && EAGLE_MEM_DIR="$healthy_home" "$EAGLE_BIN" statusline | strip_ansi)
+assert_contains "$statusline_ok" "sessions" "healthy statusline should still show memory counts"
+
+corrupt_home="$tmp_dir/corrupt"
+mkdir -p "$corrupt_home"
+printf 'not a sqlite database\n' > "$corrupt_home/memory.db"
+
+doctor_bad=$(EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" doctor --json)
+assert_json "$doctor_bad" '.overall == "Needs attention" and .database.integrity.status == "error"' "doctor should mark corrupted DB as needing attention"
+
+set +e
+health_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" health --json 2>/dev/null)
+health_rc=$?
+set -e
+[ "$health_rc" -ne 0 ] || { echo "health --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$health_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "health --json should emit a structured DB integrity error"
+
+set +e
+stats_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" search --stats --json 2>/dev/null)
+stats_rc=$?
+set -e
+[ "$stats_rc" -ne 0 ] || { echo "search --stats --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$stats_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "search --stats --json should emit a structured DB integrity error"
+
+set +e
+compaction_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" compaction --json 2>/dev/null)
+compaction_rc=$?
+set -e
+[ "$compaction_rc" -ne 0 ] || { echo "compaction --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$compaction_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "compaction --json should emit a structured DB integrity error"
+
+set +e
+tasks_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" tasks --json 2>/dev/null)
+tasks_rc=$?
+set -e
+[ "$tasks_rc" -ne 0 ] || { echo "tasks --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$tasks_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "tasks --json should emit a structured DB integrity error"
+
+set +e
+graph_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" graph 2>&1)
+graph_rc=$?
+set -e
+[ "$graph_rc" -ne 0 ] || { echo "graph should fail on corrupted DB" >&2; exit 1; }
+assert_contains "$graph_bad" "Database integrity check failed" "graph should explain corrupted DB instead of showing an empty graph"
+
+set +e
+inspect_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" inspect recall --json 2>/dev/null)
+inspect_rc=$?
+set -e
+[ "$inspect_rc" -ne 0 ] || { echo "inspect recall --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$inspect_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "inspect recall --json should emit a structured DB integrity error"
+
+set +e
+dashboard_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" dashboard --json 2>/dev/null)
+dashboard_rc=$?
+set -e
+[ "$dashboard_rc" -ne 0 ] || { echo "dashboard --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$dashboard_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "dashboard --json should emit a structured DB integrity error"
+
+set +e
+replay_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" replay --last --json 2>/dev/null)
+replay_rc=$?
+set -e
+[ "$replay_rc" -ne 0 ] || { echo "replay --json should fail on corrupted DB" >&2; exit 1; }
+assert_json "$replay_bad" '.status == "error" and .error == "database_integrity" and .database.integrity.status == "error"' "replay --json should emit a structured DB integrity error"
+
+statusline_bad=$(cd "$repo" && EAGLE_MEM_DIR="$corrupt_home" "$EAGLE_BIN" statusline | strip_ansi)
+assert_contains "$statusline_bad" "DB error" "statusline should show DB error for corrupted memory state"
+
+echo "trust surface regressions passed"