fix(hook): read Claude Code payload from stdin (v0.2.8)

Critical: prior versions interpolated $CLAUDE_HOOK_NAME and
$CLAUDE_HOOK_TEXT in the install-hooks command — Claude Code never
sets those env vars. Production hooks always called the classifier
with empty text, every event piled up in pending/, and the journal
never recorded anything beyond what manual `task-journal event`
produced.

Fix:
- IngestHook.kind / .text become Option<String>. When omitted, the
  command reads stdin as JSON (the actual hook payload) and projects
  it to a (kind, text) pair: UserPromptSubmit -> prompt; PreToolUse /
  PostToolUse -> "{tool_name}: {tool_input}[ -> {tool_response}]";
  Stop / SessionStart -> empty.
- install-hooks now writes `task-journal ingest-hook --backend=cli ||
  true` — no env-var interpolation. The `|| true` safety net stays.
- Empty stdin returns ("Stop", "") instead of erroring, so dry-run
  invocations and missing pipes don't crash.

3 new integration tests cover UserPromptSubmit prompt extraction,
PostToolUse tool_name+input+response synthesis, and the install-
hooks command no longer containing the bogus env vars. CLI overrides
(--kind / --text) still work for the legacy unit/integration tests.

Closes claude-memory-rsw.

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

Author: Shahinyanm

