feat(v0.7.1): PreCompact transcript catch-up

Read transcript JSONL on PreCompact, enqueue entries newer than the
active task's last event timestamp as pending v2 chunks, spawn the
classify-worker. Closes the gap between the final PostToolUse and the
compaction event, where chunks were previously lost.

Also fix plugin/hooks/hooks.json PostToolUse template — was passing
\$TOOL_OUTPUT (an env var Claude Code never sets), so the plugin
install path always fed the classifier empty text. Stdin parse is the
correct wiring, matching install-hooks.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Shahinyanm

CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.1] - 2026-05-17
+
+PreCompact closes the gap before compaction — the synchronous hook only
+fires on `PostToolUse`, so any reasoning between the final tool call and
+the compact event used to vanish. v0.7.1 reads the transcript JSONL on
+`PreCompact`, enqueues entries newer than the active task's last event
+timestamp as pending v2 chunks, and spawns the classify-worker. The
+boundary marker still lands as before; the catch-up is additive.
+
+### Added
+- PreCompact transcript catch-up — `ingest-hook --kind=PreCompact` now
+  reads `transcript_path` from the hook stdin payload, walks the
+  session JSONL, and enqueues user/assistant entries newer than the
+  task's last event timestamp as pending v2 chunks (`UserPromptSubmit`
+  / `PreCompactChunk`). The classify-worker picks them up after the
+  hook returns. Best-effort: missing or unreadable transcript falls
+  through to the marker-only path.
+- Plugin `hooks.json` now wires `PreCompact` (was previously only
+  installed via `install-hooks`). Plugin users get the catch-up
+  without re-running the installer.
+- `TJ_DISABLE_CLASSIFY_SPAWN=1` env var — skips the classify-worker
+  spawn after enqueueing. Test-only; not documented as public.
+
+### Fixed
+- Plugin `hooks.json` PostToolUse template — was passing
+  `--text="$TOOL_OUTPUT"` (an env var Claude Code never sets), feeding
+  the classifier empty text and dropping every PostToolUse event in
+  the plugin install path. Now reads the hook payload from stdin like
+  `install-hooks` already does. Plugin users may see a sudden
+  uplift in captured events — by design.
+
 ## [0.7.0] - 2026-05-10
 
 Reasoning-chain ergonomics: surface the journal in the Claude Code

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 rust-version = "1.88"
 license = "MIT"

Cargo.toml

@@ -16,7 +16,7 @@ name = "task-journal"
 path = "src/main.rs"
 
 [dependencies]
-tj-core = { package = "task-journal-core", version = "0.7.0", path = "../tj-core" }
+tj-core = { package = "task-journal-core", version = "0.7.1", path = "../tj-core" }
 anyhow = { workspace = true }
 clap = { workspace = true }
 tracing = { workspace = true }

crates/tj-cli/Cargo.toml

