eagle-mem 4.10.8 → 4.10.10

package/CHANGELOG.md

@@ -4,6 +4,26 @@ 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:
+
+- **Memory Node Wiring**: Dream Cycle curation now creates graph `memory` nodes for active mirrored agent memories before consolidation runs, so consolidated memories can supersede real source memory nodes instead of depending on fuzzy or accidental matches.
+- **Regression Coverage**: The smoke suite now runs an isolated Dream Cycle graph-memory regression that proves multiline memory content does not become bogus graph nodes and that consolidated memories supersede both originals.
+
+---
+
 ## v4.10.8 Graph Neighbors Hotfix
 
 This hotfix tightens the final graph-memory verification path:

package/README.md

@@ -184,6 +184,8 @@ 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. Consolidation responses use a strict JSON contract, and dry-run previews skip the provider call for the memory-consolidation step.
+
 ### Trust and Recovery
 
 Eagle Mem now treats installation as a visible product surface, not a black box:

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "eagle-mem",
-  "version": "4.10.8",
+  "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"
   },
+  "scripts": {
+    "test": "bash scripts/test.sh"
+  },
   "files": [
     "bin/",
     "scripts/",

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,19 +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
-    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
-
-For any memories that should be consolidated, merge them into a single 'Compiled Truth' summary.
-The consolidated memory MUST be formatted exactly as:
+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_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
+        wired_memory_count=$((wired_memory_count + 1))
+    done
+    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
+
+    memory_prompt_json=$(printf '%s' "$active_memory_rows" | jq -c '[.[] | {
+        memory_name: .memory_name,
+        memory_type: .memory_type,
+        description: .description,
+        content: .content
+    }]')
+
+    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.>
 
@@ -589,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/scripts/test.sh

@@ -52,6 +52,7 @@ run_check "Cross Agent Memory (memories query)" "\"$EAGLE_BIN\" memories --json
 run_check "Installer And Updater (install / update syntax)" "bash -n \"$SCRIPTS_DIR/install.sh\" && bash -n \"$SCRIPTS_DIR/update.sh\""
 run_check "Code Scan And Index (scan / index syntax)" "bash -n \"$SCRIPTS_DIR/scan.sh\" && bash -n \"$SCRIPTS_DIR/index.sh\""
 run_check "Graph Memory Rebuild (isolated regression suite)" "bash \"$SCRIPTS_DIR/../tests/test_graph_memory.sh\""
+run_check "Dream Cycle Memory Graph Wiring (isolated regression suite)" "bash \"$SCRIPTS_DIR/../tests/test_curate_graph_memories.sh\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then

package/tests/test_curate_graph_memories.sh

@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# Ensures curate wires source agent memories before adding consolidated graph edges.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+EAGLE_BIN="$ROOT_DIR/bin/eagle-mem"
+
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-curate-graph.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" "$tmp_dir/bin"
+
+cat > "$tmp_dir/bin/curl" <<'EOF'
+#!/usr/bin/env bash
+if [ -n "${EAGLE_CURATE_FAKE_CURL_MARKER:-}" ]; then
+    echo called >> "$EAGLE_CURATE_FAKE_CURL_MARKER"
+fi
+
+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"
+
+. "$ROOT_DIR/lib/common.sh"
+"$ROOT_DIR/db/migrate.sh" >/dev/null
+. "$ROOT_DIR/lib/db.sh"
+
+cat > "$EAGLE_MEM_DIR/config.toml" <<'EOF'
+[provider]
+type = "ollama"
+
+[ollama]
+url = "http://127.0.0.1:11434"
+model = "fake"
+EOF
+
+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;"
+}
+
+# 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
+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
+
+echo "curate graph memory regressions passed"

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'