feat(v0.9.3): Stop hook transcript catch-up

Replace the v0.7.0-era hardcoded `--kind=Stop --text="Session ended"`
hook command with the same transcript-tail catch-up that PreCompact
already does. The old form queued one unclassifiable noise entry
per session end; v0.9.3 reads the JSONL session log and enqueues
user + assistant entries newer than the active task's last event
timestamp.

Implementation: rename precompact_enqueue_transcript_chunks →
enqueue_transcript_chunks_since_last_event with a new
`assistant_chunk_kind` parameter, then call from both PreCompact
(`PreCompactChunk`) and Stop (`StopChunk`) branches. Distinct kinds
let ops grep pending/ by source hook.

Mock test paths (`--mock-event-type` + `--mock-task-id`) bypass
the new Stop branch so existing test fixtures invoking
`--kind=Stop` with mock args still hit the mock-classifier
dispatch unchanged.

Plugin hooks.json Stop entry drops the explicit `--kind=Stop
--text="Session ended"` flags and reads the hook stdin payload
like PostToolUse and PreCompact.

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

Author: Shahinyanm

CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.3] - 2026-05-17
+
+**Stop hook learns to catch up.** Previously the `Stop` hook fired
+with a hardcoded `--text="Session ended"` — a sentinel string that
+carried no semantic signal and just littered the pending queue with
+unclassifiable noise (the heuristic skipped it, the API would have
+spent a haiku call to say "this is nothing"). v0.9.3 replaces it with
+the same transcript-tail catch-up that PreCompact already does:
+parse the JSONL session log, enqueue user + assistant entries newer
+than the active task's last event timestamp, spawn the
+classify-worker. No boundary marker — a session end isn't a
+reasoning boundary, just a pause.
+
+### Added
+- Stop-hook transcript catch-up. Mirrors the PreCompact catch-up
+  introduced in v0.7.1. Reads `transcript_path` from the hook stdin
+  payload; chunks land as `UserPromptSubmit` (user) or `StopChunk`
+  (assistant) pending v2 entries. Distinct `StopChunk` kind lets ops
+  grep the pending dir by source hook.
+- `enqueue_transcript_chunks_since_last_event` helper — extracted
+  from the PreCompact branch so both hooks share the same code path.
+  Old `precompact_enqueue_transcript_chunks` was renamed; same body,
+  one new parameter (`assistant_chunk_kind`).
+
+### Changed
+- Plugin `hooks.json` Stop entry no longer pins
+  `--kind=Stop --text="Session ended"`. Reads hook stdin payload
+  like PostToolUse and PreCompact already do.
+
+### Compatibility
+- Mock test path (`--mock-event-type` + `--mock-task-id`) bypasses
+  the new Stop branch so existing test fixtures invoking
+  `--kind=Stop` with mock args still hit the mock-classifier
+  dispatch instead of being intercepted by transcript catch-up.
+
 ## [0.9.2] - 2026-05-17
 
 ### Fixed

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.9.2"
+version = "0.9.3"
 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.9.2", path = "../tj-core" }
+tj-core = { package = "task-journal-core", version = "0.9.3", path = "../tj-core" }
 anyhow = { workspace = true }
 clap = { workspace = true }
 tracing = { workspace = true }

crates/tj-cli/Cargo.toml

