agent-dump 1.2.0__tar.gz → 1.2.2__tar.gz

{agent_dump-1.2.0 → agent_dump-1.2.2}/Cargo.lock

@@ -10,7 +10,7 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "agent-dump"
-version = "1.2.0"
+version = "1.2.2"
 dependencies = [
  "agent-dump-core",
  "caseless",

{agent_dump-1.2.0 → agent_dump-1.2.2}/Cargo.toml

@@ -46,7 +46,7 @@ nix = { version = "0.31", default-features = false, features = ["fs", "user"] }
 
 [package]
 name = "agent-dump"
-version = "1.2.0"
+version = "1.2.2"
 edition = "2024"
 rust-version = "1.90"
 publish = false

{agent_dump-1.2.0 → agent_dump-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-dump
-Version: 1.2.0
+Version: 1.2.2
 Classifier: Environment :: Console
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
@@ -462,7 +462,7 @@ File discovery failures include partially unreadable providers. Valid sessions r
 
 When some session reads or summaries fail, collection continues with successful sessions. The saved Markdown includes a fixed incomplete-report notice with failure and included-session counts; an entirely failed run still fails.
 
-Collect discovers candidate sessions without a creation-time cutoff and processes user/assistant visible text only within the requested local dates. A session spanning several days is split into separate daily units before summarization; session counts remain unique URI counts. Text without a reliable timestamp is excluded and reported as an incomplete date-coverage gap (including undated Kimi context and inferred Cursor times). No session creation/update time is substituted. Query filters select candidates; limits apply to unique sessions after text-date filtering. Events, including long individual messages, are split into chunks of at most 3,200 Unicode characters including labels. Chunk summaries are merged in groups of at most eight; large final reports are rendered in separate source-preserving groups. Model inputs are limited to 64,000 characters per request. Oversized metadata or derived summaries fail explicitly; source text is never silently truncated. Partial reports list omitted session URIs. Full input coverage does not mean a summary preserves every detail.
+Collect discovers candidate sessions without a creation-time cutoff and processes user/assistant visible text only within the requested local dates. A session spanning several days is split into separate daily units before summarization; session counts remain unique URI counts. Text without a reliable timestamp (including undated Kimi context and inferred Cursor times) belongs to no date and is excluded without being reported as a coverage gap. No session creation/update time is substituted. Query filters select candidates; limits apply to unique sessions after text-date filtering. Events, including long individual messages, are split into chunks of at most 3,200 Unicode characters including labels. Chunk summaries are merged in groups of at most eight; large final reports are rendered in separate source-preserving groups. Model inputs are limited to 64,000 characters per request. Oversized metadata or derived summaries fail explicitly; source text is never silently truncated. Partial reports list omitted session URIs. Full input coverage does not mean a summary preserves every detail.
 
 PM summaries merge sessions only within the same date and known working directory. Sessions without a working directory retain separate attribution.
 

{agent_dump-1.2.0 → agent_dump-1.2.2}/README.md

@@ -438,7 +438,7 @@ File discovery failures include partially unreadable providers. Valid sessions r
 
 When some session reads or summaries fail, collection continues with successful sessions. The saved Markdown includes a fixed incomplete-report notice with failure and included-session counts; an entirely failed run still fails.
 
-Collect discovers candidate sessions without a creation-time cutoff and processes user/assistant visible text only within the requested local dates. A session spanning several days is split into separate daily units before summarization; session counts remain unique URI counts. Text without a reliable timestamp is excluded and reported as an incomplete date-coverage gap (including undated Kimi context and inferred Cursor times). No session creation/update time is substituted. Query filters select candidates; limits apply to unique sessions after text-date filtering. Events, including long individual messages, are split into chunks of at most 3,200 Unicode characters including labels. Chunk summaries are merged in groups of at most eight; large final reports are rendered in separate source-preserving groups. Model inputs are limited to 64,000 characters per request. Oversized metadata or derived summaries fail explicitly; source text is never silently truncated. Partial reports list omitted session URIs. Full input coverage does not mean a summary preserves every detail.
+Collect discovers candidate sessions without a creation-time cutoff and processes user/assistant visible text only within the requested local dates. A session spanning several days is split into separate daily units before summarization; session counts remain unique URI counts. Text without a reliable timestamp (including undated Kimi context and inferred Cursor times) belongs to no date and is excluded without being reported as a coverage gap. No session creation/update time is substituted. Query filters select candidates; limits apply to unique sessions after text-date filtering. Events, including long individual messages, are split into chunks of at most 3,200 Unicode characters including labels. Chunk summaries are merged in groups of at most eight; large final reports are rendered in separate source-preserving groups. Model inputs are limited to 64,000 characters per request. Oversized metadata or derived summaries fail explicitly; source text is never silently truncated. Partial reports list omitted session URIs. Full input coverage does not mean a summary preserves every detail.
 
 PM summaries merge sessions only within the same date and known working directory. Sessions without a working directory retain separate attribution.
 

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/Cargo.toml

@@ -15,7 +15,7 @@ workspace = true
 jiff.workspace = true
 md-5.workspace = true
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["raw_value"] }
 regex.workspace = true
 sha2.workspace = true
 tempfile.workspace = true

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/compat/json.rs

@@ -32,7 +32,7 @@ pub fn nonfinite(number: &Number) -> Option<f64> {
     }
 }
 