@@ -1514,8 +1514,8 @@ fn main() -> Result<()> {
             // `$CLAUDE_HOOK_TEXT` env vars that Claude Code does NOT set,
             // so production was always called with empty text and every
             // event ended up rejected — see claude-memory-rsw.
-            let (kind, text) = match (kind, text) {
-                (Some(k), Some(t)) => (k, t),
+            let (kind, text, payload) = match (kind, text) {
+                (Some(k), Some(t)) => (k, t, serde_json::Value::Null),
                 _ => parse_hook_stdin()?,
             };
 
@@ -1566,10 +1566,14 @@ fn main() -> Result<()> {
             }
 
             // PreCompact: Claude Code is about to compact the conversation.
-            // Drop a marker decision event on the most-recent open task so
-            // the post-compact agent sees a clear boundary in the journal.
-            // The marker is intentionally minimal — a future v0.7.x may
-            // synthesize a real summary if CC starts exposing one on stdin.
+            // Two responsibilities:
+            //   1. Catch-up ingest — read the transcript JSONL tail (entries
+            //      newer than the active task's last event timestamp) and
+            //      enqueue them as pending v2 chunks for the classify-worker.
+            //      Closes the gap between the last PostToolUse hook and the
+            //      compaction event, where chunks would otherwise be lost.
+            //   2. Boundary marker — synthetic decision event so the
+            //      post-compact agent sees a clear cut in the journal.
             if kind == "PreCompact" {
                 if !events_path.exists() {
                     return Ok(());
@@ -1582,6 +1586,38 @@ fn main() -> Result<()> {
                 let Some(tc) = recent.into_iter().next() else {
                     return Ok(());
                 };
+
+                // (1) Catch-up ingest. Best-effort: missing transcript_path
+                // or unreadable JSONL falls through to the marker only.
+                let last_event_ts: Option<String> = conn
+                    .query_row(
+                        "SELECT timestamp FROM events_index WHERE task_id=?1 \
+                         ORDER BY timestamp DESC LIMIT 1",
+                        rusqlite::params![&tc.task_id],
+                        |r| r.get::<_, String>(0),
+                    )
+                    .ok();
+                let transcript_path = payload
+                    .get("transcript_path")
+                    .and_then(|x| x.as_str())
+                    .map(std::path::PathBuf::from);
+                if let Some(tp) = transcript_path.as_ref() {
+                    if tp.exists() {
+                        let enq = precompact_enqueue_transcript_chunks(
+                            tp,
+                            &events_path,
+                            &project_hash,
+                            &backend,
+                            last_event_ts.as_deref(),
+                        )
+                        .unwrap_or(0);
+                        if enq > 0 && std::env::var("TJ_DISABLE_CLASSIFY_SPAWN").is_err() {
+                            let _ = spawn_classify_worker(&backend);
+                        }
+                    }
+                }
+
+                // (2) Boundary marker.
                 let now = chrono::Utc::now()
                     .to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
                 let marker_text = format!(
@@ -2801,6 +2837,54 @@ fn persist_pending_v2(
     Ok(path)
 }
 
+/// PreCompact catch-up: parse the transcript JSONL and enqueue text
+/// chunks newer than `last_event_ts` as pending v2 entries. The
+/// classify-worker picks them up afterwards. Returns the number of
+/// chunks queued. Errors are absorbed — best-effort, never fatal.
+fn precompact_enqueue_transcript_chunks(
+    transcript_path: &std::path::Path,
+    events_path: &std::path::Path,
+    project_hash: &str,
+    backend: &str,
+    last_event_ts: Option<&str>,
+) -> anyhow::Result<usize> {
+    use tj_core::session::parser::{
+        extract_assistant_texts, extract_user_text, parse_session, SessionEntry,
+    };
+    let parsed = match parse_session(transcript_path) {
+        Ok(p) => p,
+        Err(_) => return Ok(0),
+    };
+    let mut count = 0usize;
+    for entry in &parsed.entries {
+        let (ts, text, kind) = match entry {
+            SessionEntry::User(u) => {
+                let text = extract_user_text(u).unwrap_or_default();
+                (u.timestamp.clone(), text, "UserPromptSubmit")
+            }
+            SessionEntry::Assistant(a) => {
+                let texts = extract_assistant_texts(a);
+                if texts.is_empty() {
+                    continue;
+                }
+                (a.timestamp.clone(), texts.join("\n"), "PreCompactChunk")
+            }
+            _ => continue,
+        };
+        if text.trim().len() < 20 {
+            continue;
+        }
+        if let Some(last) = last_event_ts {
+            if ts.as_str() <= last {
+                continue;
+            }
+        }
+        persist_pending_v2(events_path, kind, &text, project_hash, backend)?;
+        count += 1;
+    }
+    Ok(count)
+}
+
 /// Spawn the classify-worker as a detached child. We deliberately drop
 /// the `Child` handle so the parent (the actual Claude Code hook child)
 /// can exit without waiting; the worker re-parents to init on Linux.
@@ -3164,13 +3248,13 @@ fn drain_pending(
 /// piping), we silently return ("Stop", "") so the hook becomes a no-op
 /// instead of erroring — matches the `|| true` safety net in the
 /// installed hook command.
-fn parse_hook_stdin() -> anyhow::Result<(String, String)> {
+fn parse_hook_stdin() -> anyhow::Result<(String, String, serde_json::Value)> {
     let mut buf = String::new();
     std::io::Read::read_to_string(&mut std::io::stdin(), &mut buf)
         .context("read hook payload from stdin")?;
     let buf = buf.trim();
     if buf.is_empty() {
-        return Ok(("Stop".into(), String::new()));
+        return Ok(("Stop".into(), String::new(), serde_json::Value::Null));
     }
     let v: serde_json::Value =
         serde_json::from_str(buf).with_context(|| format!("parse hook payload JSON: {buf}"))?;
@@ -3209,7 +3293,7 @@ fn parse_hook_stdin() -> anyhow::Result<(String, String)> {
         _ => String::new(),
     };
 
-    Ok((kind, text))
+    Ok((kind, text, v))
 }
 
 fn parse_event_type(s: &str) -> anyhow::Result<tj_core::event::EventType> {

crates/tj-cli/src/main.rs

@@ -2482,6 +2482,127 @@ fn precompact_hook_with_no_open_task_writes_nothing() {
         .stdout("");
 }
 
+#[test]
+fn precompact_ingests_transcript_tail_into_pending_v2() {
+    let dir = assert_fs::TempDir::new().unwrap();
+    let workdir = dir.path().join("proj");
+    std::fs::create_dir_all(&workdir).unwrap();
+
+    let _task_id = String::from_utf8(
+        Command::cargo_bin("task-journal")
+            .unwrap()
+            .env("XDG_DATA_HOME", dir.path())
+            .current_dir(&workdir)
+            .args(["create", "Compactable thing"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
+    .to_string();
+
+    // Forge a transcript JSONL with two entries strictly newer than any
+    // timestamp `task-journal create` could have produced (year 2099) —
+    // so the catch-up walk sees them as "post-last-event".
+    let transcript = workdir.join("session.jsonl");
+    let line_user = r#"{"type":"user","uuid":"u1","timestamp":"2099-01-01T00:00:00.000Z","sessionId":"s1","message":{"content":"I think the auth middleware drops the token at the refresh boundary"}}"#;
+    let line_assistant = r#"{"type":"assistant","uuid":"a1","timestamp":"2099-01-01T00:00:05.000Z","sessionId":"s1","message":{"content":[{"type":"text","text":"Confirmed: src/auth/refresh.rs uses < instead of <= at the expiry comparison."}]}}"#;
+    std::fs::write(&transcript, format!("{line_user}\n{line_assistant}\n")).unwrap();
+
+    let stdin_payload = serde_json::json!({
+        "hook_event_name": "PreCompact",
+        "transcript_path": transcript.to_str().unwrap(),
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
+        .current_dir(&workdir)
+        .args(["ingest-hook", "--backend", "cli"])
+        .write_stdin(stdin_payload)
+        .assert()
+        .success();
+
+    let pending_dir = dir.path().join("task-journal").join("pending");
+    let queued: Vec<_> = std::fs::read_dir(&pending_dir)
+        .expect("pending dir must exist after PreCompact ingest")
+        .filter_map(|e| e.ok())
+        .collect();
+    assert_eq!(
+        queued.len(),
+        2,
+        "expected 2 pending v2 chunks (user + assistant), got {}",
+        queued.len()
+    );
+
+    // Verify v2 schema and that one entry carries the user text, the other the assistant text.
+    let mut saw_user = false;
+    let mut saw_assistant = false;
+    for entry in &queued {
+        let body = std::fs::read_to_string(entry.path()).unwrap();
+        let v: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(v["schema"], "v2");
+        let text = v["text"].as_str().unwrap_or("");
+        if text.contains("auth middleware drops the token") {
+            saw_user = true;
+            assert_eq!(v["kind"], "UserPromptSubmit");
+        }
+        if text.contains("uses < instead of <=") {
+            saw_assistant = true;
+            assert_eq!(v["kind"], "PreCompactChunk");
+        }
+    }
+    assert!(saw_user && saw_assistant, "missing one of the chunks: user={saw_user} assistant={saw_assistant}");
+}
+
+#[test]
+fn precompact_skips_transcript_entries_older_than_last_event() {
+    let dir = assert_fs::TempDir::new().unwrap();
+    let workdir = dir.path().join("proj");
+    std::fs::create_dir_all(&workdir).unwrap();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .current_dir(&workdir)
+        .args(["create", "Already covered"])
+        .assert()
+        .success();
+
+    // Transcript with entries from year 2000 — strictly older than the
+    // task's create event. Catch-up must skip both, leaving pending empty.
+    let transcript = workdir.join("session.jsonl");
+    let line_old = r#"{"type":"user","uuid":"u1","timestamp":"2000-01-01T00:00:00.000Z","sessionId":"s1","message":{"content":"ancient chatter that classifier already processed"}}"#;
+    std::fs::write(&transcript, format!("{line_old}\n")).unwrap();
+
+    let stdin_payload = serde_json::json!({
+        "hook_event_name": "PreCompact",
+        "transcript_path": transcript.to_str().unwrap(),
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
+        .current_dir(&workdir)
+        .args(["ingest-hook", "--backend", "cli"])
+        .write_stdin(stdin_payload)
+        .assert()
+        .success();
+
+    let pending_dir = dir.path().join("task-journal").join("pending");
+    let queued_count = std::fs::read_dir(&pending_dir)
+        .map(|it| it.count())
+        .unwrap_or(0);
+    assert_eq!(queued_count, 0, "no chunks must be queued for ancient transcript");
+}
+
 #[test]
 fn rewind_prompt_appends_correction_event() {
     let dir = assert_fs::TempDir::new().unwrap();

crates/tj-cli/tests/cli.rs

@@ -16,7 +16,7 @@ name = "task-journal-mcp"
 path = "src/main.rs"
 
 [dependencies]
-tj-core = { package = "task-journal-core", version = "0.7.0", path = "../tj-core" }
+tj-core = { package = "task-journal-core", version = "0.7.1", path = "../tj-core" }
 anyhow = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }

crates/tj-mcp/Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "task-journal",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Append-only journal of AI-coding task reasoning chains: hypotheses, decisions, rejections, evidence. Renders compact resume packs so an agent can pick up a 2-week-old task with full context.",
   "author": {
     "name": "Mher Shahinyan"

plugin/.claude-plugin/plugin.json

@@ -6,7 +6,18 @@
         "hooks": [
           {
             "type": "command",
-            "command": "task-journal ingest-hook --kind=PostToolUse --text=\"$TOOL_OUTPUT\" --backend=cli 2>/dev/null || true"
+            "command": "task-journal ingest-hook --backend=cli 2>/dev/null || true"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "task-journal ingest-hook --backend=cli 2>/dev/null || true"
           }
         ]
       }