eagle-mem 4.10.9 → 4.10.10

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.10.10 Dream Cycle Consolidation Hardening
+
+This patch closes the review findings from the multi-model Spectral pass:
+
+- **Structured Consolidation Parsing**: Dream Cycle memory consolidation now asks providers for strict JSON and validates the response with `jq`, removing the brittle `CONSOLIDATE:` text parser that could break on punctuation, arrows, pipes, or whitespace in memory names.
+- **Dry-Run Safety**: Memory graph consolidation dry-runs now preview graph wiring and skip the provider call, avoiding token spend and provider side effects during preview.
+- **Regression Coverage**: The Dream Cycle regression now covers JSON consolidation with punctuation-heavy names, `NONE` responses, malformed legacy text responses, idempotent reruns, and dry-run provider skipping.
+- **Indexer Edge Coverage**: Graph-memory indexing now verifies dot-command-like source lines, leading blank lines, all-whitespace chunks, and empty-file behavior.
+
+---
+
 ## v4.10.9 Dream Cycle Graph Memory Hotfix
 
 This hotfix closes the remaining graph-memory curation gap:

package/README.md

@@ -184,7 +184,7 @@ eagle-mem overview set "Current project briefing..."
 
 If graph search shows stale deleted files, run `eagle-mem graph rebuild` from the project root. The rebuild command filters missing tracked paths, clears stale code chunks and declaration nodes, preserves manual overviews, and rewires declarations with file-scoped names such as `apps/mac/DictationController.swift::finishDictation`.
 
-Dream Cycle curation also wires mirrored agent memories into graph `memory` nodes before consolidation, so `supersedes` relationships stay attached to the source memories rather than to incidental text inside memory content.
+Dream Cycle curation also wires mirrored agent memories into graph `memory` nodes before consolidation, so `supersedes` relationships stay attached to the source memories rather than to incidental text inside memory content. Consolidation responses use a strict JSON contract, and dry-run previews skip the provider call for the memory-consolidation step.
 
 ### Trust and Recovery
 

package/package.json

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

package/scripts/curate.sh

@@ -37,6 +37,46 @@ Options:
 EOF
 }
 