.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Task Journal — append-only reasoning chain memory for AI-coding tasks",
-    "version": "0.2.7"
+    "version": "0.2.8"
   },
   "plugins": [
     {
       "name": "task-journal",
       "source": "./plugin",
       "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.",
-      "version": "0.2.7",
+      "version": "0.2.8",
       "author": {
         "name": "Digital-Threads"
       },

CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.8] - 2026-05-07
+
+Critical fix: hooks now actually carry content end-to-end. Without
+this release, every captured event reached the classifier with empty
+text, queued in `pending/`, and never got classified.
+
+### Fixed
+- `ingest-hook` now reads the Claude Code hook payload as JSON from
+  stdin (the documented wiring) instead of relying on `$CLAUDE_HOOK_NAME`
+  / `$CLAUDE_HOOK_TEXT` env vars that Claude Code never set. Per
+  hook kind:
+  - `UserPromptSubmit` → `prompt`
+  - `PreToolUse` / `PostToolUse` → synthesized from `tool_name`,
+    `tool_input`, and (when present) `tool_response`
+  - `Stop` / `SessionStart` → empty (SessionStart already short-
+    circuits to its resume-pack path).
+  `--kind` / `--text` remain accepted as CLI overrides for tests and
+  ad-hoc use; they take precedence when both are passed.
+- `install-hooks` now writes `task-journal ingest-hook --backend=cli
+  || true` — the bogus env-var interpolation is gone. Closes
+  claude-memory-rsw.
+
 ## [0.2.7] - 2026-05-07
 
 ### Fixed

Cargo.lock

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

crates/tj-cli/Cargo.toml

@@ -725,13 +725,20 @@ enum Commands {
         force: bool,
     },
     /// Hook entry point: ingest a chat chunk through the classifier.
+    ///
+    /// When `--kind` and `--text` are both omitted, reads the Claude Code
+    /// hook payload as JSON from stdin (the actual production wiring).
+    /// `--kind` / `--text` remain for tests and ad-hoc use.
     IngestHook {
         /// Hook kind: UserPromptSubmit | PostToolUse | Stop | SessionStart.
+        /// If omitted, derived from stdin JSON (`hook_event_name`).
         #[arg(long)]
-        kind: String,
-        /// The chat chunk text.
+        kind: Option<String>,
+        /// The chat chunk text. If omitted, derived from stdin JSON
+        /// (`prompt` for UserPromptSubmit, synthesized from
+        /// tool_name+input+response for PostToolUse, etc.).
         #[arg(long)]
-        text: String,
+        text: Option<String>,
         /// Classifier backend: "cli" uses `claude -p` (free with your Pro/Max
         /// subscription) or "api" uses Anthropic API (requires `ANTHROPIC_API_KEY`).
         /// Default: cli.
@@ -1046,7 +1053,12 @@ fn main() -> Result<()> {
                 // and replay on next ingest.
                 // Default to subscription-based classifier (`claude -p`).
                 // Power users with API key can run install-hooks --backend=api below.
-                let cmd = "task-journal ingest-hook --kind=$CLAUDE_HOOK_NAME --text=\"$CLAUDE_HOOK_TEXT\" --backend=cli || true";
+                // Claude Code pipes the hook payload as JSON on stdin; the
+                // `--kind` / `--text` flags from earlier templates pointed
+                // at env vars Claude Code never sets and therefore always
+                // fed the classifier empty text. Stdin-only is the correct
+                // wiring (see claude-memory-rsw).
+                let cmd = "task-journal ingest-hook --backend=cli || true";
                 let entries = serde_json::json!({
                     "UserPromptSubmit": [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
                     "PostToolUse":     [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
@@ -1174,6 +1186,17 @@ fn main() -> Result<()> {
             mock_task_id,
             mock_confidence,
         } => {
+            // Resolve (kind, text) source: explicit args win; otherwise
+            // read the Claude Code hook payload from stdin. The earlier
+            // settings.json template interpolated `$CLAUDE_HOOK_NAME` /
+            // `$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),
+                _ => parse_hook_stdin()?,
+            };
+
             let cwd = std::env::current_dir()?;
             let project_hash = tj_core::project_hash::from_path(&cwd)?;
             let events_path = tj_core::paths::events_dir()?.join(format!("{project_hash}.jsonl"));
@@ -1811,6 +1834,70 @@ fn drain_pending(
     Ok(())
 }
 
+/// Read a Claude Code hook payload from stdin and project it down to
+/// the (kind, text) pair the rest of `ingest-hook` operates on.
+///
+/// Claude Code passes hook input as a JSON object on stdin. The fields
+/// we care about (per the public hooks spec):
+///
+/// - common: `hook_event_name`
+/// - UserPromptSubmit: `prompt`
+/// - PreToolUse / PostToolUse: `tool_name`, `tool_input`, `tool_response`
+/// - Stop / SessionStart: nothing extra worth ingesting (SessionStart
+///   takes a separate fast path further up)
+///
+/// If stdin is empty (someone runs the command interactively without
+/// 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)> {
+    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()));
+    }
+    let v: serde_json::Value =
+        serde_json::from_str(buf).with_context(|| format!("parse hook payload JSON: {buf}"))?;
+
+    let kind = v
+        .get("hook_event_name")
+        .and_then(|s| s.as_str())
+        .unwrap_or("Stop")
+        .to_string();
+
+    let text = match kind.as_str() {
+        "UserPromptSubmit" => v
+            .get("prompt")
+            .and_then(|s| s.as_str())
+            .unwrap_or("")
+            .to_string(),
+        "PreToolUse" | "PostToolUse" => {
+            let tool = v
+                .get("tool_name")
+                .and_then(|s| s.as_str())
+                .unwrap_or("tool");
+            let input = v
+                .get("tool_input")
+                .map(|x| x.to_string())
+                .unwrap_or_default();
+            let response = v
+                .get("tool_response")
+                .map(|x| x.to_string())
+                .unwrap_or_default();
+            if response.is_empty() {
+                format!("{tool}: {input}")
+            } else {
+                format!("{tool}: {input} → {response}")
+            }
+        }
+        _ => String::new(),
+    };
+
+    Ok((kind, text))
+}
+
 fn parse_event_type(s: &str) -> anyhow::Result<tj_core::event::EventType> {
     use tj_core::event::EventType::*;
     Ok(match s {

crates/tj-cli/src/main.rs

@@ -1236,6 +1236,141 @@ fn ingest_hook_session_start_with_no_open_tasks_emits_no_context() {
     );
 }
 
+#[test]
+fn ingest_hook_reads_user_prompt_submit_payload_from_stdin() {
+    // Real Claude Code passes hook input as JSON over stdin, NOT via env
+    // vars. Without this, every captured event has empty text and the
+    // classifier rejects it. Regression for claude-memory-rsw.
+    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", "Stdin host"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
+    .to_string();
+
+    let payload = serde_json::json!({
+        "hook_event_name": "UserPromptSubmit",
+        "session_id": "s-1",
+        "transcript_path": "/tmp/x",
+        "cwd": "/tmp",
+        "prompt": "We adopted Rust for the journal."
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args([
+            "ingest-hook",
+            "--backend",
+            "cli",
+            "--mock-event-type",
+            "decision",
+            "--mock-task-id",
+            &task_id,
+            "--mock-confidence",
+            "0.95",
+        ])
+        .write_stdin(payload)
+        .assert()
+        .success();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["pack", &task_id, "--mode", "full"])
+        .assert()
+        .success()
+        .stdout(contains("We adopted Rust for the journal"));
+}
+
+#[test]
+fn ingest_hook_reads_post_tool_use_payload_from_stdin() {
+    // PostToolUse payloads have no `prompt` field — content lives in
+    // `tool_name` / `tool_input` / `tool_response`. The stdin parser must
+    // synthesize text from those.
+    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", "Tool host"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
+    .to_string();
+
+    let payload = serde_json::json!({
+        "hook_event_name": "PostToolUse",
+        "session_id": "s-2",
+        "transcript_path": "/tmp/x",
+        "cwd": "/tmp",
+        "tool_name": "Bash",
+        "tool_input": { "command": "cargo test" },
+        "tool_response": { "output": "all 222 tests pass" }
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args([
+            "ingest-hook",
+            "--backend",
+            "cli",
+            "--mock-event-type",
+            "evidence",
+            "--mock-task-id",
+            &task_id,
+            "--mock-confidence",
+            "0.9",
+        ])
+        .write_stdin(payload)
+        .assert()
+        .success();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["pack", &task_id, "--mode", "full"])
+        .assert()
+        .success()
+        .stdout(contains("Bash").and(contains("cargo test")));
+}
+
+#[test]
+fn install_hooks_writes_command_without_bogus_env_var_interpolation() {
+    // The old install-hooks emitted $CLAUDE_HOOK_NAME / $CLAUDE_HOOK_TEXT,
+    // neither of which Claude Code actually populates. The current command
+    // must rely on stdin instead.
+    let dir = assert_fs::TempDir::new().unwrap();
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("HOME", dir.path())
+        .args(["install-hooks", "--scope", "user"])
+        .assert()
+        .success();
+    let s = std::fs::read_to_string(dir.path().join(".claude/settings.json")).unwrap();
+    assert!(
+        !s.contains("$CLAUDE_HOOK_NAME") && !s.contains("$CLAUDE_HOOK_TEXT"),
+        "install-hooks must not interpolate non-existent env vars: {s}"
+    );
+}
+
 #[test]
 fn ingest_hook_with_mock_writes_classified_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.2.7", path = "../tj-core" }
+tj-core = { package = "task-journal-core", version = "0.2.8", 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.2.7",
+  "version": "0.2.8",
   "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

@@ -1,6 +1,6 @@
 {
   "name": "task-journal",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "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",