@@ -1587,12 +1587,13 @@ fn main() -> Result<()> {
                     .map(std::path::PathBuf::from);
                 if let Some(tp) = transcript_path.as_ref() {
                     if tp.exists() {
-                        let enq = precompact_enqueue_transcript_chunks(
+                        let enq = enqueue_transcript_chunks_since_last_event(
                             tp,
                             &events_path,
                             &project_hash,
                             &backend,
                             last_event_ts.as_deref(),
+                            "PreCompactChunk",
                         )
                         .unwrap_or(0);
                         if enq > 0 && std::env::var("TJ_DISABLE_CLASSIFY_SPAWN").is_err() {
@@ -1637,6 +1638,66 @@ fn main() -> Result<()> {
                 return Ok(());
             }
 
+            // Stop: Claude Code is about to end the session. Same
+            // catch-up logic as PreCompact (read transcript tail,
+            // enqueue chunks newer than the active task's last
+            // event timestamp), but no boundary marker — a session
+            // end isn't a reasoning boundary, the task is just
+            // pausing. The v0.7.0-era Stop hook fired with hardcoded
+            // text="Session ended" which carried no signal and just
+            // littered the pending queue with noise; v0.9.3 replaces
+            // that with a real catch-up.
+            //
+            // Skip the catch-up when running through the mock test
+            // path (mock_event_type + mock_task_id) — those tests
+            // expect their explicit `--kind=Stop` invocation to fall
+            // through to the mock-classifier dispatch below, not be
+            // intercepted by the new transcript-tail logic.
+            let is_mock_stop = mock_event_type.is_some() && mock_task_id.is_some();
+            if !is_mock_stop && kind == "Stop" {
+                if !events_path.exists() {
+                    return Ok(());
+                }
+                let state_path =
+                    tj_core::paths::state_dir()?.join(format!("{project_hash}.sqlite"));
+                let conn = tj_core::db::open(&state_path)?;
+                tj_core::db::ingest_new_events(&conn, &events_path, &project_hash)?;
+                let recent = recent_task_contexts(&conn, 1)?;
+                let Some(tc) = recent.into_iter().next() else {
+                    return Ok(());
+                };
+
+                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 = enqueue_transcript_chunks_since_last_event(
+                            tp,
+                            &events_path,
+                            &project_hash,
+                            &backend,
+                            last_event_ts.as_deref(),
+                            "StopChunk",
+                        )
+                        .unwrap_or(0);
+                        if enq > 0 && std::env::var("TJ_DISABLE_CLASSIFY_SPAWN").is_err() {
+                            let _ = spawn_classify_worker(&backend);
+                        }
+                    }
+                }
+                return Ok(());
+            }
+
             // Drain any pending entries first (Task 10 fills the real-classifier branch).
             drain_pending(
                 &events_path,
@@ -2814,16 +2875,27 @@ 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 catch-up: parse the JSONL session log and enqueue user
+/// + assistant text entries newer than `last_event_ts` as pending v2
+/// chunks. The classify-worker picks them up afterwards. Returns the
+/// number of chunks queued. Errors are absorbed — best-effort, never
+/// fatal. Used by both PreCompact (before compaction) and Stop (end
+/// of session) hooks to recover events the synchronous PostToolUse
+/// hook didn't see — internal classifier `claude -p` calls, MCP
+/// responses with thinking-only assistant turns, or the final
+/// assistant message before a session ends.
+///
+/// `assistant_chunk_kind` tags assistant-side entries so the source
+/// hook is visible in the pending queue (e.g. "PreCompactChunk"
+/// vs "StopChunk"). User entries always tag as "UserPromptSubmit"
+/// to trigger `process_pending_entry`'s auto-open behavior.
+fn enqueue_transcript_chunks_since_last_event(
     transcript_path: &std::path::Path,
     events_path: &std::path::Path,
     project_hash: &str,
     backend: &str,
     last_event_ts: Option<&str>,
+    assistant_chunk_kind: &str,
 ) -> anyhow::Result<usize> {
     use tj_core::session::parser::{
         extract_assistant_texts, extract_user_text, parse_session, SessionEntry,
@@ -2844,7 +2916,7 @@ fn precompact_enqueue_transcript_chunks(
                 if texts.is_empty() {
                     continue;
                 }
-                (a.timestamp.clone(), texts.join("\n"), "PreCompactChunk")
+                (a.timestamp.clone(), texts.join("\n"), assistant_chunk_kind)
             }
             _ => continue,
         };

crates/tj-cli/src/main.rs

@@ -2557,6 +2557,123 @@ fn precompact_skips_transcript_entries_older_than_last_event() {
     );
 }
 
+#[test]
+fn stop_ingests_transcript_tail_into_pending_v2() {
+    // v0.9.3: Stop hook does transcript catch-up (like PreCompact)
+    // instead of injecting hardcoded "Session ended" noise.
+    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", "End-of-session catch-up"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
+    .to_string();
+
+    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":"the refund flow needs idempotency keys per payment provider"}}"#;
+    let line_assistant = r#"{"type":"assistant","uuid":"a1","timestamp":"2099-01-01T00:00:05.000Z","sessionId":"s1","message":{"content":[{"type":"text","text":"Confirmed: dlocal returns 200 OK for duplicate calls when idempotency-key header is set."}]}}"#;
+    std::fs::write(&transcript, format!("{line_user}\n{line_assistant}\n")).unwrap();
+
+    let stdin_payload = serde_json::json!({
+        "hook_event_name": "Stop",
+        "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", "hybrid"])
+        .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 Stop catch-up")
+        .filter_map(|e| e.ok())
+        .collect();
+    assert_eq!(
+        queued.len(),
+        2,
+        "expected 2 pending v2 chunks (user + assistant), got {}",
+        queued.len()
+    );
+
+    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("idempotency keys per payment provider") {
+            saw_user = true;
+            assert_eq!(v["kind"], "UserPromptSubmit");
+        }
+        if text.contains("dlocal returns 200 OK") {
+            saw_assistant = true;
+            // Distinct kind from PreCompactChunk — lets ops grep which hook queued it.
+            assert_eq!(v["kind"], "StopChunk");
+        }
+    }
+    assert!(
+        saw_user && saw_assistant,
+        "missing one of the chunks: user={saw_user} assistant={saw_assistant}"
+    );
+}
+
+#[test]
+fn stop_without_transcript_path_is_silent_noop() {
+    // Belt-and-braces: when CC's Stop payload omits transcript_path
+    // (or hook is invoked manually with no stdin), we must not crash
+    // and must not litter pending/ with placeholder entries — the
+    // pre-v0.9.3 "Session ended" text noise we deliberately removed.
+    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", "noop check"])
+        .assert()
+        .success();
+
+    let stdin_payload = serde_json::json!({"hook_event_name": "Stop"}).to_string();
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .current_dir(&workdir)
+        .args(["ingest-hook", "--backend", "hybrid"])
+        .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,
+        "Stop without transcript_path must NOT queue any pending entry"
+    );
+}
+
 #[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.9.2", path = "../tj-core" }
+tj-core = { package = "task-journal-core", version = "0.9.3", 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.9.2",
+  "version": "0.9.3",
   "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

@@ -24,10 +24,11 @@
     ],
     "Stop": [
       {
+        "matcher": "",
         "hooks": [
           {
             "type": "command",
-            "command": "task-journal ingest-hook --kind=Stop --text=\"Session ended\" 2>/dev/null || true"
+            "command": "task-journal ingest-hook 2>/dev/null || true"
           }
         ]
       }

plugin/hooks/hooks.json

@@ -1,6 +1,6 @@
 {
   "name": "task-journal",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Append-only journal of AI-coding task reasoning chains. Captures 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",