+parse_consolidations_json() {
+    local result="$1"
+    local trimmed json_payload
+
+    trimmed=$(printf '%s' "$result" | tr -d '\r' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    case "$trimmed" in
+        ""|NONE|none|null)
+            printf '[]\n'
+            return 0
+            ;;
+    esac
+
+    json_payload=$(printf '%s' "$result" \
+        | sed -e '1s/^[[:space:]]*```json[[:space:]]*$//' \
+              -e '1s/^[[:space:]]*```[[:space:]]*$//' \
+              -e '$s/^[[:space:]]*```[[:space:]]*$//')
+
+    printf '%s' "$json_payload" | jq -c '
+        def trim: gsub("^\\s+|\\s+$"; "");
+        def names:
+            if type == "array" then map(tostring | trim) | map(select(length > 0))
+            elif type == "string" then split(",") | map(trim) | map(select(length > 0))
+            else []
+            end;
+        def root:
+            if type == "array" then .
+            elif type == "object" then (.consolidations // .items // .instructions // [])
+            else []
+            end;
+        root
+        | map({
+            source_names: ((.source_names // .sourceNames // .source_memories // .sourceMemories // .original_names // .originalNames // .originals // .names) | names),
+            new_name: ((.new_name // .newName // .name // .title // "") | tostring | trim),
+            description: ((.description // "") | tostring),
+            value: ((.value // .content // .compiled_truth // .compiledTruth // "") | tostring)
+        })
+        | map(select((.source_names | length) > 0 and (.new_name | length) > 0))
+    ' 2>/dev/null
+}
+
 while [ $# -gt 0 ]; do
     case "$1" in
         -h|--help)
@@ -559,7 +599,11 @@ if [ -n "$co_edit_data" ]; then
             co_wire_count=$((co_wire_count + 1))
         fi
     done <<< "$co_edit_data"
-    eagle_ok "Wired $co_wire_count co-edited file edges"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would wire $co_wire_count co-edited file edges"
+    else
+        eagle_ok "Wired $co_wire_count co-edited file edges"
+    fi
 fi
 
 # 7.2 Wire session nodes and access edges
@@ -569,35 +613,55 @@ if [ -n "$recent_sessions" ]; then
     if [ "$DRY_RUN" -eq 0 ]; then
         session_wire_count=$(eagle_graph_wire_recent_session_edges "$project" 15)
     fi
-    eagle_ok "Wired $session_wire_count recent session nodes and edges"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would wire $session_wire_count recent session nodes and edges"
+    else
+        eagle_ok "Wired $session_wire_count recent session nodes and edges"
+    fi
 fi
 
 # 7.3 Offline Memory Consolidation (Compiled Truth vs Evidence)
-active_memories=$(eagle_db "SELECT memory_name, memory_type, description, content FROM agent_memories WHERE project = '$p_esc';")
-if [ -n "$active_memories" ]; then
-    memory_node_count=0
-    active_memory_nodes=$(eagle_db_json "SELECT memory_name, content FROM agent_memories WHERE project = '$p_esc';" || true)
-    active_memory_node_count=$(printf '%s' "$active_memory_nodes" | jq 'length' 2>/dev/null || echo 0)
+active_memory_rows=$(eagle_db_json "SELECT memory_name, memory_type, description, content FROM agent_memories WHERE project = '$p_esc';" || {
+    eagle_log "WARN" "Unable to read active agent memories for consolidation"
+    echo "[]"
+})
+active_memory_count=$(printf '%s' "$active_memory_rows" | jq 'length' 2>/dev/null || echo 0)
+if [ "$active_memory_count" -gt 0 ]; then
+    wired_memory_count=0
     memory_node_index=0
-    while [ "$memory_node_index" -lt "$active_memory_node_count" ]; do
-        mname=$(printf '%s' "$active_memory_nodes" | jq -r ".[$memory_node_index].memory_name // empty")
-        mcontent=$(printf '%s' "$active_memory_nodes" | jq -r ".[$memory_node_index].content // empty")
+    while [ "$memory_node_index" -lt "$active_memory_count" ]; do
+        mname=$(printf '%s' "$active_memory_rows" | jq -r ".[$memory_node_index].memory_name // empty")
+        mcontent=$(printf '%s' "$active_memory_rows" | jq -r ".[$memory_node_index].content // empty")
         memory_node_index=$((memory_node_index + 1))
         [ -n "$mname" ] || continue
         if [ "$DRY_RUN" -eq 0 ]; then
             eagle_graph_add_node "$project" "memory" "$mname" "$mcontent" ""
         fi
-        memory_node_count=$((memory_node_count + 1))
+        wired_memory_count=$((wired_memory_count + 1))
     done
-    eagle_ok "Wired $memory_node_count agent memory graph nodes"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would wire $wired_memory_count agent memory graph nodes"
+    else
+        eagle_ok "Wired $wired_memory_count agent memory graph nodes"
+    fi
 
-    consolidation_prompt="Analyze these mirrored agent memories for project '$project'. Identify any memories that are redundant, overlap in scope, or describe the same subsystem/gotcha/concept.
-    
-MEMORIES:
-$active_memories
+    memory_prompt_json=$(printf '%s' "$active_memory_rows" | jq -c '[.[] | {
+        memory_name: .memory_name,
+        memory_type: .memory_type,
+        description: .description,
+        content: .content
+    }]')
 
-For any memories that should be consolidated, merge them into a single 'Compiled Truth' summary.
-The consolidated memory MUST be formatted exactly as:
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would analyze $wired_memory_count agent memories for consolidation"
+    else
+        consolidation_prompt="Analyze these mirrored agent memories for project '$project'. Identify memories that are redundant, overlap in scope, or describe the same subsystem/gotcha/concept.
+
+INPUT_MEMORIES_JSON:
+$memory_prompt_json
+
+For any memories that should be consolidated, merge them into a single Compiled Truth summary.
+The consolidated memory value MUST be formatted exactly as:
 --- Compiled Truth ---
 <A structured, clear, up-to-date summary of the topic, gotten by merging the duplicate/overlapping memories. Keep it extremely precise.>
 
@@ -605,55 +669,59 @@ The consolidated memory MUST be formatted exactly as:
 - <Original memory title 1>: <brief original description or timestamp>
 - <Original memory title 2>: <brief original description or timestamp>
 
-Format your output as a series of instructions:
-CONSOLIDATE: <original memory name 1>, <original memory name 2> -> <new consolidated memory name> | description: <new description> | value: <the merged compiled truth + evidence content>
+Return strict JSON only, with this schema:
+{
+  \"consolidations\": [
+    {
+      \"source_names\": [\"<exact source memory_name>\", \"<exact source memory_name>\"],
+      \"new_name\": \"<new consolidated memory name>\",
+      \"description\": \"<new description>\",
+      \"value\": \"<the merged compiled truth + evidence content>\"
+    }
+  ]
+}
 
-If no memories need consolidation, output: NONE"
+If no memories need consolidation, return {\"consolidations\":[]}."
 
-    consolidation_result=$(eagle_llm_call "$consolidation_prompt" "You consolidate software development memories into a single compiled truth. Be precise. Output CONSOLIDATE lines or NONE." 1024 || true)
+        consolidation_result=$(eagle_llm_call "$consolidation_prompt" "You consolidate software development memories into a single compiled truth. Return strict JSON only." 1024 || true)
+        if ! parsed_consolidations=$(parse_consolidations_json "$consolidation_result"); then
+            eagle_log "WARN" "Unable to parse memory consolidation provider response"
+            parsed_consolidations="[]"
+        fi
 
-    if [ -n "$consolidation_result" ] && ! echo "$consolidation_result" | grep -q "^NONE$"; then
-        cons_count=0
-        while IFS= read -r line; do
-            case "$line" in
-                CONSOLIDATE:*)
-                    cons_data=$(echo "$line" | sed 's/^CONSOLIDATE:[[:space:]]*//')
-                    
-                    # Parse matching: original_names -> new_name | description: desc | value: val
-                    names_part=$(echo "$cons_data" | cut -d'-' -f1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                    rest_part=$(echo "$cons_data" | cut -d'>' -f2-)
-                    new_name=$(echo "$rest_part" | cut -d'|' -f1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                    
-                    desc_part=$(echo "$rest_part" | grep -oE "description:[[:space:]]*[^|]+" | sed 's/description:[[:space:]]*//')
-                    val_part=$(echo "$rest_part" | grep -oE "value:[[:space:]]*.+" | sed 's/value:[[:space:]]*//')
-                    
-                    if [ -z "$new_name" ] || [ -z "$names_part" ]; then continue; fi
-                    
-                    if [ "$DRY_RUN" -eq 1 ]; then
-                        eagle_info "  Would consolidate: $names_part → $new_name"
+        consolidation_count=$(printf '%s' "$parsed_consolidations" | jq 'length' 2>/dev/null || echo 0)
+        if [ "$consolidation_count" -gt 0 ]; then
+            cons_count=0
+            consolidation_index=0
+            while [ "$consolidation_index" -lt "$consolidation_count" ]; do
+                consolidation_item=$(printf '%s' "$parsed_consolidations" | jq -c ".[$consolidation_index]")
+                consolidation_index=$((consolidation_index + 1))
+                new_name=$(printf '%s' "$consolidation_item" | jq -r '.new_name // empty')
+                val_part=$(printf '%s' "$consolidation_item" | jq -r '.value // empty')
+                [ -n "$new_name" ] || continue
+
+                eagle_graph_add_node "$project" "memory" "$new_name" "$val_part" ""
+                new_node_id=$(eagle_graph_get_node_id "$project" "memory" "$new_name")
+
+                old_count=$(printf '%s' "$consolidation_item" | jq '.source_names | length' 2>/dev/null || echo 0)
+                old_index=0
+                while [ "$old_index" -lt "$old_count" ]; do
+                    old_n=$(printf '%s' "$consolidation_item" | jq -r ".source_names[$old_index] // empty")
+                    old_index=$((old_index + 1))
+                    [ -n "$old_n" ] || continue
+                    old_node_id=$(eagle_graph_get_node_id "$project" "memory" "$old_n")
+                    if [ -n "$old_node_id" ] && [ -n "$new_node_id" ]; then
+                        eagle_graph_add_edge "$project" "$new_node_id" "$old_node_id" "supersedes" 1.0
                     else
-                        # 1. Add new consolidated memory node
-                        eagle_graph_add_node "$project" "memory" "$new_name" "$val_part" ""
-                        new_node_id=$(eagle_graph_get_node_id "$project" "memory" "$new_name")
-                        
-                        # 2. Wire supersedes edges from new node to old nodes, and mark old nodes as inactive/superseded
-                        IFS=',' read -ra name_arr <<< "$names_part"
-                        for old_n in "${name_arr[@]}"; do
-                            old_n=$(echo "$old_n" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                            if [ -z "$old_n" ]; then continue; fi
-                            old_node_id=$(eagle_graph_get_node_id "$project" "memory" "$old_n")
-                            if [ -n "$old_node_id" ] && [ -n "$new_node_id" ]; then
-                                eagle_graph_add_edge "$project" "$new_node_id" "$old_node_id" "supersedes" 1.0
-                            fi
-                        done
-                        cons_count=$((cons_count + 1))
+                        eagle_log "WARN" "Unable to wire supersedes edge: source='$old_n' consolidated='$new_name'"
                     fi
-                    ;;
-            esac
-        done <<< "$consolidation_result"
-        eagle_ok "Consolidated $cons_count sets of overlapping agent memories"
-    else
-        eagle_ok "Agent memories are fully consolidated and up to date"
+                done
+                cons_count=$((cons_count + 1))
+            done
+            eagle_ok "Consolidated $cons_count sets of overlapping agent memories"
+        else
+            eagle_ok "Agent memories are fully consolidated and up to date"
+        fi
     fi
 else
     eagle_dim "  No active agent memories to consolidate"

package/scripts/index.sh

@@ -89,6 +89,25 @@ ext_to_lang() {
     esac
 }
 
+sql_literal_expr() {
+    awk '
+        BEGIN { first = 1 }
+        {
+            gsub(/\047/, "\047\047")
+            if (!first) {
+                printf "||char(10)||"
+            }
+            printf "\047%s\047", $0
+            first = 0
+        }
+        END {
+            if (first) {
+                printf "\047\047"
+            }
+        }
+    '
+}
+
 # ─── Collect files ─────────────────────────────────────────
 
 TMPDIR_IDX=$(mktemp -d)
@@ -194,11 +213,11 @@ DELETE FROM code_chunks WHERE project = '$project_sql' AND file_path = '$file_sq
         [ "$end" -gt "$total_lines" ] && end="$total_lines"
 
         content=$(sed -n "${start},${end}p" "$full_path" | eagle_redact)
-        content_sql=$(eagle_sql_escape "$content")
+        content_expr=$(printf '%s\n' "$content" | sql_literal_expr)
 
         txn_sql+="
 INSERT INTO code_chunks (project, file_path, language, start_line, end_line, content, mtime)
-VALUES ('$project_sql', '$file_sql', '$lang_sql', $start, $end, '$content_sql', $current_mtime);"
+VALUES ('$project_sql', '$file_sql', '$lang_sql', $start, $end, $content_expr, $current_mtime);"
 
         chunk_count=$((chunk_count + 1))
         start=$((end + 1))

package/tests/test_curate_graph_memories.sh

@@ -14,24 +14,12 @@ mkdir -p "$HOME" "$EAGLE_MEM_DIR" "$tmp_dir/bin"
 
 cat > "$tmp_dir/bin/curl" <<'EOF'
 #!/usr/bin/env bash
-body=""
-while [ "$#" -gt 0 ]; do
-    case "$1" in
-        -d)
-            shift
-            body="${1:-}"
-            ;;
-    esac
-    shift || true
-done
-
-if printf '%s' "$body" | grep -q "mirrored agent memories"; then
-    content="CONSOLIDATE: Memory A, Memory B -> Compiled AB | description: merged memories | value: --- Compiled Truth --- merged truth"
-else
-    content="NONE"
+if [ -n "${EAGLE_CURATE_FAKE_CURL_MARKER:-}" ]; then
+    echo called >> "$EAGLE_CURATE_FAKE_CURL_MARKER"
 fi
 
-jq -nc --arg content "$content" '{message:{content:$content}}'
+content="${EAGLE_CURATE_FAKE_RESPONSE:-NONE}"
+jq -nc --arg content "$content" '{message:{role:"assistant",content:$content}}'
 EOF
 chmod +x "$tmp_dir/bin/curl"
 export PATH="$tmp_dir/bin:$PATH"
@@ -49,45 +37,104 @@ url = "http://127.0.0.1:11434"
 model = "fake"
 EOF
 
-eagle_db "INSERT INTO agent_memories (project, file_path, memory_name, memory_type, description, content)
-          VALUES
-          ('project', 'memory://a', 'Memory A', 'project', 'First memory', 'Content A
-Evidence line that must not become a graph node'),
-          ('project', 'memory://b', 'Memory B', 'project', 'Second memory', 'Content B');" >/dev/null
-
-"$EAGLE_BIN" curate -p project >/dev/null
-
-original_count=$(eagle_db "SELECT COUNT(*)
-                          FROM graph_nodes
-                          WHERE project = 'project'
-                            AND node_type = 'memory'
-                            AND node_name IN ('Memory A', 'Memory B');")
-if [ "$original_count" != "2" ]; then
-    echo "expected original agent memories to be graph nodes, got $original_count" >&2
-    exit 1
-fi
+assert_eq() {
+    local expected="$1" actual="$2" message="$3"
+    if [ "$actual" != "$expected" ]; then
+        echo "$message: expected $expected, got $actual" >&2
+        exit 1
+    fi
+}
+
+insert_memory() {
+    local project="$1" file_path="$2" memory_name="$3" description="$4" content="$5"
+    eagle_db "INSERT INTO agent_memories (project, file_path, memory_name, memory_type, description, content)
+              VALUES
+              ('$(eagle_sql_escape "$project")',
+               '$(eagle_sql_escape "$file_path")',
+               '$(eagle_sql_escape "$memory_name")',
+               'project',
+               '$(eagle_sql_escape "$description")',
+               '$(eagle_sql_escape "$content")');" >/dev/null
+}
+
+agent_memory_rows() {
+    local project="$1"
+    eagle_db "SELECT COUNT(*)
+              FROM agent_memories
+              WHERE project = '$(eagle_sql_escape "$project")';"
+}
+
+memory_graph_nodes() {
+    local project="$1"
+    eagle_db "SELECT COUNT(*)
+              FROM graph_nodes
+              WHERE project = '$(eagle_sql_escape "$project")'
+                AND node_type = 'memory';"
+}
+
+supersedes_edges() {
+    local project="$1" new_name="${2:-}"
+    local new_filter=""
+    if [ -n "$new_name" ]; then
+        new_filter="AND s.node_name = '$(eagle_sql_escape "$new_name")'"
+    fi
+    eagle_db "SELECT COUNT(*)
+              FROM graph_edges e
+              JOIN graph_nodes s ON s.id = e.source_node_id
+              JOIN graph_nodes t ON t.id = e.target_node_id
+              WHERE e.project = '$(eagle_sql_escape "$project")'
+                AND e.edge_type = 'supersedes'
+                AND s.node_type = 'memory'
+                AND t.node_type = 'memory'
+                $new_filter;"
+}
 
-memory_node_count=$(eagle_db "SELECT COUNT(*)
-                             FROM graph_nodes
-                             WHERE project = 'project'
-                               AND node_type = 'memory';")
-if [ "$memory_node_count" != "3" ]; then
-    echo "expected two originals plus one consolidated memory node, got $memory_node_count" >&2
+# Happy path: structured JSON survives punctuation that broke the old text parser.
+export EAGLE_CURATE_FAKE_RESPONSE='{"consolidations":[{"source_names":["Memory A - Dash","Memory B > Pipe | Name"],"new_name":"Compiled AB JSON","description":"merged memories","value":"--- Compiled Truth ---\nmerged truth\n\n--- Evidence Trail ---\n- Memory A - Dash\n- Memory B > Pipe | Name"}]}'
+insert_memory "project-json" "memory://a" "Memory A - Dash" "First memory" $'Content A\nEvidence line that must not become a graph node'
+insert_memory "project-json" "memory://b" "Memory B > Pipe | Name" "Second memory" "Content B"
+
+"$EAGLE_BIN" curate -p project-json >/dev/null
+assert_eq "2" "$(agent_memory_rows project-json)" "source agent memories should survive curate"
+assert_eq "3" "$(memory_graph_nodes project-json)" "curate should create two originals plus one consolidated memory node"
+assert_eq "2" "$(supersedes_edges project-json "Compiled AB JSON")" "consolidated memory should supersede both originals"
+
+# Idempotency: re-running the same consolidation should not create duplicate nodes or edges.
+"$EAGLE_BIN" curate -p project-json >/dev/null
+assert_eq "3" "$(memory_graph_nodes project-json)" "curate should keep memory graph nodes idempotent"
+assert_eq "2" "$(supersedes_edges project-json "Compiled AB JSON")" "curate should keep supersedes edge count idempotent"
+
+# No consolidation: source nodes are still wired, but no supersedes edges are created.
+export EAGLE_CURATE_FAKE_RESPONSE='{"consolidations":[]}'
+insert_memory "project-none" "memory://none-a" "Memory None A" "First none memory" "Content A"
+insert_memory "project-none" "memory://none-b" "Memory None B" "Second none memory" "Content B"
+"$EAGLE_BIN" curate -p project-none >/dev/null
+assert_eq "2" "$(memory_graph_nodes project-none)" "NONE response should still wire source memory nodes"
+assert_eq "0" "$(supersedes_edges project-none)" "NONE response should not create supersedes edges"
+
+# Malformed legacy/text output is ignored safely instead of producing partial graph edges.
+export EAGLE_CURATE_FAKE_RESPONSE='CONSOLIDATE: Memory Broken A, Memory Broken B -> Broken AB | description: legacy | value: legacy text'
+insert_memory "project-malformed" "memory://bad-a" "Memory Broken A" "First malformed memory" "Content A"
+insert_memory "project-malformed" "memory://bad-b" "Memory Broken B" "Second malformed memory" "Content B"
+"$EAGLE_BIN" curate -p project-malformed >/dev/null
+assert_eq "2" "$(memory_graph_nodes project-malformed)" "malformed response should still wire source memory nodes"
+assert_eq "0" "$(supersedes_edges project-malformed)" "malformed response should not create supersedes edges"
+
+# Dry-run: memory graph writes and provider calls are skipped for consolidation.
+dry_run_marker="$tmp_dir/curl-called"
+dry_run_output="$tmp_dir/dry-run.out"
+export EAGLE_CURATE_FAKE_CURL_MARKER="$dry_run_marker"
+export EAGLE_CURATE_FAKE_RESPONSE='{"consolidations":[{"source_names":["Dry A","Dry B"],"new_name":"Dry AB","description":"dry","value":"dry"}]}'
+insert_memory "project-dry" "memory://dry-a" "Dry A" "First dry memory" "Content A"
+insert_memory "project-dry" "memory://dry-b" "Dry B" "Second dry memory" "Content B"
+"$EAGLE_BIN" curate --dry-run -p project-dry > "$dry_run_output"
+if [ -f "$dry_run_marker" ]; then
+    echo "dry-run should not call the consolidation provider" >&2
     exit 1
 fi
-
-supersedes_edges=$(eagle_db "SELECT COUNT(*)
-                            FROM graph_edges e
-                            JOIN graph_nodes s ON s.id = e.source_node_id
-                            JOIN graph_nodes t ON t.id = e.target_node_id
-                            WHERE e.project = 'project'
-                              AND e.edge_type = 'supersedes'
-                              AND s.node_type = 'memory'
-                              AND s.node_name = 'Compiled AB'
-                              AND t.node_type = 'memory'
-                              AND t.node_name IN ('Memory A', 'Memory B');")
-if [ "$supersedes_edges" != "2" ]; then
-    echo "expected consolidated memory to supersede both originals, got $supersedes_edges" >&2
+assert_eq "0" "$(memory_graph_nodes project-dry)" "dry-run should not write memory graph nodes"
+if ! grep -q "Would wire 2 agent memory graph nodes" "$dry_run_output"; then
+    echo "dry-run did not report the memory graph wiring preview" >&2
     exit 1
 fi
 

package/tests/test_graph_memory.sh

@@ -77,11 +77,70 @@ CREATE TABLE graph_fixture (
 );
 EOF
 
-git -C "$repo" add a.sh b.sh old.sh db/source_column.sql
+cat > "$repo/sqlite_cli_literal.sh" <<'EOF'
+EAGLE_DB_SETUP=".headers off
+.output /dev/null
+PRAGMA busy_timeout=10000;
+.output stdout"
+EOF
+
+{
+    printf '\n'
+    printf '%s\n' 'echo "starts after an intentional blank line"'
+    printf '%s\n' '   '
+} > "$repo/sql_literal_edges.sh"
+
+{
+    printf '%s\n' '   '
+    printf '\t\n'
+} > "$repo/space_only.sh"
+
+: > "$repo/empty.sh"
+
+git -C "$repo" add a.sh b.sh old.sh db/source_column.sql sqlite_cli_literal.sh sql_literal_edges.sh space_only.sh empty.sh
 
 "$EAGLE_BIN" scan --force "$repo" >/dev/null
 "$EAGLE_BIN" index --force "$repo" >/dev/null
 
+dot_command_chunk_count=$(eagle_db "SELECT COUNT(*)
+                                    FROM code_chunks
+                                    WHERE project = 'project'
+                                      AND file_path = 'sqlite_cli_literal.sh'
+                                      AND content LIKE '%.output stdout%';")
+if [ "$dot_command_chunk_count" != "1" ]; then
+    echo "index did not preserve sqlite dot-command-like source lines" >&2
+    exit 1
+fi
+
+leading_blank_hex=$(eagle_db "SELECT hex(substr(content, 1, 1))
+                              FROM code_chunks
+                              WHERE project = 'project'
+                                AND file_path = 'sql_literal_edges.sh'
+                              LIMIT 1;")
+if [ "$leading_blank_hex" != "0A" ]; then
+    echo "index did not preserve leading blank line in SQL literal expression" >&2
+    exit 1
+fi
+
+whitespace_chunk_count=$(eagle_db "SELECT COUNT(*)
+                                   FROM code_chunks
+                                   WHERE project = 'project'
+                                     AND file_path = 'space_only.sh'
+                                     AND length(content) > 0;")
+if [ "$whitespace_chunk_count" != "1" ]; then
+    echo "index did not preserve all-whitespace source chunk" >&2
+    exit 1
+fi
+
+empty_chunk_count=$(eagle_db "SELECT COUNT(*)
+                              FROM code_chunks
+                              WHERE project = 'project'
+                                AND file_path = 'empty.sh';")
+if [ "$empty_chunk_count" != "0" ]; then
+    echo "index should not create chunks for empty files" >&2
+    exit 1
+fi
+
 decl_count=$(eagle_db "SELECT COUNT(*)
                        FROM graph_nodes
                        WHERE project = 'project'