-fn normalize(value: &mut Value) {
+pub(crate) fn normalize(value: &mut Value) {
     match value {
         Value::Number(number) if number.as_str().contains(['.', 'e', 'E']) => {
             if let Ok(value) = number.as_str().parse::<f64>()
@@ -50,7 +50,7 @@ fn normalize(value: &mut Value) {
 pub fn from_slice(bytes: &[u8]) -> crate::Result<Value> {
     let text = std::str::from_utf8(bytes)
         .map_err(|error| diagnostic::invalid_utf8(bytes, error))?;
-    let original = serde_json::from_slice::<Value>(bytes);
+    let original = serde_json::from_str::<Value>(text);
     if let Ok(mut value) = original {
         normalize(&mut value);
         return Ok(value);

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/output/render.rs

@@ -5,7 +5,10 @@ const fn unsafe_char(c: char) -> bool {
     matches!(c, '\u{0}'..='\u{8}' | '\u{b}'..='\u{1f}' | '\u{7f}'..='\u{9f}' | '\u{61c}' | '\u{200e}' | '\u{200f}' | '\u{202a}'..='\u{202e}' | '\u{2066}'..='\u{2069}')
 }
 pub fn safe_body(text: &str) -> String {
-    text.chars().filter(|c| !unsafe_char(*c)).collect()
+    let mut safe = String::with_capacity(text.len());
+    text.split(unsafe_char)
+        .for_each(|piece| safe.push_str(piece));
+    safe
 }
 pub fn safe_line(text: &str) -> String {
     let replaced: String = text
@@ -458,3 +461,14 @@ pub fn metadata_summary(session: &Session, scheme: &str, zh: bool) -> String {
     fields.push(format!("uri={scheme}://{}", session.id));
     safe_line(&fields.join(" | "))
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn safe_body_drops_terminal_controls_and_keeps_layout() {
+        assert_eq!(
+            super::safe_body("\x1b[2J测试\u{202e}\n\tmore\rtext\u{7f}\u{85}"),
+            "[2J测试\n\tmoretext"
+        );
+    }
+}

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/providers/claude/mod.rs

@@ -13,6 +13,17 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
+static RECORD: jsonl::Shape = jsonl::Shape::Fields(&[
+    ("timestamp", jsonl::Shape::Leaf),
+    (
+        "message",
+        jsonl::Shape::Fields(&[
+            ("role", jsonl::Shape::Leaf),
+            ("model", jsonl::Shape::Leaf),
+        ]),
+    ),
+]);
+
 pub struct Claude {
     roots: SourceRoots,
     titles: HashMap<PathBuf, HashMap<String, Value>>,
@@ -117,7 +128,7 @@ impl Claude {
     }
 
     fn scan(path: &Path) -> crate::Result<jsonl::Metadata> {
-        jsonl::metadata(path, 20)
+        jsonl::metadata(path, 20, Some(&RECORD))
     }
 
     fn parse(

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/providers/codex/mod.rs

@@ -14,6 +14,21 @@ use crate::session::{Session, SessionData, parse_timestamp};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
+static RECORD: jsonl::Shape = jsonl::Shape::Fields(&[
+    ("timestamp", jsonl::Shape::Leaf),
+    (
+        "payload",
+        jsonl::Shape::Fields(&[
+            ("type", jsonl::Shape::Leaf),
+            ("model", jsonl::Shape::Leaf),
+            (
+                "arguments",
+                jsonl::Shape::Fields(&[("model", jsonl::Shape::Leaf)]),
+            ),
+        ]),
+    ),
+]);
+
 pub struct Codex {
     roots: SourceRoots,
     titles: Option<HashMap<String, String>>,
@@ -79,7 +94,7 @@ impl Codex {
     }
 
     fn scan(path: &Path) -> crate::Result<jsonl::Metadata> {
-        jsonl::metadata(path, 10)
+        jsonl::metadata(path, 10, Some(&RECORD))
     }
 
     fn parse(

agent_dump-1.2.2/crates/agent-dump-core/src/providers/jsonl.rs

@@ -0,0 +1,275 @@
+use crate::providers::contract::{DiagnosticSink, RecoverableDiagnostic};
+use serde::de::{Deserializer, IgnoredAny, MapAccess, Visitor};
+use serde_json::value::RawValue;
+use serde_json::{Map, Value};
+use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
+use std::path::Path;
+
+pub const FULL_SCAN_LIMIT: u64 = 256 * 1024;
+const WINDOW: u64 = 64 * 1024;
+
+pub struct Metadata {
+    pub header: Option<Value>,
+    pub records: Vec<Value>,
+    pub tail: Option<Value>,
+    pub complete: bool,
+}
+
+/// Fields a provider reads from a record. `Fields` positions are only
+/// indexed, so a non-object there is kept as null.
+pub enum Shape {
+    Leaf,
+    Fields(&'static [(&'static str, Shape)]),
+}
+
+struct Pruned(&'static [(&'static str, Shape)]);
+
+impl<'de> Visitor<'de> for Pruned {
+    type Value = Map<String, Value>;
+
+    fn expecting(
+        &self,
+        formatter: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        formatter.write_str("a JSON object")
+    }
+
+    fn visit_map<A: MapAccess<'de>>(
+        self,
+        mut map: A,
+    ) -> Result<Self::Value, A::Error> {
+        let mut object = Map::new();
+        while let Some(key) = map.next_key::<String>()? {
+            if let Some((_, shape)) =
+                self.0.iter().find(|(name, _)| *name == key)
+            {
+                let raw = map.next_value::<&RawValue>()?;
+                let value = project(raw.get(), shape)
+                    .map_err(serde::de::Error::custom)?;
+                object.insert(key, value);
+            } else {
+                map.next_value::<IgnoredAny>()?;
+            }
+        }
+        Ok(object)
+    }
+}
+
+fn project(text: &str, shape: &'static Shape) -> serde_json::Result<Value> {
+    match shape {
+        Shape::Leaf => serde_json::from_str(text),
+        Shape::Fields(fields) if text.starts_with('{') => {
+            let mut deserializer = serde_json::Deserializer::from_str(text);
+            let object = deserializer.deserialize_map(Pruned(fields))?;
+            deserializer.end()?;
+            Ok(Value::Object(object))
+        }
+        Shape::Fields(_) => Ok(Value::Null),
+    }
+}
+
+fn object(bytes: &[u8]) -> Option<Value> {
+    crate::compat::json::from_slice(bytes)
+        .ok()
+        .filter(Value::is_object)
+}
+
+fn pruned(bytes: &[u8], shape: &'static Shape) -> Option<Value> {
+    let text = std::str::from_utf8(bytes).ok()?;
+    let text = text.trim_start_matches([' ', '\t', '\n', '\r']);
+    if !text.starts_with('{') {
+        return None;
+    }
+    // Inputs serde_json rejects, such as NaN, take the compatible path.
+    let Ok(mut value) = project(text, shape) else {
+        return object(bytes);
+    };
+    crate::compat::json::normalize(&mut value);
+    Some(value)
+}
+
+fn nonempty(bytes: &[u8]) -> bool {
+    bytes.iter().any(|byte| !byte.is_ascii_whitespace())
+}
+
+/// Records after the first `head_lines` keep only the fields in `shape`.
+pub fn metadata(
+    path: &Path,
+    head_lines: usize,
+    shape: Option<&'static Shape>,
+) -> crate::Result<Metadata> {
+    let mut file = crate::storage::source_io::open(path)?;
+    let size = file.metadata()?.len();
+    let mut bytes = Vec::new();
+    if size <= FULL_SCAN_LIMIT {
+        crate::storage::source_io::at(path, file.read_to_end(&mut bytes))?;
+        let lines: Vec<_> = bytes
+            .split(|byte| *byte == b'\n')
+            .filter(|line| nonempty(line))
+            .collect();
+        let mut records = Vec::new();
+        for line in &lines {
+            records.extend(match shape {
+                Some(shape) if records.len() >= head_lines => {
+                    pruned(line, shape)
+                }
+                _ => object(line),
+            });
+        }
+        return Ok(Metadata {
+            header: lines.first().and_then(|line| object(line)),
+            records,
+            tail: None,
+            complete: true,
+        });
+    }
+    crate::storage::source_io::at(
+        path,
+        file.by_ref().take(WINDOW).read_to_end(&mut bytes),
+    )?;
+    let end = bytes.iter().rposition(|byte| *byte == b'\n');
+    let lines: Vec<_> = end
+        .map(|end| {
+            bytes[..=end]
+                .split(|byte| *byte == b'\n')
+                .take(head_lines)
+                .filter(|line| nonempty(line))
+                .collect()
+        })
+        .unwrap_or_default();
+    let header = if end.is_none() {
+        Some(serde_json::json!({}))
+    } else {
+        lines.first().and_then(|line| object(line))
+    };
+    let records = lines.iter().filter_map(|line| object(line)).collect();
+    file.seek(SeekFrom::Start(size - WINDOW))?;
+    let mut tail = Vec::new();
+    file.take(WINDOW).read_to_end(&mut tail)?;
+    let tail_record =
+        tail.iter()
+            .position(|byte| *byte == b'\n')
+            .and_then(|start| {
+                let end = tail.iter().rposition(|byte| *byte == b'\n')?;
+                tail[start + 1..=end]
+                    .split(|byte| *byte == b'\n')
+                    .rev()
+                    .find(|line| nonempty(line))
+                    .and_then(object)
+            });
+    Ok(Metadata {
+        header,
+        records,
+        tail: tail_record,
+        complete: false,
+    })
+}
+
+pub fn scan(
+    path: &Path,
+    diagnostics: &mut DiagnosticSink<'_>,
+    mut append: impl FnMut(Value, &mut DiagnosticSink<'_>) -> crate::Result<()>,
+) -> crate::Result<()> {
+    scan_numbered(path, diagnostics, |_, record, diagnostics| {
+        append(record, diagnostics)
+    })
+}
+
+pub fn scan_numbered(
+    path: &Path,
+    diagnostics: &mut DiagnosticSink<'_>,
+    mut append: impl FnMut(
+        usize,
+        Value,
+        &mut DiagnosticSink<'_>,
+    ) -> crate::Result<()>,
+) -> crate::Result<()> {
+    let mut reader = BufReader::new(crate::storage::source_io::open(path)?);
+    let mut line = Vec::new();
+    let mut number = 0;
+    let mut skipped = Vec::new();
+    let mut count = 0;
+    loop {
+        line.clear();
+        if crate::storage::source_io::at(
+            path,
+            reader.read_until(b'\n', &mut line),
+        )? == 0
+        {
+            break;
+        }
+        number += 1;
+        if !nonempty(&line) {
+            continue;
+        }
+        if let Some(value) = object(&line) {
+            append(number, value, diagnostics)?;
+        } else if matches!(line.last(), Some(b'\n' | b'\r')) {
+            count += 1;
+            if skipped.len() < 5 {
+                skipped.push(number);
+            }
+        }
+    }
+    if count > 0 {
+        diagnostics(RecoverableDiagnostic::JsonlRecordsSkipped {
+            path: path.to_owned(),
+            count,
+            lines: skipped,
+        })?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    static SHAPE: Shape = Shape::Fields(&[
+        ("timestamp", Shape::Leaf),
+        (
+            "payload",
+            Shape::Fields(&[
+                ("type", Shape::Leaf),
+                ("arguments", Shape::Fields(&[("model", Shape::Leaf)])),
+            ]),
+        ),
+    ]);
+
+    #[test]
+    fn pruned_records_read_like_full_records() {
+        let lines: [&[u8]; 12] = [
+            br#"{"timestamp":"t","payload":{"type":"message","content":"x"}}"#,
+            br#"{"timestamp":"t","payload":[{"type":"message"}]}"#,
+            br#"{"payload":{"type":["message"]}}"#,
+            br#"{"payload":{"type":{"kind":"message"}}}"#,
+            br#"{"timestamp":"t","payload":{"type":"message","n":NaN}}"#,
+            br#"{"timestamp":"a","timestamp":"b","payload":{"type":1}}"#,
+            br#"  {"timestamp":"c","payload":{"arguments":"{}"}}"#,
+            br#"{"payload":{"arguments":{"model":"m"}},"timestamp":1e999}"#,
+            br#"[{"timestamp":"t"}]"#,
+            br#"{"timestamp":"t"} trailing"#,
+            b"{\"timestamp\":\"\xff\"}",
+            br#"{"timestamp":"t","payload":"text"}"#,
+        ];
+        for line in lines {
+            let full = object(line);
+            let pruned = pruned(line, &SHAPE);
+            assert_eq!(full.is_some(), pruned.is_some(), "{line:?}");
+            let (Some(full), Some(pruned)) = (full, pruned) else {
+                continue;
+            };
+            for path in [
+                &["timestamp"][..],
+                &["payload", "type"],
+                &["payload", "arguments", "model"],
+            ] {
+                let read = |value: &Value| {
+                    path.iter()
+                        .fold(value.clone(), |value, key| value[key].clone())
+                };
+                assert_eq!(read(&full), read(&pruned), "{line:?} {path:?}");
+            }
+        }
+    }
+}

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/providers/pi/mod.rs

@@ -36,7 +36,7 @@ impl Pi {
     }
 
     fn scan(path: &Path) -> crate::Result<crate::providers::jsonl::Metadata> {
-        crate::providers::jsonl::metadata(path, 20)
+        crate::providers::jsonl::metadata(path, 20, None)
     }
 
     fn parse(

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/query/context.rs

@@ -45,17 +45,41 @@ pub fn locate(
     query: &Query,
 ) -> crate::Result<Vec<Location>> {
     let revision = revision(data)?;
+    Ok(evidence(data, query)
+        .into_iter()
+        .map(|(index, snippet)| {
+            let position = index + 1;
+            Location {
+                position,
+                locator: format!("{revision}:{position}"),
+                role: data.messages[index].role.clone(),
+                snippet,
+            }
+        })
+        .collect())
+}
+
+pub fn hits(data: &SessionData, query: &Query) -> Vec<usize> {
+    evidence(data, query)
+        .into_iter()
+        .map(|(index, _)| index)
+        .collect()
+}
+
+fn evidence(data: &SessionData, query: &Query) -> Vec<(usize, String)> {
     let text = TextQuery::new(
         query.keyword.as_deref().unwrap_or(""),
         crate::query::text::Mode::Terms,
     );
+    if text.literals.is_empty() {
+        return Vec::new();
+    }
     let terms: Vec<_> = text
         .literals
         .iter()
         .map(|term| TextQuery::new(term, crate::query::text::Mode::Phrase))
         .collect();
-    Ok(data
-        .messages
+    data.messages
         .iter()
         .enumerate()
         .filter_map(|(index, message)| {
@@ -69,15 +93,9 @@ pub fn locate(
             let content = searchable_message(message);
             let evidence =
                 terms.iter().find_map(|term| term.find(&[&content]))?;
-            let position = index + 1;
-            Some(Location {
-                position,
-                locator: format!("{revision}:{position}"),
-                role: message.role.clone(),
-                snippet: evidence.snippet,
-            })
+            Some((index, evidence.snippet))
         })
-        .collect())
+        .collect()
 }
 
 pub fn window(

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/query/index/tests.rs

@@ -356,3 +356,30 @@ fn existing_normalized_text_copies_remain_usable() {
         .unwrap();
     assert_eq!(stored, "after 认 证");
 }
+
+#[test]
+fn updates_refresh_last_seen_only_after_a_day() {
+    let directory = tempfile::tempdir().unwrap();
+    let mut index =
+        SearchIndex::at(&directory.path().join("index.db")).unwrap();
+    let a = session(directory.path(), "a", 0);
+    let provider = Reader(|_: &Session| Ok("body".into()));
+    let seen = |index: &mut SearchIndex, value: Option<f64>| -> f64 {
+        if let Some(value) = value {
+            index
+                .connection
+                .execute("UPDATE index_state SET last_seen_at = ?", [value])
+                .unwrap();
+            update(index, &provider, std::slice::from_ref(&a));
+        }
+        index
+            .connection
+            .query_row("SELECT last_seen_at FROM index_state", [], |r| r.get(0))
+            .unwrap()
+    };
+    update(&mut index, &provider, std::slice::from_ref(&a));
+    let stale = 2.0f64.mul_add(-86400.0, now());
+    assert!(seen(&mut index, Some(stale)) > stale + 86400.0);
+    let recent = now() - 3600.0;
+    assert!((seen(&mut index, Some(recent)) - recent).abs() < f64::EPSILON);
+}

{agent_dump-1.2.0 → agent_dump-1.2.2}/crates/agent-dump-core/src/query/index.rs

@@ -213,11 +213,10 @@ impl SearchIndex {
     ) -> crate::Result<(usize, Vec<String>)> {
         let observed = now();
         let indexed: HashMap<String, IndexedRow> = self.connection.prepare("SELECT session_id, updated_signature, fts_rowid, indexed_at FROM index_state WHERE agent = ?")?.query_map([info.name], |r| Ok((r.get(0)?, IndexedRow { signature: r.get(1)?, rowid: r.get(2)?, observed: r.get(3)? })))?.collect::<Result<_, _>>()?;
-        let transaction = self.connection.transaction()?;
-        for session in sessions {
-            transaction.execute("UPDATE index_state SET last_seen_at = MAX(last_seen_at, ?) WHERE agent = ? AND session_id = ?", params![observed, info.name, session.id])?;
-        }
-        transaction.commit()?;
+        let ids: Vec<_> = sessions.iter().map(|session| &session.id).collect();
+        // Rows expire after 30 unseen days. Refreshing at most daily lets
+        // repeated searches skip the write and its journal sync.
+        self.connection.execute("UPDATE index_state SET last_seen_at = ? WHERE agent = ? AND last_seen_at < ? AND session_id IN (SELECT value FROM json_each(?))", params![observed, info.name, observed - 86400.0, serde_json::to_string(&ids)?])?;
         let pending: Vec<_> = sessions
             .iter()
             .filter_map(|session| {
@@ -371,20 +370,10 @@ impl SearchIndex {
         let Some(table) = fts_table(query) else {
             return self.literal_search(query, keys);
         };
-        // The contentless normalized table stores no text; its matches read
-        // the raw trigram row.
-        let (raw, fields) = if table == "sessions_fts" {
-            (
-                "JOIN sessions_fts_trigram raw ON raw.rowid = f.rowid",
-                "raw.title, raw.content",
-            )
-        } else {
-            ("", "f.title, f.content")
-        };
         // Unary + keeps MATCH as the FTS scan instead of repeating it per key.
         // Filtering returned rows retains the global BM25 corpus.
         let sql = format!(
-            "SELECT s.agent, s.session_id, {fields}, bm25({table}) FROM {table} f {raw} JOIN index_state s ON s.fts_rowid = f.rowid WHERE {table} MATCH ? AND +f.rowid IN (SELECT scoped.fts_rowid FROM json_each(?) scope JOIN index_state scoped ON scoped.agent = json_extract(scope.value, '$[0]') AND scoped.session_id = json_extract(scope.value, '$[1]')) ORDER BY bm25({table}), s.session_updated_at DESC, s.session_created_at DESC, s.agent, s.session_id"
+            "SELECT s.agent, s.session_id, f.rowid, bm25({table}) FROM {table} f JOIN index_state s ON s.fts_rowid = f.rowid WHERE {table} MATCH ? AND +f.rowid IN (SELECT scoped.fts_rowid FROM json_each(?) scope JOIN index_state scoped ON scoped.agent = json_extract(scope.value, '$[0]') AND scoped.session_id = json_extract(scope.value, '$[1]')) ORDER BY bm25({table}), s.session_updated_at DESC, s.session_created_at DESC, s.agent, s.session_id"
         );
         let expression = query
             .literals
@@ -399,23 +388,33 @@ impl SearchIndex {
             })
             .collect::<Vec<_>>()
             .join(" ");
-        let mut statement = self.connection.prepare(&sql)?;
-        let mut rows = statement
-            .query(params![expression, serde_json::to_string(keys)?])?;
+        let mut ranked = self.connection.prepare(&sql)?;
+        let mut rows =
+            ranked.query(params![expression, serde_json::to_string(keys)?])?;
+        // Ranked rows carry no text, so sorting never spills whole bodies to
+        // temporary files. Both tables share rowids; the trigram row holds
+        // the text.
+        let mut text = self.connection.prepare(
+            "SELECT title, content FROM sessions_fts_trigram WHERE rowid = ?",
+        )?;
         let mut results = Vec::new();
         while let Some(row) = rows.next()? {
-            let provider: String = row.get(0)?;
-            let id: String = row.get(1)?;
-            let title: String = row.get(2)?;
-            let content: String = row.get(3)?;
+            let Some((title, content)) = text
+                .query_row([row.get::<_, i64>(2)?], |r| {
+                    Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
+                })
+                .optional()?
+            else {
+                continue;
+            };
             let Some(evidence) = query.find(&[&title, &content]) else {
                 continue;
             };
             results.push(SearchResult {
-                provider,
-                id,
+                provider: row.get(0)?,
+                id: row.get(1)?,
                 snippet: evidence.snippet,
-                rank: -row.get::<_, f64>(4)?,
+                rank: -row.get::<_, f64>(3)?,
             });
         }
         Ok(results)