feat(hook): SessionStart auto-injects resume-pack of open tasks

Without this, the journal could record reasoning chains but couldn't
*surface* them — every new Claude Code session started cold and the
user had to remember to call task_pack manually. That defeats the
auto-memory promise of the project.

Behavior:
- `task-journal ingest-hook --kind=SessionStart` now short-circuits
  before the classifier path. It opens the project SQLite, ingests
  any new JSONL events, queries up to 3 most-recently-active OPEN
  tasks, renders each in compact mode via tj_core::pack::assemble,
  and writes a JSON envelope to stdout:
    {
      "hookSpecificOutput": {
        "hookEventName": "SessionStart",
        "additionalContext": "<concatenated packs>"
      }
    }
  Claude Code reads that envelope and folds additionalContext into
  the system prompt.
- No events file → empty stdout (no ghost SQLite files for projects
  that never used the journal).
- No open tasks → empty stdout (don't pollute system prompt).
- `install-hooks` now wires SessionStart alongside UserPromptSubmit /
  PostToolUse / Stop, so the auto-injection is on by default.

Two new tests cover the happy path (envelope shape + content) and
the no-tasks silent path. install-hooks test asserts SessionStart is
present in the generated settings.json.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Shahinyanm

crates/tj-cli/src/main.rs

@@ -999,6 +999,11 @@ fn main() -> Result<()> {
                     "UserPromptSubmit": [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
                     "PostToolUse":     [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
                     "Stop":            [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
+                    // SessionStart drives the auto resume-pack injection:
+                    // ingest-hook short-circuits on this kind, queries open
+                    // tasks for the current project, and emits the
+                    // additionalContext envelope Claude Code expects.
+                    "SessionStart":    [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
                 });
                 hooks_obj.insert("hooks".into(), entries);
 
@@ -1104,6 +1109,47 @@ fn main() -> Result<()> {
             let events_path = tj_core::paths::events_dir()?.join(format!("{project_hash}.jsonl"));
             std::fs::create_dir_all(events_path.parent().unwrap())?;
 
+            // SessionStart: emit a JSON envelope with compact resume-packs of
+            // open tasks so Claude Code injects them into its system context
+            // automatically. This is the load-bearing UX for "the journal
+            // remembers" — without it, users would have to call task_pack
+            // manually each session. Empty stdout when no open tasks → no
+            // injection, keeps system prompt clean for fresh projects.
+            if kind == "SessionStart" {
+                // Skip early on a clean machine: nothing to surface, and we
+                // don't want SessionStart to spawn empty SQLite files in
+                // every project Claude Code is opened in.
+                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, 3)?;
+                if recent.is_empty() {
+                    return Ok(());
+                }
+                let mut bundle = String::new();
+                for tc in &recent {
+                    let pack = tj_core::pack::assemble(
+                        &conn,
+                        &tc.task_id,
+                        tj_core::pack::PackMode::Compact,
+                    )?;
+                    bundle.push_str(&pack.text);
+                    bundle.push_str("\n\n");
+                }
+                let envelope = serde_json::json!({
+                    "hookSpecificOutput": {
+                        "hookEventName": "SessionStart",
+                        "additionalContext": bundle.trim_end(),
+                    }
+                });
+                println!("{}", serde_json::to_string(&envelope)?);
+                return Ok(());
+            }
+
             // Drain any pending entries first (Task 10 fills the real-classifier branch).
             drain_pending(
                 &events_path,

crates/tj-cli/tests/cli.rs

@@ -800,6 +800,10 @@ fn install_hooks_writes_to_settings_json() {
     assert!(content.contains("UserPromptSubmit"));
     assert!(content.contains("PostToolUse"));
     assert!(content.contains("task-journal ingest-hook"));
+    assert!(
+        content.contains("SessionStart"),
+        "install-hooks must wire SessionStart so resume-pack injection works"
+    );
 }
 
 #[test]
@@ -1078,6 +1082,96 @@ fn ingest_hook_writes_telemetry_record() {
     );
 }
 
+#[test]
+fn ingest_hook_session_start_emits_resume_pack_json() {
+    let dir = assert_fs::TempDir::new().unwrap();
+    let task_id = String::from_utf8(
+        Command::cargo_bin("task-journal")
+            .unwrap()
+            .env("XDG_DATA_HOME", dir.path())
+            .args(["create", "Wire SessionStart pack"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args([
+            "event",
+            &task_id,
+            "--type",
+            "decision",
+            "--text",
+            "Adopt Rust for the journal.",
+        ])
+        .assert()
+        .success();
+
+    let out = Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["ingest-hook", "--kind", "SessionStart", "--text", ""])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let body = String::from_utf8(out).unwrap();
+
+    let v: serde_json::Value = serde_json::from_str(body.trim()).unwrap_or_else(|e| {
+        panic!("SessionStart hook stdout must be JSON; got: {body:?}; err: {e}")
+    });
+    let hso = v
+        .get("hookSpecificOutput")
+        .expect("hookSpecificOutput key missing");
+    assert_eq!(
+        hso.get("hookEventName").and_then(|s| s.as_str()),
+        Some("SessionStart"),
+        "wrong hookEventName: {body}"
+    );
+    let ctx = hso
+        .get("additionalContext")
+        .and_then(|s| s.as_str())
+        .expect("additionalContext key missing");
+    assert!(
+        ctx.contains("Wire SessionStart pack"),
+        "additionalContext must include task title: {ctx}"
+    );
+    assert!(
+        ctx.contains("Adopt Rust"),
+        "additionalContext must include event text: {ctx}"
+    );
+}
+
+#[test]
+fn ingest_hook_session_start_with_no_open_tasks_emits_no_context() {
+    let dir = assert_fs::TempDir::new().unwrap();
+    let out = Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["ingest-hook", "--kind", "SessionStart", "--text", ""])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let body = String::from_utf8(out).unwrap();
+    // Empty stdout is the documented signal to Claude Code that no
+    // additionalContext should be injected — we don't want to pollute
+    // the system prompt with an empty pack on fresh projects.
+    assert!(
+        body.trim().is_empty(),
+        "SessionStart with no open tasks must emit nothing, got: {body:?}"
+    );
+}
+
 #[test]
 fn ingest_hook_with_mock_writes_classified_event() {
     let dir = assert_fs::TempDir::new().unwrap();