From 79ae28248cc45ff5254f49974d65eb5ad6f0476b Mon Sep 17 00:00:00 2001
From: Mher Shahinyan <shahinyanm@gmail.com>
Date: Fri, 6 Nov 2026 10:07:11 +0400
Subject: [PATCH 1/5] fix: quiet task-journal: strict recall, one-line session
 start, hooks in the plugin, cleanup-noise

---
 CHANGELOG.md                               |   45 +
 INSTALL.md                                 |   44 +-
 README.md                                  |   18 +-
 crates/tj-cli/src/main.rs                  | 1030 +++++++++++-------
 crates/tj-cli/tests/cli.rs                 | 1114 ++++++++++----------
 crates/tj-core/src/classifier/heuristic.rs |   63 +-
 crates/tj-core/src/classifier/mod.rs       |   61 ++
 crates/tj-core/src/classifier/prompt.rs    |    2 +-
 crates/tj-core/src/db.rs                   |   14 +-
 crates/tj-core/src/lib.rs                  |    1 +
 crates/tj-core/src/noise.rs                |  102 ++
 crates/tj-core/src/pack.rs                 |   14 +-
 crates/tj-core/src/recall.rs               |  446 ++++----
 crates/tj-core/src/session/extractor.rs    |   41 +-
 crates/tj-mcp/src/main.rs                  |  110 +-
 plugin/hooks/hooks.json                    |   27 +-
 plugin/hooks/journal.test.ts               |   73 +-
 plugin/hooks/journal.ts                    |   55 +-
 plugin/hooks/register.test.ts              |   21 +-
 plugin/hooks/register.tsx                  |   41 +-
 plugin/skills/task-journal/SKILL.md        |    6 +-
 21 files changed, 1822 insertions(+), 1506 deletions(-)
 create mode 100644 crates/tj-core/src/noise.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0ade52..22a4d8a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+Less noise in the agent's context. Measured on 300 sessions: push-recall was
+added to tool results 13,696 times, almost never about the work at hand.
+
+### Changed
+- **Push-recall only on a strong match with the session's task.** A hit must be a
+  rejection or decision the agent or the user recorded (classifier output is not
+  trusted) on the session's active task or a task of the same module, sharing a
+  file, issue or commit with the tool call, or at least three meaningful words —
+  one shared word used to be enough. Paths count as files, not words. No session
+  task, no recall. At most one hit, at most once per ten tool calls of a session
+  (`TJ_RECALL_EVERY`), never for the journal's own tools. It arrives as
+  `additionalContext` for every tool: the async hook's `updatedMCPToolOutput`
+  never reached the model and rewrote other servers' output.
+- **The session start is one line.** It names the open task the session most
+  likely continues — its own after a resume or compaction, else the one the git
+  branch names (the branch, or an issue key in it), else the folder's latest — and
+  how to resume it. Resume packs, honesty scores and chronicle gaps are on request
+  (`task_pack`, `task-journal check`, `module_list`).
+- **No chronicle line in replies or prompts.** `task_create` no longer carries a
+  `chronicle` field, and the mod no longer adds a chronicle reminder to prompts.
+- **Short MCP instructions.** Seven plain lines on what to record and why, without
+  capitals or "NON-NEGOTIABLE".
+- **Hooks ship with the plugin.** `plugin/hooks/hooks.json` wires the session start,
+  push-recall and model switches (`ingest-hook --from-plugin`, never the classifier
+  queue). `install-hooks` for Claude Code now only takes the hooks earlier versions
+  wrote out of `settings.json`, after copying it to
+  `settings.json.task-journal-backup-<time>`; Codex is unchanged. While the mod runs,
+  a hook still left in `settings.json` stands down, so no event is handled twice.
+  `--auto-capture` and `--proactive-recall` no longer apply to Claude Code.
+- **The classic nudge runs on a session's first prompt and then every sixth**
+  (`TJ_NUDGE_EVERY`), not on every prompt, and no longer shouts.
+- **A rejection is an approach ruled out in so many words** ("decided against",
+  "ruled out", "отказались от", "tried X … didn't work"), at most 600 characters.
+  The classifier and `backfill` no longer file bug reports, log lines or whole
+  answers as rejections, and the classifier drops raw tool calls, compaction
+  summaries and notifications instead of recording them.
+
+### Added
+- `task-journal cleanup-noise [--dry-run] [--all]` retires what the classifier once
+  filed as reasoning but is not: raw tool calls, compaction summaries, harness
+  notifications, and rejections that rule no approach out. Each gets a correction
+  (the journal stays append-only), which keeps it out of packs, recall and exports
+  without moving its task up the "newest first" lists. Only classifier entries are
+  touched.
+
 ## [0.31.2] - 2026-10-05
 
 ### Changed
diff --git a/INSTALL.md b/INSTALL.md
index 3446875..42d6187 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -6,8 +6,8 @@ server) plus thin integrations for each agent:
 | Client | What you install | What it gets |
 |--------|------------------|--------------|
 | Claude Code 2.1.287+ | the plugin (MCP server + skill + mod) | journal tools, the session's task kept in the system prompt, catch-up before compaction, the task above the prompt |
-| Claude Code, older | the plugin, optionally `install-hooks` | journal tools, resume packs on session start |
-| Codex | `codex mcp add` + `install-hooks --client codex` | journal tools, resume packs, optional auto-capture |
+| Claude Code, older | the plugin | journal tools, the open task named at session start, push-recall |
+| Codex | `codex mcp add` + `install-hooks --client codex` | journal tools, the open task named at session start, optional auto-capture |
 | Any other MCP client | the MCP server | the seven journal tools |
 
 ## Prerequisites
@@ -70,14 +70,18 @@ current (0.30+). If they aren't, it says so once and stays off. On Claude Code
 older than 2.1.287 the mod doesn't load; the MCP tools and the skill work as
 before.
 
-**Classic hooks next to the mod.** If you ran `task-journal install-hooks`
-before, you can keep it. The mod tells those hooks it is active
-(`TJ_MOD_ACTIVE=1`), and they skip what the mod replaces — the reminder,
-per-message classification (`--auto-capture`) and the transcript catch-ups at
-stop, compaction and `/clear` (the mod catches up once, right before each
-compaction). The rest keeps running: the session-start resume
-pack, the model-switch record, push-recall and `/rewind` corrections. To remove
-them anyway: `task-journal install-hooks --scope user --uninstall`.
+**Hooks.** The plugin ships its own: at session start, one line naming the
+open task the session most likely continues (its own after a resume or a
+compaction, else the one the git branch names, else the folder's latest);
+after a tool call, push-recall — at most one prior rejection or decision of the
+session's task that the call clearly touches, at most once every ten calls; and
+the model-switch record. Full packs, honesty scores and chronicle gaps are on
+request (`task_pack`, `task-journal check`, `module_list`).
+
+If an earlier version's `task-journal install-hooks` wrote hooks into
+`settings.json`, run it once more: for Claude Code it now only takes them out,
+after copying the file to `settings.json.task-journal-backup-<time>`. Until
+then they stand down while the mod runs, so no event is handled twice.
 
 ### Older Claude Code, or without the plugin
 
@@ -91,23 +95,9 @@ Wire the MCP server yourself in `~/.claude/settings.json`:
 }
 ```
 
-and, for resume packs at session start, install the hooks:
-
-```bash
-task-journal install-hooks --scope user             # → ~/.claude/settings.json
-task-journal install-hooks --scope project          # → .claude/settings.json
-task-journal install-hooks --scope user --auto-capture   # also classify prompts and tool calls in the background
-```
-
-The default install adds only a read-only `SessionStart` hook (resume packs) and
-a `UserPromptSubmit` reminder. `--auto-capture` adds background classification
-of prompts, tool calls and session ends; it is a safety net under self-tagging,
-not a replacement, and with `--backend hybrid` (the default) it may spawn
-`claude -p` for chunks the local heuristic can't classify.
-
-The installer keeps every unrelated key in the settings file, wraps each hook in
-`|| true` so a failure never breaks the session, runs the capture hooks `async`
-so the chat never waits, and gives `SessionEnd` an explicit timeout.
+The hooks come with the plugin, so on older Claude Code install the plugin
+too: its hooks run there, only the mod doesn't load. Without the plugin the MCP
+tools work on their own.
 
 > The hook payload arrives as JSON on stdin. There are no `$CLAUDE_HOOK_*`
 > environment variables.
diff --git a/README.md b/README.md
index cc3c521..429fc76 100644
--- a/README.md
+++ b/README.md
@@ -101,10 +101,10 @@ that tie it back to the code.
 
 ## How it works
 
-- **The mod (Claude Code 2.1.287+).** A plugin of function hooks that runs inside Claude Code and calls the `task-journal` CLI. It keeps the session's active task in the system prompt (a compaction can't drop it), gives each session its own active task, shows the session's task in a band above the prompt (nothing while it has none), reminds the agent to log only after several prompts without an entry, and — right before a compaction — asks the model what was never logged and records it as `suggested` events. It needs no setup. When it runs, the classic hooks skip what it replaces (the reminder, per-message classification and the transcript catch-ups) and keep the rest (resume packs, push-recall, `/rewind`). Codex and Claude Code older than 2.1.287 keep using the hooks below; there the mod simply doesn't load.
+- **The mod (Claude Code 2.1.287+).** A plugin of function hooks that runs inside Claude Code and calls the `task-journal` CLI. It keeps the session's active task in the system prompt (a compaction can't drop it), gives each session its own active task, shows the session's task in a band above the prompt (nothing while it has none), reminds the agent to log only after several prompts without an entry, and — right before a compaction — asks the model what was never logged and records it as `suggested` events. It needs no setup. The plugin also ships three hooks of its own: a one-line note at session start naming the open task the session most likely continues, push-recall after tool calls, and the model-switch record. Codex keeps using `install-hooks --client codex`; on Claude Code older than 2.1.287 the mod doesn't load and the plugin's hooks still run.
 - **Self-tagging is the primary path (recommended).** You — the agent in the live session — record reasoning directly via the five MCP tools: open a task with a `goal`, append a typed `decision` / `finding` / `rejection` / `evidence` event at the moment of commitment, and `task_close` with a written `outcome`. This is free (it rides the interactive session), language-agnostic, and higher-fidelity than any after-the-fact classifier. The bundled `task-journal` skill drives this automatically. See [MCP tools](#mcp-tools).
-- **Auto-capture is an opt-in backstop — OFF by default (v0.14.0).** A fresh `install-hooks` wires only a cheap, read-only SessionStart resume hook: no per-message classifier runs, no `claude -p` is ever spawned, nothing is charged. Self-tagging is the capture mechanism. Opt in with `install-hooks --auto-capture` and Claude Code hooks also run every prompt, tool call, and reply through a two-stage classifier that lands typed events on its own: Stage 1 is a fast in-process heuristic (obvious EN+RU phrasing, zero cost); Stage 2 falls back to an LLM only when the heuristic is uncertain (and only if you pick `--backend agent-sdk` / `api`). Even opted in it is a safety net under your explicit self-tagging, not the main mechanism, and it misses real reasoning — especially non-English prose.
-- **Project chronicle (0.31).** The journal is also a map of the system: the project splits into **modules** — parts of the system by meaning, not folders or tickets — and every task belongs to one or more. Each module has a page: how it works now, the decisions, rejections and constraints of all its tasks, and its history, one line per task. A new task can start from that page; closing it adds its line. The journal suggests a module for a new task (from its words and files, no model call) and names what the chronicle is missing — no map yet, tasks without a module, a module whose state lags behind its tasks — at session start and in tool replies, so the agent keeps it up by itself. `/task-journal:map` (or the skill's steps in any client) maps a project and sorts its past tasks, with the user confirming both. A repository has one map: git worktrees share their main checkout's, and a module's history gathers tasks from every worktree, while each task stays in its own worktree's journal.
+- **Auto-capture is an opt-in backstop — OFF by default (v0.14.0).** A fresh `install-hooks --client codex` wires only a cheap, read-only SessionStart hook: no per-message classifier runs, no `claude -p` is ever spawned, nothing is charged. Self-tagging is the capture mechanism; on Claude Code the mod adds its catch-up before compaction. Opt in with `install-hooks --client codex --auto-capture` and Codex hooks also run every prompt, tool call, and reply through a two-stage classifier that lands typed events on its own: Stage 1 is a fast in-process heuristic (obvious EN+RU phrasing, zero cost); Stage 2 falls back to an LLM only when the heuristic is uncertain (and only if you pick `--backend agent-sdk` / `api`). Even opted in it is a safety net under your explicit self-tagging, not the main mechanism, and it misses real reasoning — especially non-English prose.
+- **Project chronicle (0.31).** The journal is also a map of the system: the project splits into **modules** — parts of the system by meaning, not folders or tickets — and every task belongs to one or more. Each module has a page: how it works now, the decisions, rejections and constraints of all its tasks, and its history, one line per task. A new task can start from that page; closing it adds its line. The journal suggests a module for a new task (from its words and files, no model call) and names what the chronicle is missing — no map yet, tasks without a module, a module whose state lags behind its tasks — when asked: `module_list` and `task-journal state`. `/task-journal:map` (or the skill's steps in any client) maps a project and sorts its past tasks, with the user confirming both. A repository has one map: git worktrees share their main checkout's, and a module's history gathers tasks from every worktree, while each task stays in its own worktree's journal.
 - **Artifact extraction.** Each event scans its text for commit hashes, PR URLs, file paths, issue IDs, and branch names. Aggregated artifacts are how Task Journal links related tasks: when you start a new task touching the same issue or file, the prior task is surfaced automatically.
 - **Resume packs.** `task_pack` (MCP tool or CLI) renders a task into a compact Markdown briefing — Goal, Outcome, decisions, rejections, evidence, artifacts — that fits in a fresh agent's context window without dumping the raw event log.
 - **Auto-capture boundaries.** Beyond per-event capture, two extra hooks mark *reasoning boundaries* automatically. On `PreCompact`, Task Journal reads the transcript JSONL tail (entries newer than the active task's last event) and enqueues anything the synchronous hooks missed before the compact — then drops a marker decision so the post-compact agent sees a clear cut. A `/rewind`-prefixed prompt appends a single correction event so pack readers see where the user rolled back. No mass-rejection of prior events — the boundary is a sentinel, not a rewrite.
@@ -196,7 +196,8 @@ task-journal pack tj-x9rz1f --mode full
 | `doctor` | Self-check the install |
 | `rebuild-state` | Rebuild SQLite from JSONL |
 | `migrate-project` | Re-key data when a project moves on disk |
-| `install-hooks [--scope user\|project] [--auto-capture] [--backend hybrid\|agent-sdk\|api\|heuristic]` | Wire Claude Code hooks. Default: only the read-only SessionStart resume hook. `--auto-capture` adds the per-message classifier (spawns `claude -p` unless `--backend heuristic`). |
+| `install-hooks [--client claude\|codex] [--scope user\|project] [--auto-capture] [--backend hybrid\|agent-sdk\|api\|heuristic]` | Codex: wire its hooks (default: the read-only SessionStart hook; `--auto-capture` adds the per-message classifier). Claude Code: its hooks come with the plugin, so this takes the ones earlier versions wrote out of `settings.json`, after a backup. |
+| `cleanup-noise [--dry-run] [--all]` | Retire what the classifier once filed as reasoning but is not — raw tool calls, compaction summaries, notifications, "rejections" that rule no approach out — with one correction each (the journal stays append-only). |
 
 ## MCP tools
 
@@ -309,15 +310,12 @@ Wire the MCP server into Claude Code (`~/.claude/settings.json`):
 }
 ```
 
-Wire hooks (one-shot). Default installs only the read-only SessionStart resume
-hook — no classifier, no `claude -p`:
+Claude Code's hooks come with the plugin. Without the plugin the MCP tools work
+on their own; there is no hook to wire. If an earlier version's `install-hooks`
+left hooks in `settings.json`, take them out (a backup is made first):
 
 ```bash
 task-journal install-hooks --scope user
-
-# Opt in to per-message auto-capture (spawns `claude -p` per uncertain chunk
-# unless you pin --backend heuristic):
-task-journal install-hooks --scope user --auto-capture --backend heuristic
 ```
 
 ### Updating
diff --git a/crates/tj-cli/src/main.rs b/crates/tj-cli/src/main.rs
index d92816a..92a5c1e 100644
--- a/crates/tj-cli/src/main.rs
+++ b/crates/tj-cli/src/main.rs
@@ -1237,6 +1237,19 @@ enum Commands {
         #[arg(long)]
         all: bool,
     },
+    /// Retire what the classifier once filed as reasoning but is not: raw
+    /// tool calls, compaction summaries, harness notifications, and
+    /// "rejections" that rule no approach out. The journal is append-only,
+    /// so each one gets a correction, which takes it out of packs, recall and
+    /// exports. Only classifier entries are touched, never the agent's or yours.
+    CleanupNoise {
+        /// Show what would be retired; write nothing.
+        #[arg(long)]
+        dry_run: bool,
+        /// Clean every project's journal, not just the current one.
+        #[arg(long)]
+        all: bool,
+    },
     /// Set or update the goal of an existing task.
     Goal {
         task_id: String,
@@ -1470,6 +1483,11 @@ enum Commands {
         ///   - "cli" — removed in v0.8.0; use "agent-sdk" (its resurrection).
         #[arg(long, default_value = "hybrid")]
         backend: String,
+        /// Set by the hooks the Claude Code plugin ships: session start,
+        /// push-recall and model switches only — never the classifier queue,
+        /// which the plugin's mod replaces.
+        #[arg(long)]
+        from_plugin: bool,
         /// Test/dev override: bypass classifier and force this event type. Hidden from --help.
         #[arg(long, hide = true)]
         mock_event_type: Option<String>,
@@ -2264,6 +2282,9 @@ fn real_main() -> Result<()> {
                 );
             }
         }
+        Commands::CleanupNoise { dry_run, all } => {
+            run_cleanup_noise(dry_run, all)?;
+        }
         Commands::PendingGc { days, all } => {
             let pending_dir = tj_core::paths::events_dir()?
                 .parent()
@@ -2486,67 +2507,21 @@ fn real_main() -> Result<()> {
                 serde_json::json!({})
             };
 
+            let before = serde_json::to_string_pretty(&current)?;
             let hooks_obj = current
                 .as_object_mut()
                 .ok_or_else(|| anyhow::anyhow!("settings is not a JSON object"))?;
-            if uninstall {
-                // Surgical removal: walk the `hooks` block, drop only
-                // entries whose command contains "task-journal ingest-hook"
-                // — leaves co-located third-party plugin hooks (token-pilot
-                // etc.) intact. Old behavior `remove("hooks")` nuked
-                // everyone's hooks; this is the bxl-bug fix.
-                if let Some(hooks_block) =
-                    hooks_obj.get_mut("hooks").and_then(|v| v.as_object_mut())
-                {
-                    let kinds: Vec<String> = hooks_block.keys().cloned().collect();
-                    for kind in kinds {
-                        let Some(arr) = hooks_block.get_mut(&kind).and_then(|v| v.as_array_mut())
-                        else {
-                            continue;
-                        };
-                        // Each entry is { matcher, hooks: [{type, command}, ...] }.
-                        // Filter the inner array; keep only non-task-journal commands.
-                        for entry in arr.iter_mut() {
-                            let Some(inner) = entry.get_mut("hooks").and_then(|v| v.as_array_mut())
-                            else {
-                                continue;
-                            };
-                            inner.retain(|h| {
-                                h.get("command")
-                                    .and_then(|c| c.as_str())
-                                    .map(|c| {
-                                        !(c.contains("task-journal ingest-hook")
-                                            || c.contains("task-journal nudge"))
-                                    })
-                                    .unwrap_or(true)
-                            });
-                        }
-                        // Drop matcher entries with empty inner arrays.
-                        arr.retain(|entry| {
-                            entry
-                                .get("hooks")
-                                .and_then(|v| v.as_array())
-                                .map(|a| !a.is_empty())
-                                .unwrap_or(true)
-                        });
-                        // If the whole kind is empty, remove it.
-                        if arr.is_empty() {
-                            hooks_block.remove(&kind);
-                        }
-                    }
-                    // Empty hooks block → remove entirely so settings.json
-                    // stays tidy when we were the only user.
-                    if hooks_block.is_empty() {
-                        hooks_obj.remove("hooks");
-                    }
-                }
-                // Remove our env key too — preserve other env entries.
-                if let Some(env) = hooks_obj.get_mut("env").and_then(|v| v.as_object_mut()) {
-                    env.remove("TJ_CLASSIFIER_CLI");
-                    // Drop empty env block to keep settings.json clean.
-                    if env.is_empty() {
-                        hooks_obj.remove("env");
-                    }
+            // Claude Code gets its hooks from the task-journal plugin. The
+            // settings.json entries earlier versions wrote ran next to them,
+            // so for Claude Code this only takes ours out again.
+            let is_claude = client == "claude";
+            if uninstall || is_claude {
+                remove_task_journal_hooks(hooks_obj);
+                if is_claude && !uninstall && (auto_capture || proactive_recall) {
+                    eprintln!(
+                        "--auto-capture / --proactive-recall do nothing for Claude Code: \
+                         the plugin's mod records the session."
+                    );
                 }
             } else {
                 // Wrap with `|| true` so a failed classifier (network down, rate limit,
@@ -2696,8 +2671,27 @@ fn real_main() -> Result<()> {
                     }
                 }
             }
-            std::fs::write(&settings_path, serde_json::to_string_pretty(&current)?)?;
+
+            let after = serde_json::to_string_pretty(&current)?;
+            if after != before {
+                // A copy first: the file holds every other tool's settings too.
+                if settings_path.exists() {
+                    let stamp = chrono::Utc::now().format("%Y%m%d%H%M%S");
+                    let backup = settings_path
+                        .with_file_name(format!("{config_file}.task-journal-backup-{stamp}"));
+                    std::fs::copy(&settings_path, &backup)
+                        .with_context(|| format!("back up {}", settings_path.display()))?;
+                    println!("backup: {}", backup.display());
+                }
+                std::fs::write(&settings_path, after)?;
+            }
             println!("{}", settings_path.display());
+            if is_claude && !uninstall {
+                println!(
+                    "Claude Code takes its task-journal hooks from the plugin \
+                     (/plugin install task-journal@task-journal); none are kept in this file."
+                );
+            }
 
             // Onboarding convenience: retro-import existing Claude Code history
             // so the journal isn't empty on day one. Always operates on the
@@ -2805,6 +2799,7 @@ fn real_main() -> Result<()> {
             kind,
             text,
             backend,
+            from_plugin,
             mock_event_type,
             mock_task_id,
             mock_confidence,
@@ -2833,14 +2828,12 @@ fn real_main() -> Result<()> {
                 _ => parse_hook_stdin()?,
             };
 
-            // The Claude Code mod captures in-process and marks the hooks it
-            // starts; the classic capture stands down where the mod does the
-            // same work: the Stop / PreCompact / SessionEnd transcript
-            // catch-up (and the compaction marker) here, per-message queueing
-            // and auto-open further down. Push-recall, the `/rewind`
-            // correction, resume packs and model switches stay ours.
+            // Where the plugin's own hooks run (its mod says so with
+            // TJ_PLUGIN_HOOKS), a hook still left in settings.json stands
+            // down: one event, one record. Next to an older plugin without
+            // hooks it keeps doing what that mod doesn't.
             let mod_on = mod_active();
-            if mod_on && matches!(kind.as_str(), "Stop" | "PreCompact" | "SessionEnd") {
+            if !from_plugin && env_flag("TJ_PLUGIN_HOOKS") {
                 return Ok(());
             }
 
@@ -2868,223 +2861,81 @@ fn real_main() -> Result<()> {
             // neither source is present (standalone behaviour unchanged).
             let live_session_id = tj_core::session_id::live_session_id(Some(&payload));
 
-            // Push-recall (claude-memory-60m). Best-effort, fail-open, read-only.
-            // After a (non-MCP) tool call, surface a relevant prior
-            // rejection/decision via an additionalContext envelope so the agent
-            // doesn't re-walk a ruled-out path. Gated by TJ_PUSH_RECALL=0.
-            //
-            // Dedup vs claude-memory-7km: skip MCP-tool turns — those are
-            // handled by 7km's updatedMCPToolOutput path, so emitting
-            // additionalContext here too would double-surface the same recall.
-            // The two paths are mutually exclusive by tool type (this =
-            // non-mcp tools; 7km = mcp__ tools). The block only adds a stdout
-            // envelope; it never touches the JSONL log or the pending flow
-            // below, and any error is swallowed so the hook can't break.
-            let tool_is_mcp = payload
-                .get("tool_name")
-                .and_then(|v| v.as_str())
-                .map(|n| n.starts_with("mcp__"))
-                .unwrap_or(false);
-            if kind == "PostToolUse"
-                && !tool_is_mcp
-                && std::env::var("TJ_PUSH_RECALL").as_deref() != Ok("0")
-                && events_path.exists()
-            {
-                let state_path =
-                    tj_core::paths::state_dir()?.join(format!("{project_hash}.sqlite"));
-                if let Ok(conn) = tj_core::db::open(&state_path) {
-                    let _ = tj_core::db::ingest_new_events(&conn, &events_path, &project_hash);
-                    if let Ok(hits) = tj_core::recall::relevant_recall(
-                        &conn,
-                        &text,
-                        tj_core::recall::DEFAULT_MAX_HITS,
-                    ) {
-                        let hits = fresh_recall_hits(
-                            hits,
-                            live_session_id.as_deref(),
-                            &events_path,
-                            &project_hash,
-                        );
-                        if !hits.is_empty() {
-                            let mut ctx = String::new();
-                            for h in &hits {
-                                let verb = match h.event_type {
-                                    tj_core::event::EventType::Rejection => "previously rejected",
-                                    _ => "previously decided",
-                                };
-                                ctx.push_str(&format!(
-                                    "⚠ recall: in task {} you {}: {}\n",
-                                    h.task_id, verb, h.text
-                                ));
-                            }
-                            let envelope = serde_json::json!({
-                                "hookSpecificOutput": {
-                                    "hookEventName": "PostToolUse",
-                                    "additionalContext": ctx.trim_end(),
-                                }
-                            });
-                            println!("{}", serde_json::to_string(&envelope)?);
-                        }
-                    }
-                }
-            }
-
-            // Push-recall via updatedMCPToolOutput (claude-memory-7km). For an
-            // MCP PostToolUse turn whose input echoes a prior rejection/decision,
-            // prepend a recall banner to what Claude sees of that tool's output.
-            // Best-effort, read-only: any miss or error emits nothing and the
-            // real output passes through unchanged. Complements 60m (which skips
-            // mcp__ tools) — gated MCP-only, falls through to the queue path so
-            // event capture is unaffected. Disabled by TJ_PUSH_RECALL=0.
+            // Push-recall (claude-memory-60m / 7km). Best-effort, fail-open,
+            // read-only: after a tool call, at most one prior rejection or
+            // decision of the session's own task that the call clearly
+            // touches (see `session_recall`), as additionalContext. Gated by
+            // TJ_PUSH_RECALL=0.
             if kind == "PostToolUse" && std::env::var("TJ_PUSH_RECALL").as_deref() != Ok("0") {
-                if let Some(envelope) = push_recall_envelope(
+                let hits = session_recall(
                     &payload,
                     &events_path,
                     &project_hash,
                     live_session_id.as_deref(),
-                ) {
+                );
+                if let Some(envelope) = recall_envelope(&hits) {
                     println!("{}", serde_json::to_string(&envelope)?);
                 }
             }
 
-            // 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.
+            // SessionStart: one line naming the task this session most likely
+            // continues, plus the user's standing preferences. Packs, honesty
+            // scores and chronicle gaps are on request (task_pack, task_check,
+            // module_list): three packs on every start cost thousands of
+            // tokens, mostly about other work. Only `additionalContext` goes
+            // out — never `sessionTitle` (it overrode Claude Code's own session
+            // name) nor `initialUserMessage` (auto-open captured it as a task
+            // title), see 0.14.3. Nothing to say → empty stdout.
             if kind == "SessionStart" {
-                // User preferences are global, so they surface even in a fresh
-                // project with no events of its own (Pillar C "remember me").
-                let prefs_block = session_preferences_block();
-                // 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. Preferences still go
-                // out if there are any.
-                if !events_path.exists() {
-                    if !prefs_block.is_empty() {
-                        emit_session_context(&prefs_block);
-                    }
-                    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)?;
-                // The chronicle's most important gap, for every client that
-                // reads this hook (Claude Code with or without the mod, Codex),
-                // also when no task is open. Advice only: it never fails the
-                // session start.
-                let chronicle_line = tj_core::chronicle::Chronicle::open(&cwd)
-                    .and_then(|chr| tj_core::archive::gaps(&chr, &conn, &project_hash, None))
-                    .ok()
-                    .and_then(|gaps| tj_core::archive::headline(&gaps));
-                let recent =
-                    recent_task_contexts(&conn, &project_hash, 3, live_session_id.as_deref())?;
-                if recent.is_empty() {
-                    let context = [Some(prefs_block.as_str()), chronicle_line.as_deref()]
-                        .into_iter()
-                        .flatten()
-                        .filter(|part| !part.is_empty())
-                        .collect::<Vec<_>>()
-                        .join("\n\n");
-                    if !context.is_empty() {
-                        emit_session_context(&context);
-                    }
-                    return Ok(());
-                }
-                // After a compaction (source=="compact"), re-inject the
-                // active task + its in-force constraints so the rebuilt
-                // context doesn't lose what it was doing. Best-effort:
-                // any error → no reminder, never abort SessionStart.
-                let source = payload.get("source").and_then(|v| v.as_str()).unwrap_or("");
-                let mut bundle = String::new();
-                // Preferences lead the bundle — they're the smallest, most
-                // durable signal about how the user wants to be worked with.
-                if !prefs_block.is_empty() {
-                    bundle.push_str(&prefs_block);
-                    bundle.push_str("\n\n");
-                }
-                // A resumed or forked session keeps its transcript, so the
-                // reminder would be noise — except when the conversation sat
-                // idle long enough that what it was doing is no longer fresh
-                // for the user either. Claude Code 2.1.251+ reports the gap in
-                // `seconds_since_last_response` on `resume` and `fork`.
-                let idle_secs = payload
-                    .get("seconds_since_last_response")
-                    .and_then(|v| v.as_u64());
-                let stale_resume = matches!(source, "resume" | "fork")
-                    && idle_secs.is_some_and(|s| s >= STALE_RESUME_SECS);
-                if source == "compact" || stale_resume {
-                    let label = if source == "compact" {
-                        "Active task after compaction".to_string()
-                    } else {
-                        format!(
-                            "Active task, idle for {}",
-                            human_gap(idle_secs.unwrap_or_default())
-                        )
-                    };
-                    if let Ok(Some(reminder)) =
-                        tj_core::reminder::active_task_reminder(&conn, &label)
+                // Preferences are global, so they show in a fresh project too.
+                let mut parts = vec![session_preferences_block()];
+                let mut has_task = false;
+                // No journal yet: don't create a SQLite file for every
+                // project Claude Code is opened in.
+                if events_path.exists() {
+                    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)?;
+                    if let Some(line) =
+                        session_start_line(&conn, &project_hash, live_session_id.as_deref(), &cwd)?
                     {
-                        bundle.push_str(&reminder);
-                        bundle.push_str("\n\n");
-                    }
-                }
-                if source == "compact" {
-                    // Advisory (the hook can't force it): suggest the main agent
-                    // delegate the just-compacted segment to the in-session
-                    // distiller subagent, which backfills missed reasoning from
-                    // the transcript file (which survives compaction) for the
-                    // active task(s). Background → never blocks. Gated off by
-                    // TJ_DISTILLER_HINT=0 for users who don't want it.
-                    if std::env::var("TJ_DISTILLER_HINT").as_deref() != Ok("0") {
-                        let transcript_hint = payload
-                            .get("transcript_path")
-                            .and_then(|v| v.as_str())
-                            .map(|p| format!(" (transcript: {p})"))
-                            .unwrap_or_default();
-                        bundle.push_str(&format!(
-                            "[task-journal] A compaction just occurred. If decisions, rejections, \
-or findings from before it are not yet in the journal for the active task(s) above, delegate to \
-the `task-journal-distiller` subagent to capture them from the transcript{transcript_hint}. It \
-runs in the background and won't block you; it only fills gaps and never closes tasks.\n\n"
-                        ));
+                        parts.push(line);
+                        has_task = true;
                     }
                 }
-                if let Some(line) = &chronicle_line {
-                    bundle.push_str(line);
-                    bundle.push_str("\n\n");
-                }
-                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");
+
+                // After a compaction the mod catches up on its own; without
+                // it, point at the distiller subagent, which backfills what
+                // was not logged from the transcript (it survives compaction).
+                // TJ_DISTILLER_HINT=0 turns this off.
+                let source = payload.get("source").and_then(|v| v.as_str()).unwrap_or("");
+                if source == "compact"
+                    && has_task
+                    && !mod_on
+                    && std::env::var("TJ_DISTILLER_HINT").as_deref() != Ok("0")
+                {
+                    let transcript_hint = payload
+                        .get("transcript_path")
+                        .and_then(|v| v.as_str())
+                        .map(|p| format!(" (transcript: {p})"))
+                        .unwrap_or_default();
+                    parts.push(format!(
+                        "[task-journal] A compaction just occurred. If decisions, rejections or \
+findings from before it are missing from the journal, delegate to the `task-journal-distiller` \
+subagent to capture them from the transcript{transcript_hint}. It runs in the background and \
+never closes tasks."
+                    ));
                 }
 
-                // We deliberately DO NOT emit `sessionTitle` or
-                // `initialUserMessage` here. The v0.10.1 X2 experiment set
-                // `sessionTitle` to "TJ — <task_id> (<n> open)", which
-                // OVERRODE Claude Code's native session name with our task id
-                // — users saw "TJ — tj-qqay98cpc2" instead of a name derived
-                // from their own prompt. `initialUserMessage` injected a
-                // "[Task Journal resumed: …]" banner into the next prompt,
-                // which the auto-open path then captured as a garbage task
-                // title. The resume context the model actually needs already
-                // rides in `additionalContext`; the tab label belongs to
-                // Claude Code, not to us. (0.14.3)
-                let hook_specific = serde_json::json!({
-                    "hookEventName": "SessionStart",
-                    "additionalContext": bundle.trim_end(),
-                });
-                let envelope = serde_json::json!({
-                    "hookSpecificOutput": hook_specific,
-                });
-                println!("{}", serde_json::to_string(&envelope)?);
+                let context = parts
+                    .into_iter()
+                    .filter(|part| !part.is_empty())
+                    .collect::<Vec<_>>()
+                    .join("\n\n");
+                if !context.is_empty() {
+                    emit_session_context(&context);
+                }
                 return Ok(());
             }
 
@@ -3149,6 +3000,14 @@ runs in the background and won't block you; it only fills gaps and never closes
                 return Ok(());
             }
 
+            // Past this point is capture: transcript catch-ups and the
+            // classifier queue. The mod records the session in-process, and
+            // the plugin's hooks never start it — without the mod the queue
+            // grew with nothing to drain it (0.14.4).
+            if from_plugin || mod_on {
+                return Ok(());
+            }
+
             // PreCompact: Claude Code is about to compact the conversation.
             // Two responsibilities:
             //   1. Catch-up ingest — read the transcript JSONL tail (entries
@@ -3417,11 +3276,6 @@ runs in the background and won't block you; it only fills gaps and never closes
                 return Ok(());
             }
 
-            // The mod classifies prompts and tool calls itself (see above).
-            if mod_on && matches!(kind.as_str(), "UserPromptSubmit" | "PostToolUse") {
-                return Ok(());
-            }
-
             // A tool call arrives as its full input + response JSON; cap it
             // so one big file read or command output can't flood the queue.
             let text: String = if kind == "PostToolUse" {
@@ -3546,6 +3400,9 @@ runs in the background and won't block you; it only fills gaps and never closes
                     let Some(tid) = out.task_id_guess else {
                         return Ok(());
                     };
+                    if !worth_recording(out.event_type, &out.suggested_text, &text) {
+                        return Ok(());
+                    }
 
                     // Journal-integrity safeguards. The classifier sometimes
                     // mis-attributes events to old or closed tasks (no fault
@@ -4876,9 +4733,9 @@ fn nudge_escalation_text(work_bytes: u64, recorded: usize) -> Option<String> {
         return None;
     }
     Some(format!(
-        "⚠ task-journal: this session has done substantial work but recorded only \
-{recorded} journal entr{} — log the key decisions, rejections, and findings NOW via \
-event_add before this reasoning is lost.",
+        "task-journal: this session has done substantial work but recorded only \
+{recorded} journal entr{} — log the key decisions, rejections and findings with \
+event_add while they are fresh.",
         if recorded == 1 { "y" } else { "ies" }
     ))
 }
@@ -4911,13 +4768,23 @@ fn count_session_events_tail(path: &std::path::Path, sid: &str, tail_lines: usiz
 /// True when the Claude Code mod (`plugin/hooks/register.ts`) runs in this
 /// session: it sets `TJ_MOD_ACTIVE` for every hook it starts. Codex never does.
 fn mod_active() -> bool {
-    std::env::var("TJ_MOD_ACTIVE").is_ok_and(|v| !v.is_empty() && v != "0")
+    env_flag("TJ_MOD_ACTIVE")
 }
 
-/// Adaptive UserPromptSubmit nudge (caveman pattern, non-blocking, free): always
-/// emit the base "record as you go" reminder, and — when the session has done
-/// substantial work but logged little — escalate. All signals are cheap (a file
-/// size + a tail scan); no model, never blocks the prompt.
+/// An environment flag the mod sets: on unless unset, empty or "0".
+fn env_flag(name: &str) -> bool {
+    std::env::var(name).is_ok_and(|v| !v.is_empty() && v != "0")
+}
+
+/// Prompts of one session per nudge; `TJ_NUDGE_EVERY` overrides it. The same
+/// reminder on every prompt is noise the model learns to skip.
+const NUDGE_EVERY: u32 = 6;
+
+/// Adaptive UserPromptSubmit nudge (non-blocking, free): on the first prompt
+/// of a session and then every [`NUDGE_EVERY`]th, the base "record as you go"
+/// reminder — and, when the session has done substantial work but logged
+/// little, an escalation. All signals are cheap (a file size + a tail scan);
+/// no model, never blocks the prompt.
 fn run_nudge() -> anyhow::Result<()> {
     // Recursion guard, same as recall-hook: never inject into our own
     // classifier child (`claude -p` / `codex exec` re-run the user's hooks).
@@ -4929,20 +4796,40 @@ fn run_nudge() -> anyhow::Result<()> {
         return Ok(());
     }
 
-    let mut ctx = NUDGE_BASE.to_string();
-    let escalation = (|| -> Option<String> {
+    let payload = (|| -> Option<serde_json::Value> {
         use std::io::{IsTerminal, Read};
-        // Manual `task-journal nudge` in a terminal has no hook payload — don't
-        // block waiting on stdin.
+        // Manual `task-journal nudge` in a terminal has no hook payload —
+        // don't block waiting on stdin.
         if std::io::stdin().is_terminal() {
             return None;
         }
         let mut buf = String::new();
-        if std::io::stdin().read_to_string(&mut buf).is_err() || buf.trim().is_empty() {
-            return None;
+        std::io::stdin().read_to_string(&mut buf).ok()?;
+        serde_json::from_str(&buf).ok()
+    })();
+    let sid = payload
+        .as_ref()
+        .and_then(|p| tj_core::session_id::live_session_id(Some(p)));
+
+    if let (Some(sid), Ok(state_dir)) = (&sid, tj_core::paths::state_dir()) {
+        let every = std::env::var("TJ_NUDGE_EVERY")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(NUDGE_EVERY)
+            .max(1);
+        let _ = std::fs::create_dir_all(&state_dir);
+        let prompt = session_counter(&state_dir.join("nudge.pace"), sid, |n| {
+            n.unwrap_or(0).saturating_add(1)
+        });
+        if (prompt - 1) % every != 0 {
+            return Ok(());
         }
-        let payload: serde_json::Value = serde_json::from_str(&buf).ok()?;
-        let sid = tj_core::session_id::live_session_id(Some(&payload))?;
+    }
+
+    let mut ctx = NUDGE_BASE.to_string();
+    let escalation = (|| -> Option<String> {
+        let payload = payload.as_ref()?;
+        let sid = sid.as_deref()?;
         let transcript = payload.get("transcript_path").and_then(|v| v.as_str())?;
         let work_bytes = std::fs::metadata(transcript).map(|m| m.len()).unwrap_or(0);
         let cwd = std::env::current_dir().ok()?;
@@ -4950,7 +4837,7 @@ fn run_nudge() -> anyhow::Result<()> {
         let events_path = tj_core::paths::events_dir()
             .ok()?
             .join(format!("{project_hash}.jsonl"));
-        let recorded = count_session_events_tail(&events_path, &sid, 400);
+        let recorded = count_session_events_tail(&events_path, sid, 400);
         nudge_escalation_text(work_bytes, recorded)
     })();
     if let Some(extra) = escalation {
@@ -5137,19 +5024,130 @@ fn session_preferences_block() -> String {
     s.trim_end().to_string()
 }
 
-/// How long a resumed or forked conversation must have sat idle before the
-/// active-task reminder earns its place in `additionalContext`. Eight hours —
-/// roughly "picked it up the next day".
-const STALE_RESUME_SECS: u64 = 8 * 60 * 60;
+/// Most characters of a goal the SessionStart line repeats.
+const START_GOAL_MAX: usize = 200;
 
-/// Coarse, human-readable gap ("14h", "3d") for the reminder label.
-fn human_gap(secs: u64) -> String {
-    let hours = secs / 3600;
-    if hours >= 48 {
-        format!("{}d", hours / 24)
-    } else {
-        format!("{hours}h")
+/// The SessionStart line: the open task this session most likely continues —
+/// its own (after a compaction or a resume), else the one the git branch
+/// names, else the folder's latest — and how to resume it. `None` when the
+/// folder has no open task.
+fn session_start_line(
+    conn: &rusqlite::Connection,
+    project_hash: &str,
+    session: Option<&str>,
+    cwd: &std::path::Path,
+) -> anyhow::Result<Option<String>> {
+    let open: i64 = conn.query_row("SELECT COUNT(*) FROM tasks WHERE status='open'", [], |r| {
+        r.get(0)
+    })?;
+    if open == 0 {
+        return Ok(None);
+    }
+
+    let own = match session {
+        Some(sid) => tj_core::db::active_task_for_session(conn, project_hash, sid)?,
+        None => None,
+    };
+    let by_branch = match (&own, git_branch(cwd)) {
+        (None, Some(branch)) => task_for_branch(conn, &branch)?.map(|id| (id, branch)),
+        _ => None,
+    };
+    let (task_id, why) = match (own, by_branch) {
+        (Some(id), _) => (id, "this session's task".to_string()),
+        (None, Some((id, branch))) => (id, format!("the task for branch {branch}")),
+        (None, None) => {
+            let id: String = conn.query_row(
+                "SELECT task_id FROM tasks WHERE status='open' ORDER BY last_event_at DESC LIMIT 1",
+                [],
+                |r| r.get(0),
+            )?;
+            (id, "the latest open task here".to_string())
+        }
+    };
+
+    let (title, goal): (String, Option<String>) = conn.query_row(
+        "SELECT title, goal FROM tasks WHERE task_id=?1",
+        rusqlite::params![task_id],
+        |r| Ok((r.get(0)?, r.get(1)?)),
+    )?;
+    let goal = goal
+        .filter(|g| !g.trim().is_empty())
+        .map(|g| {
+            let short: String = g.chars().take(START_GOAL_MAX).collect();
+            format!(" — goal: {}", short.trim_end().trim_end_matches('.'))
+        })
+        .unwrap_or_default();
+    let others = match open - 1 {
+        0 => String::new(),
+        n => format!(" {n} more open: task_search(status=\"open\")."),
+    };
+
+    Ok(Some(format!(
+        "📓 Task Journal — {why}: {task_id} \"{title}\"{goal}. If this work continues it, resume with task_pack(\"{task_id}\").{others}"
+    )))
+}
+
+/// The open task the branch names: one whose events carry the branch, or
+/// carry (or whose title holds) the issue key in it — `feat/DEV-4621-x`
+/// names DEV-4621. Newest first.
+fn task_for_branch(conn: &rusqlite::Connection, branch: &str) -> anyhow::Result<Option<String>> {
+    use rusqlite::OptionalExtension;
+
+    let mut needles = vec![(branch.to_string(), false)];
+    needles.extend(
+        tj_core::artifacts::extract(branch)
+            .linked_issues
+            .into_iter()
+            .map(|issue| (issue, true)),
+    );
+
+    for (needle, by_title) in needles {
+        let id: Option<String> = conn
+            .query_row(
+                "SELECT t.task_id FROM tasks t
+                 WHERE t.status = 'open'
+                   AND ((?3 AND t.title LIKE ?2)
+                        OR EXISTS (SELECT 1 FROM events_index ei
+                                   WHERE ei.task_id = t.task_id AND ei.artifacts LIKE ?1))
+                 ORDER BY t.last_event_at DESC LIMIT 1",
+                rusqlite::params![format!("%\"{needle}\"%"), format!("%{needle}%"), by_title],
+                |r| r.get(0),
+            )
+            .optional()?;
+        if id.is_some() {
+            return Ok(id);
+        }
     }
+
+    Ok(None)
+}
+
+/// The checked-out branch of the repository holding `dir`, read from its
+/// `HEAD` (a worktree's `.git` file points at its own). `None` outside a
+/// repository or on a detached HEAD.
+fn git_branch(dir: &std::path::Path) -> Option<String> {
+    let git = dir
+        .ancestors()
+        .map(|d| d.join(".git"))
+        .find(|p| p.exists())?;
+    let head = if git.is_dir() {
+        git.join("HEAD")
+    } else {
+        let body = std::fs::read_to_string(&git).ok()?;
+        let gitdir = std::path::Path::new(body.trim().strip_prefix("gitdir:")?.trim());
+        let gitdir = if gitdir.is_absolute() {
+            gitdir.to_path_buf()
+        } else {
+            git.parent()?.join(gitdir)
+        };
+        gitdir.join("HEAD")
+    };
+
+    std::fs::read_to_string(head)
+        .ok()?
+        .trim()
+        .strip_prefix("ref: refs/heads/")
+        .map(str::to_string)
 }
 
 /// Emit a SessionStart `additionalContext` envelope and nothing else.
@@ -5163,6 +5161,170 @@ fn emit_session_context(ctx: &str) {
     println!("{env}");
 }
 
+/// Takes task-journal's hooks (`ingest-hook`, `nudge`, `recall-hook`) and its
+/// legacy env key out of a settings.json / hooks.json object. Surgical: other
+/// tools' hooks and env entries stay (the old `remove("hooks")` nuked
+/// everyone's — the bxl bug); a matcher, event, `hooks` or `env` block this
+/// leaves empty goes too.
+fn remove_task_journal_hooks(settings: &mut serde_json::Map<String, serde_json::Value>) {
+    let is_ours = |c: &str| {
+        c.contains("task-journal ingest-hook")
+            || c.contains("task-journal nudge")
+            || c.contains("task-journal recall-hook")
+    };
+
+    if let Some(hooks_block) = settings.get_mut("hooks").and_then(|v| v.as_object_mut()) {
+        let kinds: Vec<String> = hooks_block.keys().cloned().collect();
+        for kind in kinds {
+            let Some(arr) = hooks_block.get_mut(&kind).and_then(|v| v.as_array_mut()) else {
+                continue;
+            };
+            // Each entry is { matcher, hooks: [{type, command}, ...] }.
+            for entry in arr.iter_mut() {
+                if let Some(inner) = entry.get_mut("hooks").and_then(|v| v.as_array_mut()) {
+                    inner.retain(|h| {
+                        h.get("command")
+                            .and_then(|c| c.as_str())
+                            .map(|c| !is_ours(c))
+                            .unwrap_or(true)
+                    });
+                }
+            }
+            arr.retain(|entry| {
+                entry
+                    .get("hooks")
+                    .and_then(|v| v.as_array())
+                    .map(|a| !a.is_empty())
+                    .unwrap_or(true)
+            });
+            if arr.is_empty() {
+                hooks_block.remove(&kind);
+            }
+        }
+        if hooks_block.is_empty() {
+            settings.remove("hooks");
+        }
+    }
+
+    if let Some(env) = settings.get_mut("env").and_then(|v| v.as_object_mut()) {
+        env.remove("TJ_CLASSIFIER_CLI");
+        if env.is_empty() {
+            settings.remove("env");
+        }
+    }
+}
+
+/// Why `event` is noise the classifier filed as reasoning, or `None` when it
+/// stays: only classifier entries of a reasoning type are judged — machine
+/// text of any type, and a rejection that rules no approach out.
+fn cleanup_reason(event: &tj_core::event::Event) -> Option<&'static str> {
+    use tj_core::event::{Author, EventType};
+
+    let reasoning = matches!(
+        event.event_type,
+        EventType::Decision
+            | EventType::Rejection
+            | EventType::Finding
+            | EventType::Evidence
+            | EventType::Hypothesis
+            | EventType::Constraint
+    );
+    // Compaction markers and model switches are the journal's own
+    // bookkeeping, already kept out of packs and recall.
+    if event.author != Author::Classifier || !reasoning || tj_core::db::is_bookkeeping(event) {
+        return None;
+    }
+
+    tj_core::noise::machine_text(&event.text).or_else(|| {
+        (event.event_type == EventType::Rejection
+            && !tj_core::classifier::is_explicit_rejection(&event.text))
+        .then_some("rejection that rules no approach out")
+    })
+}
+
+/// `task-journal cleanup-noise [--dry-run] [--all]`: one bookkeeping
+/// correction per noise entry not corrected yet, so a second run finds
+/// nothing. Prints counts by reason per journal, with samples on a dry run.
+fn run_cleanup_noise(dry_run: bool, all: bool) -> Result<()> {
+    let events_dir = tj_core::paths::events_dir()?;
+    let journals: Vec<std::path::PathBuf> = if all {
+        let mut paths: Vec<_> = std::fs::read_dir(&events_dir)?
+            .filter_map(|e| e.ok().map(|e| e.path()))
+            .filter(|p| p.extension().is_some_and(|x| x == "jsonl"))
+            .collect();
+        paths.sort();
+        paths
+    } else {
+        let hash = tj_core::project_hash::from_path(std::env::current_dir()?)?;
+        vec![events_dir.join(format!("{hash}.jsonl"))]
+    };
+
+    let mut total = 0usize;
+    for path in journals.iter().filter(|p| p.exists()) {
+        let events = read_events_lenient(path, "cleanup-noise")?;
+        let corrected: std::collections::HashSet<&str> = events
+            .iter()
+            .filter_map(|e| e.corrects.as_deref())
+            .collect();
+        let noise: Vec<(&tj_core::event::Event, &str)> = events
+            .iter()
+            .filter(|e| !corrected.contains(e.event_id.as_str()))
+            .filter_map(|e| cleanup_reason(e).map(|why| (e, why)))
+            .collect();
+        if noise.is_empty() {
+            continue;
+        }
+
+        let mut by_reason: std::collections::BTreeMap<&str, Vec<&tj_core::event::Event>> =
+            Default::default();
+        for (e, why) in &noise {
+            by_reason.entry(why).or_default().push(e);
+        }
+        let name = path.file_stem().and_then(|n| n.to_str()).unwrap_or("?");
+        println!(
+            "{name}: {} entr{}",
+            noise.len(),
+            if noise.len() == 1 { "y" } else { "ies" }
+        );
+        for (why, list) in &by_reason {
+            println!("  {why}: {}", list.len());
+            if dry_run {
+                for e in list.iter().take(3) {
+                    let sample: String = e.text.chars().take(100).collect();
+                    println!("    {:?}: {}", e.event_type, sample.replace('\n', " "));
+                }
+            }
+        }
+        total += noise.len();
+
+        if !dry_run {
+            let mut writer = tj_core::storage::JsonlWriter::open(path)?;
+            for (e, why) in &noise {
+                let mut fix = tj_core::event::Event::new(
+                    &e.task_id,
+                    tj_core::event::EventType::Correction,
+                    tj_core::event::Author::User,
+                    tj_core::event::Source::Cli,
+                    format!("{} not reasoning: {why}", tj_core::noise::CLEANUP_PREFIX),
+                );
+                fix.corrects = Some(e.event_id.clone());
+                fix.status = tj_core::event::EventStatus::Confirmed;
+                fix.meta = serde_json::json!({ "kind": tj_core::db::NOISE_CLEANUP });
+                writer.append(&fix)?;
+            }
+            writer.flush_durable()?;
+        }
+    }
+
+    match (total, dry_run) {
+        (0, _) => println!("nothing to clean"),
+        (n, true) => println!("{n} entries would be retired; run without --dry-run to retire them"),
+        (n, false) => println!("{n} entries retired"),
+    }
+
+    Ok(())
+}
+
 const CONSOLIDATE_TASK_TITLE: &str = "Project conventions (consolidated)";
 
 /// Dream backfill, shared by `dream` and `complete`: re-read the in-scope
@@ -6351,6 +6513,26 @@ fn process_pending_entry(
     Ok(())
 }
 
+/// Whether a classified chunk is worth an event: its text is reasoning, not
+/// a raw tool call, a summary or a notification, and a rejection rules an
+/// approach out in so many words. Whole answers, tool payloads and summaries
+/// filed as rejections were most of what recall later pushed back.
+fn worth_recording(
+    event_type: tj_core::event::EventType,
+    suggested_text: &str,
+    chunk: &str,
+) -> bool {
+    use tj_core::classifier::is_explicit_rejection;
+
+    if tj_core::noise::machine_text(suggested_text).is_some() {
+        return false;
+    }
+
+    event_type != tj_core::event::EventType::Rejection
+        || is_explicit_rejection(suggested_text)
+        || is_explicit_rejection(chunk)
+}
+
 /// What became of one classified chunk.
 enum ChunkOutcome {
     /// An event was written to the journal.
@@ -6438,6 +6620,12 @@ fn classify_chunk(
         recent.push(new_task);
     }
 
+    // A compaction summary or a harness notification is never reasoning; a
+    // tool call still may carry a test result, so it goes on.
+    if kind != "PostToolUse" && tj_core::noise::machine_text(text).is_some() {
+        return Ok(ChunkOutcome::Dropped);
+    }
+
     let author_hint = if kind.contains("UserPrompt") {
         "user"
     } else {
@@ -6458,6 +6646,9 @@ fn classify_chunk(
     let Some(tid) = out.task_id_guess else {
         return Ok(ChunkOutcome::Dropped);
     };
+    if !worth_recording(out.event_type, &out.suggested_text, text) {
+        return Ok(ChunkOutcome::Dropped);
+    }
 
     use tj_core::event::EventType;
     if matches!(out.event_type, EventType::Close) && kind == "Stop" {
@@ -6582,91 +6773,166 @@ fn drain_pending(
 /// 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.
-/// Build a PostToolUse `updatedMCPToolOutput` envelope when an MCP tool call
-/// echoes a prior rejection/decision (claude-memory-7km). Returns None
-/// (pass through, emit nothing) for non-MCP tools, no hits, or any error.
-/// Never panics, never mutates the journal.
-///
-/// Dedup vs claude-memory-60m: this fires ONLY for `mcp__` tools; 60m's
-/// `additionalContext` path skips those. The two are mutually exclusive by
-/// tool type so a single recall is never double-surfaced.
-fn push_recall_envelope(
+/// Least tool calls between two recalls in one session; `TJ_RECALL_EVERY`
+/// overrides it (0 lets every call recall).
+const RECALL_EVERY: u32 = 10;
+
+/// What push-recall may show after one tool call: at most one prior
+/// rejection or decision of the session's active task (or of a task in the
+/// same module) that the call clearly touches — see
+/// `tj_core::recall::recall_for_task`. Each event at most once per session,
+/// and no more often than once every [`RECALL_EVERY`] tool calls. Nothing
+/// without a session id or an active task, and nothing for the journal's own
+/// tools, whose output already is the journal. Best-effort: any error is
+/// silence.
+fn session_recall(
     payload: &serde_json::Value,
     events_path: &std::path::Path,
     project_hash: &str,
     session_id: Option<&str>,
-) -> Option<serde_json::Value> {
-    // MCP-only gate: Claude Code prefixes MCP tools `mcp__<server>__<tool>`.
-    let tool_name = payload.get("tool_name").and_then(|v| v.as_str())?;
-    if !tool_name.starts_with("mcp__") {
-        return None;
-    }
-    if !events_path.exists() {
-        return None;
-    }
-    let query_text = payload
-        .get("tool_input")
-        .map(|v| v.to_string())
+) -> Vec<tj_core::recall::RecallHit> {
+    let tool = payload
+        .get("tool_name")
+        .and_then(|v| v.as_str())
         .unwrap_or_default();
-    if query_text.trim().is_empty() {
-        return None;
+    let (Some(sid), Ok(state_dir)) = (session_id, tj_core::paths::state_dir()) else {
+        return Vec::new();
+    };
+    if tool.contains("task-journal__") || !events_path.exists() {
+        return Vec::new();
     }
-    let original = payload
-        .get("tool_response")
-        .map(render_tool_response)
-        .unwrap_or_default();
 
-    let state_path = tj_core::paths::state_dir()
-        .ok()?
-        .join(format!("{project_hash}.sqlite"));
-    let conn = tj_core::db::open(&state_path).ok()?;
+    let every = std::env::var("TJ_RECALL_EVERY")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(RECALL_EVERY);
+    let pace = state_dir.join(format!("{project_hash}.recall-pace"));
+    // Calls since the last recall; a session's first call counts as due.
+    let since_last = session_counter(&pace, sid, |n| n.map_or(every, |n| n.saturating_add(1)));
+    if since_last < every {
+        return Vec::new();
+    }
+
+    let Ok(conn) = tj_core::db::open(state_dir.join(format!("{project_hash}.sqlite"))) else {
+        return Vec::new();
+    };
     let _ = tj_core::db::ingest_new_events(&conn, events_path, project_hash);
-    // Reuse 60m's recall engine + threshold — no recall logic lives here.
-    let hits =
-        tj_core::recall::relevant_recall(&conn, &query_text, tj_core::recall::DEFAULT_MAX_HITS)
-            .ok()?;
-    let hits = fresh_recall_hits(hits, session_id, events_path, project_hash);
+    let Ok(Some(task)) = tj_core::db::active_task_for_session(&conn, project_hash, sid) else {
+        return Vec::new();
+    };
+
+    let query = tool_input_text(payload);
+    let hits = tj_core::recall::recall_for_task(&conn, &task, &query, 5).unwrap_or_default();
+    let hits = fresh_recall_hits(
+        hits,
+        Some(sid),
+        events_path,
+        project_hash,
+        tj_core::recall::DEFAULT_MAX_HITS,
+    );
+    if !hits.is_empty() {
+        session_counter(&pace, sid, |_| 0);
+    }
+
+    hits
+}
+
+/// What a tool call did, as text: the string values of its input, without
+/// the JSON keys (`file_path`, `old_string` say nothing about the work) and
+/// without the output (a log or a file's content is not the agent's intent).
+fn tool_input_text(payload: &serde_json::Value) -> String {
+    fn strings<'a>(v: &'a serde_json::Value, out: &mut Vec<&'a str>) {
+        match v {
+            serde_json::Value::String(s) => out.push(s),
+            serde_json::Value::Array(items) => items.iter().for_each(|x| strings(x, out)),
+            serde_json::Value::Object(map) => map.values().for_each(|x| strings(x, out)),
+            _ => {}
+        }
+    }
+
+    let mut parts = Vec::new();
+    if let Some(input) = payload.get("tool_input") {
+        strings(input, &mut parts);
+    }
+
+    parts.join(" ")
+}
+
+/// The PostToolUse `additionalContext` envelope for recall hits, or `None`
+/// without any. Every tool gets the same shape: the hook runs async, and an
+/// async `updatedMCPToolOutput` (the old banner over an MCP tool's output)
+/// never reached the model — besides rewriting other servers' output.
+fn recall_envelope(hits: &[tj_core::recall::RecallHit]) -> Option<serde_json::Value> {
     if hits.is_empty() {
         return None;
     }
-    let updated = format!("{}\n\n{}", render_recall_banner(&hits), original);
+
+    let context = hits
+        .iter()
+        .map(|h| {
+            let verb = match h.event_type {
+                tj_core::event::EventType::Rejection => "previously rejected",
+                _ => "previously decided",
+            };
+            format!("⚠ recall: in task {} you {}: {}", h.task_id, verb, h.text)
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+
     Some(serde_json::json!({
-        "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
-            "updatedMCPToolOutput": updated,
-        }
+        "hookSpecificOutput": { "hookEventName": "PostToolUse", "additionalContext": context }
     }))
 }
 
+/// Most `<session> <n>` lines a per-session counter file keeps.
+const SESSION_COUNTER_CAP: usize = 500;
+
+/// Sets `sid`'s counter in `path` (lines `<session> <n>`, newest last) to
+/// `next(current)` and returns the new value. Best-effort: an unreadable file
+/// counts as empty, a failed write is ignored.
+// ponytail: read-modify-write without a lock; two parallel hooks can lose
+// one count, which only shifts the next reminder by a call.
+fn session_counter(
+    path: &std::path::Path,
+    sid: &str,
+    next: impl FnOnce(Option<u32>) -> u32,
+) -> u32 {
+    let body = std::fs::read_to_string(path).unwrap_or_default();
+    let mut current = None;
+    let mut lines: Vec<&str> = Vec::new();
+    for line in body.lines() {
+        match line.split_once(' ') {
+            Some((s, n)) if s == sid => current = n.parse().ok(),
+            _ => lines.push(line),
+        }
+    }
+
+    let value = next(current);
+    let own = format!("{sid} {value}");
+    lines.push(&own);
+    let keep = &lines[lines.len().saturating_sub(SESSION_COUNTER_CAP)..];
+    let _ = std::fs::write(path, keep.join("\n") + "\n");
+
+    value
+}
+
 /// Most `<session> <event_id>` lines the shown-recall log keeps.
 const RECALL_SHOWN_CAP: usize = 2000;
 
-/// The recall hits still worth pushing to `session_id`: each one at most once
-/// per session (remembered in `<state_dir>/<project>.recall-shown`, newest
-/// [`RECALL_SHOWN_CAP`] lines), and never an event the session wrote on its
-/// current task — the agent just wrote it. Without a session id every hit
-/// passes, as before. Best-effort: an unreadable log never hides a hit.
+/// The first `max` recall hits still worth pushing to `session_id`: each one
+/// at most once per session (remembered in `<state_dir>/<project>.recall-shown`,
+/// newest [`RECALL_SHOWN_CAP`] lines), and never an event the session wrote on
+/// its current task — the agent just wrote it. Without a session id every hit
+/// passes. Best-effort: an unreadable log never hides a hit.
 fn fresh_recall_hits(
     hits: Vec<tj_core::recall::RecallHit>,
     session_id: Option<&str>,
     events_path: &std::path::Path,
     project_hash: &str,
+    max: usize,
 ) -> Vec<tj_core::recall::RecallHit> {
     let Some(sid) = session_id else {
-        return hits;
+        return hits.into_iter().take(max).collect();
     };
     if hits.is_empty() {
         return hits;
@@ -6674,7 +6940,7 @@ fn fresh_recall_hits(
     let Ok(log) =
         tj_core::paths::state_dir().map(|d| d.join(format!("{project_hash}.recall-shown")))
     else {
-        return hits;
+        return hits.into_iter().take(max).collect();
     };
 
     let own = session_task_event_ids(events_path, sid);
@@ -6684,6 +6950,7 @@ fn fresh_recall_hits(
         .into_iter()
         .filter(|h| !own.contains(&h.event_id))
         .filter(|h| !shown.contains(format!("{sid} {}", h.event_id).as_str()))
+        .take(max)
         .collect();
     if fresh.is_empty() {
         return fresh;
@@ -6728,32 +6995,19 @@ fn session_task_event_ids(
         .collect()
 }
 
-/// One ⚠ line per recall hit (mirrors the close-gate / SessionStart convention).
-fn render_recall_banner(hits: &[tj_core::recall::RecallHit]) -> String {
-    let mut s = String::from("\u{26a0} Task Journal recall — you may be repeating a prior path:");
-    for h in hits {
-        let verb = match h.event_type {
-            tj_core::event::EventType::Rejection => "rejected",
-            _ => "decided on",
-        };
-        s.push_str(&format!(
-            "\n  \u{26a0} in task {} you previously {} this: {}",
-            h.task_id, verb, h.text
-        ));
-    }
-    s
-}
-
-/// Collapse a `tool_response` JSON value to the text Claude would have seen.
-/// A bare string is used as-is; any other JSON is stringified (mirrors how
-/// `parse_hook_stdin` stringifies `tool_response`).
-fn render_tool_response(v: &serde_json::Value) -> String {
-    match v {
-        serde_json::Value::String(s) => s.clone(),
-        other => other.to_string(),
-    }
-}
-
+/// 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, serde_json::Value)> {
     let mut buf = String::new();
     std::io::Read::read_to_string(&mut std::io::stdin(), &mut buf)
diff --git a/crates/tj-cli/tests/cli.rs b/crates/tj-cli/tests/cli.rs
index 53c5adb..36ca1b5 100644
--- a/crates/tj-cli/tests/cli.rs
+++ b/crates/tj-cli/tests/cli.rs
@@ -22,6 +22,9 @@ impl Command {
             "CLAUDE_CODE_SESSION_ID",
             "TJ_IN_CLASSIFIER",
             "TJ_MOD_ACTIVE",
+            "TJ_PLUGIN_HOOKS",
+            "TJ_RECALL_EVERY",
+            "TJ_NUDGE_EVERY",
         ] {
             cmd.env_remove(var);
         }
@@ -1717,16 +1720,77 @@ fn event_correct_links_to_corrected_event() {
         .stdout(contains("Migration was NOT done").and(contains("[correction]")));
 }
 
+/// Claude Code takes its hooks from the plugin; the ones earlier versions
+/// wrote to settings.json ran next to them. install-hooks for Claude Code now
+/// takes ours out — after a copy of the file — and keeps everyone else's.
+#[test]
+fn install_hooks_for_claude_code_removes_its_hooks_after_a_backup() {
+    let dir = assert_fs::TempDir::new().unwrap();
+    let claude_dir = dir.path().join(".claude");
+    std::fs::create_dir_all(&claude_dir).unwrap();
+    let ours = |command: &str| serde_json::json!({ "type": "command", "command": command });
+    let original = serde_json::json!({
+        "theme": "dark",
+        "hooks": {
+            "UserPromptSubmit": [{ "matcher": "", "hooks": [
+                ours("task-journal nudge || true"),
+                ours("task-journal ingest-hook || true"),
+                ours("task-journal recall-hook || true"),
+                ours("other-plugin do-thing"),
+            ]}],
+            "Stop": [{ "matcher": "", "hooks": [ours("task-journal ingest-hook || true")] }],
+        }
+    })
+    .to_string();
+    std::fs::write(claude_dir.join("settings.json"), &original).unwrap();
+
+    let run = || {
+        Command::cargo_bin("task-journal")
+            .unwrap()
+            .env("HOME", dir.path())
+            .args(["install-hooks", "--scope", "user", "--auto-capture"])
+            .assert()
+            .success()
+    };
+    run().stdout(contains("backup:"));
+
+    let content = std::fs::read_to_string(claude_dir.join("settings.json")).unwrap();
+    assert!(!content.contains("task-journal"), "{content}");
+    assert!(content.contains("other-plugin do-thing"), "{content}");
+    assert!(content.contains("dark"), "{content}");
+    assert!(
+        !content.contains("\"Stop\""),
+        "an event left empty goes: {content}"
+    );
+
+    let backups = || -> Vec<std::path::PathBuf> {
+        std::fs::read_dir(&claude_dir)
+            .unwrap()
+            .map(|e| e.unwrap().path())
+            .filter(|p| {
+                p.to_string_lossy()
+                    .contains("settings.json.task-journal-backup-")
+            })
+            .collect()
+    };
+    assert_eq!(backups().len(), 1);
+    assert_eq!(std::fs::read_to_string(&backups()[0]).unwrap(), original);
+
+    // Nothing left to take out: no write, no second backup.
+    run().stdout(contains("backup:").not());
+    assert_eq!(backups().len(), 1);
+}
+
 #[test]
 fn install_hooks_command_uses_no_fail_pattern() {
     let dir = assert_fs::TempDir::new().unwrap();
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user"])
+        .args(["install-hooks", "--scope", "user", "--client", "codex"])
         .assert()
         .success();
-    let s = std::fs::read_to_string(dir.path().join(".claude/settings.json")).unwrap();
+    let s = std::fs::read_to_string(dir.path().join(".codex/hooks.json")).unwrap();
     assert!(
         s.contains("|| true"),
         "hook command must end with || true so a failed classifier doesn't break Claude Code: {s}"
@@ -1734,16 +1798,16 @@ fn install_hooks_command_uses_no_fail_pattern() {
 }
 
 #[test]
-fn install_hooks_writes_to_settings_json() {
+fn install_hooks_default_wires_resume_and_nudge_only() {
     let dir = assert_fs::TempDir::new().unwrap();
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user"])
+        .args(["install-hooks", "--scope", "user", "--client", "codex"])
         .assert()
         .success();
 
-    let settings_path = dir.path().join(".claude").join("settings.json");
+    let settings_path = dir.path().join(".codex").join("hooks.json");
     assert!(settings_path.exists());
     let content = std::fs::read_to_string(&settings_path).unwrap();
     assert!(content.contains("task-journal ingest-hook")); // SessionStart resume
@@ -1774,12 +1838,18 @@ fn install_hooks_auto_capture_wires_all_events() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user", "--auto-capture"])
+        .args([
+            "install-hooks",
+            "--scope",
+            "user",
+            "--client",
+            "codex",
+            "--auto-capture",
+        ])
         .assert()
         .success();
 
-    let content =
-        std::fs::read_to_string(dir.path().join(".claude").join("settings.json")).unwrap();
+    let content = std::fs::read_to_string(dir.path().join(".codex").join("hooks.json")).unwrap();
     for ev in [
         "SessionStart",
         "UserPromptSubmit",
@@ -1787,7 +1857,6 @@ fn install_hooks_auto_capture_wires_all_events() {
         "Stop",
         "PreCompact",
         "SessionEnd",
-        "PostModelSwitch",
     ] {
         assert!(content.contains(ev), "--auto-capture must wire {ev}");
     }
@@ -1967,32 +2036,6 @@ fn post_model_switch_without_active_task_is_a_noop() {
         .stdout("");
 }
 
-/// Claude Code 2.1.268: SessionEnd hooks share a 1.5-second budget unless a
-/// per-hook `timeout` raises it (up to 60s). Without one, the last-chance
-/// catch-up ingest is cancelled and the tail of the session is lost.
-#[test]
-fn install_hooks_gives_session_end_a_timeout() {
-    let dir = assert_fs::TempDir::new().unwrap();
-    Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user", "--auto-capture"])
-        .assert()
-        .success();
-
-    let settings: serde_json::Value = serde_json::from_str(
-        &std::fs::read_to_string(dir.path().join(".claude").join("settings.json")).unwrap(),
-    )
-    .unwrap();
-    let timeout = settings["hooks"]["SessionEnd"][0]["hooks"][0]["timeout"]
-        .as_u64()
-        .expect("SessionEnd hook must declare a timeout");
-    assert!(
-        (10..=60).contains(&timeout),
-        "SessionEnd timeout must raise the 1.5s budget without exceeding the 60s cap: {timeout}"
-    );
-}
-
 /// The heavy capture hooks spawn a classifier. `async: true` (Claude Code
 /// 2.1.x) runs them in the background, so the chat never waits on them and no
 /// timeout applies. SessionStart stays synchronous — its stdout is the resume
@@ -2003,12 +2046,19 @@ fn install_hooks_runs_heavy_capture_hooks_async() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user", "--auto-capture"])
+        .args([
+            "install-hooks",
+            "--scope",
+            "user",
+            "--client",
+            "codex",
+            "--auto-capture",
+        ])
         .assert()
         .success();
 
     let settings: serde_json::Value = serde_json::from_str(
-        &std::fs::read_to_string(dir.path().join(".claude").join("settings.json")).unwrap(),
+        &std::fs::read_to_string(dir.path().join(".codex").join("hooks.json")).unwrap(),
     )
     .unwrap();
     for ev in ["PostToolUse", "Stop", "PreCompact"] {
@@ -2053,11 +2103,11 @@ fn session_end_hook_is_clean_noop_without_journal() {
 #[test]
 fn install_hooks_merges_and_preserves_third_party_hooks() {
     let dir = assert_fs::TempDir::new().unwrap();
-    let claude_dir = dir.path().join(".claude");
-    std::fs::create_dir_all(&claude_dir).unwrap();
+    let codex_dir = dir.path().join(".codex");
+    std::fs::create_dir_all(&codex_dir).unwrap();
     // Pre-existing foreign hooks (another plugin) on the same events we touch.
     std::fs::write(
-        claude_dir.join("settings.json"),
+        codex_dir.join("hooks.json"),
         serde_json::json!({
             "hooks": {
                 "UserPromptSubmit": [{ "matcher": "", "hooks": [
@@ -2076,14 +2126,14 @@ fn install_hooks_merges_and_preserves_third_party_hooks() {
         Command::cargo_bin("task-journal")
             .unwrap()
             .env("HOME", dir.path())
-            .args(["install-hooks", "--scope", "user"])
+            .args(["install-hooks", "--scope", "user", "--client", "codex"])
             .assert()
             .success();
     };
     run();
     run(); // idempotent: second install must not duplicate task-journal entries
 
-    let content = std::fs::read_to_string(claude_dir.join("settings.json")).unwrap();
+    let content = std::fs::read_to_string(codex_dir.join("hooks.json")).unwrap();
     // Foreign hooks survive.
     assert!(
         content.contains("other-plugin do-thing"),
@@ -2107,10 +2157,10 @@ fn install_hooks_merges_and_preserves_third_party_hooks() {
 #[test]
 fn install_hooks_is_idempotent_and_uninstall_works() {
     let dir = assert_fs::TempDir::new().unwrap();
-    let claude_dir = dir.path().join(".claude");
-    std::fs::create_dir_all(&claude_dir).unwrap();
+    let codex_dir = dir.path().join(".codex");
+    std::fs::create_dir_all(&codex_dir).unwrap();
     std::fs::write(
-        claude_dir.join("settings.json"),
+        codex_dir.join("hooks.json"),
         serde_json::json!({"theme": "dark"}).to_string(),
     )
     .unwrap();
@@ -2118,17 +2168,17 @@ fn install_hooks_is_idempotent_and_uninstall_works() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user"])
+        .args(["install-hooks", "--scope", "user", "--client", "codex"])
         .assert()
         .success();
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user"])
+        .args(["install-hooks", "--scope", "user", "--client", "codex"])
         .assert()
         .success();
 
-    let after_install = std::fs::read_to_string(claude_dir.join("settings.json")).unwrap();
+    let after_install = std::fs::read_to_string(codex_dir.join("hooks.json")).unwrap();
     assert!(
         after_install.contains("\"theme\":\"dark\"")
             || after_install.contains("\"theme\": \"dark\""),
@@ -2139,11 +2189,18 @@ fn install_hooks_is_idempotent_and_uninstall_works() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user", "--uninstall"])
+        .args([
+            "install-hooks",
+            "--scope",
+            "user",
+            "--client",
+            "codex",
+            "--uninstall",
+        ])
         .assert()
         .success();
 
-    let after_uninstall = std::fs::read_to_string(claude_dir.join("settings.json")).unwrap();
+    let after_uninstall = std::fs::read_to_string(codex_dir.join("hooks.json")).unwrap();
     assert!(
         after_uninstall.contains("\"theme\":\"dark\"")
             || after_uninstall.contains("\"theme\": \"dark\""),
@@ -2387,11 +2444,12 @@ fn ingest_hook_mock_drain_keeps_entries_it_cannot_record() {
     );
 }
 
-/// Run one `ingest-hook` payload of `kind` with `TJ_MOD_ACTIVE` set to
-/// `mod_value` (None = unset), in a fresh project with an open task and a
-/// transcript. True when the hook left any trace: stdout, a pending entry,
-/// or a new journal line.
-fn hook_leaves_a_trace(kind: &str, mod_value: Option<&str>) -> bool {
+/// Run one `ingest-hook` payload of `kind` with the given environment (what
+/// the mod sets: `TJ_MOD_ACTIVE`, `TJ_PLUGIN_HOOKS`), as the plugin's hook
+/// (`--from-plugin`) or a settings.json one, in a fresh project with an open
+/// task and a transcript. True when the hook left any trace: stdout, a
+/// pending entry, or a new journal line.
+fn hook_leaves_a_trace(kind: &str, env: &[(&str, &str)], from_plugin: bool) -> bool {
     let xdg = assert_fs::TempDir::new().unwrap();
     let proj = assert_fs::TempDir::new().unwrap();
     Command::cargo_bin("task-journal")
@@ -2432,11 +2490,16 @@ fn hook_leaves_a_trace(kind: &str, mod_value: Option<&str>) -> bool {
     cmd.env("XDG_DATA_HOME", xdg.path())
         .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
         .current_dir(proj.path());
-    if let Some(v) = mod_value {
-        cmd.env("TJ_MOD_ACTIVE", v);
+    for (k, v) in env {
+        cmd.env(k, v);
+    }
+    if from_plugin {
+        cmd.arg("ingest-hook").arg("--from-plugin");
+    } else {
+        cmd.arg("ingest-hook");
     }
     let out = cmd
-        .args(["ingest-hook", "--backend", "heuristic"])
+        .args(["--backend", "heuristic"])
         .write_stdin(payload.to_string())
         .assert()
         .success()
@@ -2450,43 +2513,78 @@ fn hook_leaves_a_trace(kind: &str, mod_value: Option<&str>) -> bool {
     !out.is_empty() || pending > 0 || journal_len() != before
 }
 
-/// The Claude Code mod captures in-process and sets TJ_MOD_ACTIVE for the
-/// hooks it starts; the classic capture must then stand down. (Nothing here
-/// echoes a prior entry, so push-recall stays quiet too.)
-#[test]
-fn mod_active_silences_the_classic_capture_hooks() {
-    for kind in [
-        "UserPromptSubmit",
-        "PostToolUse",
-        "Stop",
-        "PreCompact",
-        "SessionEnd",
-    ] {
-        assert!(!hook_leaves_a_trace(kind, Some("1")), "{kind}, mod on");
-        assert!(hook_leaves_a_trace(kind, Some("0")), "{kind}, mod \"0\"");
-        assert!(hook_leaves_a_trace(kind, None), "{kind}, mod unset");
+const NEW_MOD: &[(&str, &str)] = &[("TJ_MOD_ACTIVE", "1"), ("TJ_PLUGIN_HOOKS", "1")];
+const OLD_MOD: &[(&str, &str)] = &[("TJ_MOD_ACTIVE", "1")];
+const CAPTURE_KINDS: [&str; 5] = [
+    "UserPromptSubmit",
+    "PostToolUse",
+    "Stop",
+    "PreCompact",
+    "SessionEnd",
+];
+
+/// Beside a plugin that ships its own hooks, a task-journal hook still left
+/// in settings.json stands down for every event: one event, one record.
+/// Without a mod (Codex, older Claude Code) the classic hooks run whole.
+#[test]
+fn settings_json_hooks_stand_down_beside_the_plugins_hooks() {
+    for kind in CAPTURE_KINDS
+        .iter()
+        .chain(&["SessionStart", "PostModelSwitch"])
+    {
+        assert!(
+            !hook_leaves_a_trace(kind, NEW_MOD, false),
+            "{kind}, new mod"
+        );
+        assert!(
+            hook_leaves_a_trace(kind, &[("TJ_MOD_ACTIVE", "0")], false),
+            "{kind}, mod \"0\""
+        );
+        assert!(hook_leaves_a_trace(kind, &[], false), "{kind}, no mod");
     }
 }
 
-/// Resume packs and the model-switch constraint are not the mod's job.
+/// Beside an older mod whose plugin had no hooks, the settings.json hook
+/// keeps the session start and the model switch and leaves capture to it.
 #[test]
-fn mod_active_keeps_session_start_and_model_switch() {
+fn settings_json_hooks_beside_an_older_mod_skip_only_capture() {
     for kind in ["SessionStart", "PostModelSwitch"] {
-        assert!(hook_leaves_a_trace(kind, Some("1")), "{kind}, mod on");
+        assert!(hook_leaves_a_trace(kind, OLD_MOD, false), "{kind}");
+    }
+    for kind in CAPTURE_KINDS {
+        assert!(!hook_leaves_a_trace(kind, OLD_MOD, false), "{kind}");
     }
 }
 
-/// The mod takes over capture, not push-recall: a tool call that echoes a
-/// prior rejection still gets the recall on both paths, and nothing is queued.
+/// The plugin's hooks bring the session start and the model switch, with or
+/// without the mod — and never the classifier queue: without a mod to drain
+/// it, that queue only grew (0.14.4).
 #[test]
-fn mod_active_keeps_push_recall() {
-    let (dir, _task_id) = seed_axum_rejection();
+fn plugin_hooks_keep_session_start_and_model_switch_and_never_queue() {
+    for env in [NEW_MOD, &[]] {
+        for kind in ["SessionStart", "PostModelSwitch"] {
+            assert!(hook_leaves_a_trace(kind, env, true), "{kind}, {env:?}");
+        }
+        for kind in CAPTURE_KINDS {
+            assert!(!hook_leaves_a_trace(kind, env, true), "{kind}, {env:?}");
+        }
+    }
+}
+
+/// Push-recall is the plugin hook's job under the mod: a tool call that
+/// clearly touches a prior rejection of the session's task gets it, as
+/// additionalContext for any tool, and nothing is queued.
+#[test]
+fn plugin_hooks_keep_push_recall_under_the_mod() {
+    let (dir, task_id) = seed_axum_rejection();
 
-    for tool in ["Bash", "mcp__x__do"] {
+    for (tool, sid) in [("Bash", "s-bash"), ("mcp__x__do", "s-mcp")] {
+        join_session(dir.path(), &task_id, sid);
         let payload = serde_json::json!({
             "hook_event_name": "PostToolUse",
+            "session_id": sid,
             "tool_name": tool,
-            "tool_input": { "command": "let's switch the server to axum" },
+            "tool_input": { "command": AXUM },
             "tool_response": { "output": "" }
         });
         let out = Command::cargo_bin("task-journal")
@@ -2494,7 +2592,8 @@ fn mod_active_keeps_push_recall() {
             .env("XDG_DATA_HOME", dir.path())
             .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
             .env("TJ_MOD_ACTIVE", "1")
-            .args(["ingest-hook", "--backend", "heuristic"])
+            .env("TJ_PLUGIN_HOOKS", "1")
+            .args(["ingest-hook", "--from-plugin", "--backend", "heuristic"])
             .write_stdin(payload.to_string())
             .assert()
             .success()
@@ -2503,6 +2602,7 @@ fn mod_active_keeps_push_recall() {
             .clone();
         let out = String::from_utf8(out).unwrap();
         assert!(out.contains("previously rejected"), "{tool}: {out}");
+        assert!(out.contains("additionalContext"), "{tool}: {out}");
     }
 
     let pending = std::fs::read_dir(dir.path().join("task-journal").join("pending"))
@@ -2511,42 +2611,6 @@ fn mod_active_keeps_push_recall() {
     assert_eq!(pending, 0, "the mod queues tool calls itself");
 }
 
-/// `/rewind` is the user rolling back a path — the mod doesn't record that,
-/// so the correction event still lands.
-#[test]
-fn mod_active_keeps_the_rewind_correction() {
-    let xdg = assert_fs::TempDir::new().unwrap();
-    let proj = assert_fs::TempDir::new().unwrap();
-    let hash = tj_core::project_hash::from_path(proj.path()).unwrap();
-    Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", xdg.path())
-        .current_dir(proj.path())
-        .args(["create", "Rewind host"])
-        .assert()
-        .success();
-
-    Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", xdg.path())
-        .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
-        .env("TJ_MOD_ACTIVE", "1")
-        .current_dir(proj.path())
-        .args(["ingest-hook", "--backend", "heuristic"])
-        .write_stdin(
-            serde_json::json!({
-                "hook_event_name": "UserPromptSubmit",
-                "prompt": "/rewind go back to plan A",
-            })
-            .to_string(),
-        )
-        .assert()
-        .success();
-
-    let journal = project_events(xdg.path(), &hash);
-    assert_eq!(session_ids_of(&journal, "correction").len(), 1, "{journal}");
-}
-
 #[test]
 fn mod_active_silences_the_nudge() {
     for (mod_value, silent) in [(Some("1"), true), (Some("0"), false), (None, false)] {
@@ -2644,7 +2708,7 @@ fn ingest_hook_writes_telemetry_record() {
 }
 
 #[test]
-fn ingest_hook_session_start_emits_resume_pack_json() {
+fn ingest_hook_session_start_names_the_task_in_json() {
     let dir = assert_fs::TempDir::new().unwrap();
     let task_id = String::from_utf8(
         Command::cargo_bin("task-journal")
@@ -2705,10 +2769,8 @@ fn ingest_hook_session_start_emits_resume_pack_json() {
         ctx.contains("Wire SessionStart pack"),
         "additionalContext must include task title: {ctx}"
     );
-    assert!(
-        ctx.contains("Adopt Rust"),
-        "additionalContext must include event text: {ctx}"
-    );
+    // The decisions themselves are on request (task_pack), not at every start.
+    assert!(!ctx.contains("Adopt Rust"), "{ctx}");
     // 0.14.3: sessionTitle / initialUserMessage are no longer emitted —
     // they overrode Claude Code's native session name and seeded garbage
     // task titles. The resume context rides in additionalContext alone.
@@ -3282,13 +3344,13 @@ fn ingest_hook_reads_post_tool_use_payload_from_stdin() {
         .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")));
+    // A raw tool call stays out of packs, so read the journal itself.
+    let hash = tj_core::project_hash::from_path(std::env::current_dir().unwrap()).unwrap();
+    let journal = project_events(dir.path(), &hash);
+    assert!(
+        journal.contains("Bash") && journal.contains("cargo test"),
+        "{journal}"
+    );
 }
 
 #[test]
@@ -3300,10 +3362,10 @@ fn install_hooks_writes_command_without_bogus_env_var_interpolation() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user"])
+        .args(["install-hooks", "--scope", "user", "--client", "codex"])
         .assert()
         .success();
-    let s = std::fs::read_to_string(dir.path().join(".claude/settings.json")).unwrap();
+    let s = std::fs::read_to_string(dir.path().join(".codex/hooks.json")).unwrap();
     assert!(
         !s.contains("$CLAUDE_HOOK_NAME") && !s.contains("$CLAUDE_HOOK_TEXT"),
         "install-hooks must not interpolate non-existent env vars: {s}"
@@ -5175,10 +5237,17 @@ fn install_hooks_wires_precompact_event() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user", "--auto-capture"])
+        .args([
+            "install-hooks",
+            "--scope",
+            "user",
+            "--client",
+            "codex",
+            "--auto-capture",
+        ])
         .assert()
         .success();
-    let s = std::fs::read_to_string(dir.path().join(".claude/settings.json")).unwrap();
+    let s = std::fs::read_to_string(dir.path().join(".codex/hooks.json")).unwrap();
     assert!(
         s.contains("PreCompact"),
         "settings.json must wire PreCompact under --auto-capture: {s}"
@@ -6333,11 +6402,14 @@ fn list_tree_indents_children_under_parents() {
     );
 }
 
-// --- Push-recall (claude-memory-60m) -----------------------------------
+// --- Push-recall (claude-memory-60m / 7km) -----------------------------
 
-/// Seed a confirmed rejection mentioning `axum` on a fresh task, returning
-/// the (TempDir, task_id). Mirrors the SessionStart-test seeding: `create`
-/// + `event --type rejection`.
+/// A tool call that clearly touches the seeded rejection: it shares
+/// "switch", "server" and "axum" with it.
+const AXUM: &str = "switch the server to axum";
+
+/// Seed a confirmed rejection about axum on a fresh task, recorded outside
+/// any session (an earlier one), returning the (TempDir, task_id).
 fn seed_axum_rejection() -> (assert_fs::TempDir, String) {
     let dir = assert_fs::TempDir::new().unwrap();
     let task_id = String::from_utf8(
@@ -6364,75 +6436,42 @@ fn seed_axum_rejection() -> (assert_fs::TempDir, String) {
             "--type",
             "rejection",
             "--text",
-            "Tried switching the server to axum but it broke rmcp stdio.",
+            "Tried to switch the server to axum but it broke rmcp stdio.",
         ])
         .assert()
         .success();
     (dir, task_id)
 }
 
-#[test]
-fn post_tool_use_emits_recall_additional_context() {
-    let (dir, task_id) = seed_axum_rejection();
-
-    let payload = serde_json::json!({
-        "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
-        "tool_name": "Bash",
-        "tool_input": { "command": "let's switch the server to axum" },
-        "tool_response": { "output": "" }
-    })
-    .to_string();
-
-    let out = Command::cargo_bin("task-journal")
+/// Session `sid` records a finding on `task_id`, which makes it the
+/// session's active task.
+fn join_session(dir: &std::path::Path, task_id: &str, sid: &str) {
+    Command::cargo_bin("task-journal")
         .unwrap()
-        .env("XDG_DATA_HOME", dir.path())
+        .env("XDG_DATA_HOME", dir)
         .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
+            "event",
+            task_id,
+            "--type",
             "finding",
-            "--mock-task-id",
-            &task_id,
-            "--mock-confidence",
-            "0.9",
+            "--text",
+            "Picked the task up again.",
+            "--session",
+            sid,
         ])
-        .write_stdin(payload)
         .assert()
-        .success()
-        .get_output()
-        .stdout
-        .clone();
-    let body = String::from_utf8(out).unwrap();
-
-    // The recall envelope is one of possibly several stdout lines (the
-    // mock path also prints the new event_id). Find the JSON line.
-    let env_line = body
-        .lines()
-        .find(|l| l.contains("additionalContext"))
-        .unwrap_or_else(|| panic!("no recall envelope on stdout, got: {body:?}"));
-    let v: serde_json::Value = serde_json::from_str(env_line.trim()).unwrap();
-    let ctx = v
-        .get("hookSpecificOutput")
-        .and_then(|h| h.get("additionalContext"))
-        .and_then(|s| s.as_str())
-        .expect("additionalContext missing");
-    assert!(ctx.contains("⚠ recall"), "ctx: {ctx}");
-    assert!(ctx.contains("axum"), "ctx: {ctx}");
-    assert_eq!(
-        v.get("hookSpecificOutput")
-            .and_then(|h| h.get("hookEventName"))
-            .and_then(|s| s.as_str()),
-        Some("PostToolUse"),
-    );
+        .success();
 }
 
 /// One real (non-mock) PostToolUse hook run; `session: None` sends no
-/// session id at all. Returns stdout.
-fn post_tool_use(dir: &std::path::Path, session: Option<&str>, tool: &str, input: &str) -> String {
+/// session id at all. Returns stdout. `TJ_RECALL_EVERY=0` unless `paced`.
+fn post_tool_use_paced(
+    dir: &std::path::Path,
+    session: Option<&str>,
+    tool: &str,
+    input: &str,
+    paced: bool,
+) -> String {
     let mut payload = serde_json::json!({
         "hook_event_name": "PostToolUse",
         "tool_name": tool,
@@ -6443,10 +6482,13 @@ fn post_tool_use(dir: &std::path::Path, session: Option<&str>, tool: &str, input
         payload["session_id"] = sid.into();
     }
 
-    let out = Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", dir)
-        .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
+    let mut cmd = Command::cargo_bin("task-journal").unwrap();
+    cmd.env("XDG_DATA_HOME", dir)
+        .env("TJ_DISABLE_CLASSIFY_SPAWN", "1");
+    if !paced {
+        cmd.env("TJ_RECALL_EVERY", "0");
+    }
+    let out = cmd
         .args(["ingest-hook", "--backend", "heuristic"])
         .write_stdin(payload.to_string())
         .assert()
@@ -6457,46 +6499,68 @@ fn post_tool_use(dir: &std::path::Path, session: Option<&str>, tool: &str, input
     String::from_utf8(out).unwrap()
 }
 
-/// After every tool call the same hits used to come back, flooding the
-/// agent's context. A session sees each hit once, on either recall path.
+fn post_tool_use(dir: &std::path::Path, session: Option<&str>, tool: &str, input: &str) -> String {
+    post_tool_use_paced(dir, session, tool, input, false)
+}
+
 #[test]
-fn push_recall_shows_each_hit_once_per_session() {
-    let (dir, _task_id) = seed_axum_rejection();
-    let axum = "let's switch the server to axum";
+fn post_tool_use_emits_recall_additional_context() {
+    let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-recall");
 
-    let first = post_tool_use(dir.path(), Some("s-a"), "Bash", axum);
-    assert!(first.contains("⚠ recall"), "{first}");
+    let out = post_tool_use(dir.path(), Some("s-recall"), "Bash", AXUM);
+    let env_line = out
+        .lines()
+        .find(|l| l.contains("additionalContext"))
+        .unwrap_or_else(|| panic!("no recall envelope on stdout, got: {out:?}"));
+    let v: serde_json::Value = serde_json::from_str(env_line.trim()).unwrap();
+    let ctx = v["hookSpecificOutput"]["additionalContext"]
+        .as_str()
+        .unwrap();
+    assert!(ctx.contains("⚠ recall"), "ctx: {ctx}");
+    assert!(ctx.contains("axum"), "ctx: {ctx}");
+    assert_eq!(v["hookSpecificOutput"]["hookEventName"], "PostToolUse");
+}
 
-    let again = post_tool_use(dir.path(), Some("s-a"), "Bash", axum);
-    assert!(!again.contains("recall"), "{again}");
-    let via_mcp = post_tool_use(dir.path(), Some("s-a"), "mcp__x__do", axum);
-    assert!(!via_mcp.contains("recall"), "{via_mcp}");
+/// An MCP tool gets the same additionalContext: the hook runs async, and an
+/// async updatedMCPToolOutput never reached the model.
+#[test]
+fn post_tool_use_recall_for_an_mcp_tool_is_additional_context() {
+    let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-mcp");
 
-    let other = post_tool_use(dir.path(), Some("s-b"), "Bash", axum);
-    assert!(other.contains("⚠ recall"), "{other}");
+    let out = post_tool_use(
+        dir.path(),
+        Some("s-mcp"),
+        "mcp__some-server__do_thing",
+        AXUM,
+    );
+    assert!(
+        out.contains("additionalContext") && out.contains("axum"),
+        "{out}"
+    );
+    assert!(!out.contains("updatedMCPToolOutput"), "{out}");
 }
 
+/// Recall belongs to the work at hand: no session id, or a session with no
+/// journal task, gets nothing — however well the call matches.
 #[test]
-fn push_recall_without_a_session_id_repeats_as_before() {
+fn push_recall_needs_a_session_with_an_active_task() {
     let (dir, _task_id) = seed_axum_rejection();
-    let axum = "let's switch the server to axum";
 
-    for _ in 0..2 {
-        let out = post_tool_use(dir.path(), None, "Bash", axum);
-        assert!(out.contains("⚠ recall"), "{out}");
-    }
+    assert!(!post_tool_use(dir.path(), None, "Bash", AXUM).contains("recall"));
+    assert!(!post_tool_use(dir.path(), Some("s-idle"), "Bash", AXUM).contains("recall"));
 }
 
-/// The agent just wrote that rejection on its own task in this session —
-/// echoing it back is noise. Another session still gets it.
+/// A rejection of another task stays out unless the two share a module.
 #[test]
-fn push_recall_skips_what_this_session_wrote_on_its_task() {
-    let dir = assert_fs::TempDir::new().unwrap();
-    let task_id = String::from_utf8(
+fn push_recall_skips_other_tasks() {
+    let (dir, _axum_task) = seed_axum_rejection();
+    let other = String::from_utf8(
         Command::cargo_bin("task-journal")
             .unwrap()
             .env("XDG_DATA_HOME", dir.path())
-            .args(["create", "Own session host"])
+            .args(["create", "Unrelated work"])
             .assert()
             .success()
             .get_output()
@@ -6506,265 +6570,157 @@ fn push_recall_skips_what_this_session_wrote_on_its_task() {
     .unwrap()
     .trim()
     .to_string();
-    let payload = serde_json::json!({
-        "hook_event_name": "UserPromptSubmit",
-        "session_id": "s-own",
-        "prompt": "Tried switching the server to axum but it broke rmcp stdio."
-    });
-    Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", dir.path())
-        .args([
-            "ingest-hook",
-            "--mock-event-type",
-            "rejection",
-            "--mock-task-id",
-            &task_id,
-        ])
-        .write_stdin(payload.to_string())
-        .assert()
-        .success();
-    let axum = "let's switch the server to axum";
+    join_session(dir.path(), &other, "s-other-task");
 
-    let own = post_tool_use(dir.path(), Some("s-own"), "Bash", axum);
-    assert!(!own.contains("recall"), "{own}");
-
-    let other = post_tool_use(dir.path(), Some("s-other"), "Bash", axum);
-    assert!(other.contains("⚠ recall"), "{other}");
+    let out = post_tool_use(dir.path(), Some("s-other-task"), "Bash", AXUM);
+    assert!(!out.contains("recall"), "{out}");
 }
 
+/// One or two shared words are not a match: "server" alone used to recall
+/// rejections from anywhere in the project.
 #[test]
-fn post_tool_use_no_recall_when_no_match() {
+fn push_recall_needs_a_strong_match() {
     let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-weak");
 
-    let payload = serde_json::json!({
-        "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
-        "tool_name": "Bash",
-        "tool_input": { "command": "update the frontend stylesheet colors" },
-        "tool_response": { "output": "" }
-    })
-    .to_string();
-
-    let out = Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", dir.path())
-        .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
-            "finding",
-            "--mock-task-id",
-            &task_id,
-            "--mock-confidence",
-            "0.9",
-        ])
-        .write_stdin(payload)
-        .assert()
-        .success()
-        .get_output()
-        .stdout
-        .clone();
-    let body = String::from_utf8(out).unwrap();
-    assert!(
-        !body.contains("additionalContext"),
-        "must not emit recall envelope for a non-matching tool turn, got: {body:?}"
+    let out = post_tool_use(
+        dir.path(),
+        Some("s-weak"),
+        "Bash",
+        "restart the axum server",
     );
+    assert!(!out.contains("recall"), "{out}");
 }
 
+/// After every tool call the same hits used to come back, flooding the
+/// agent's context. A session sees each hit once.
 #[test]
-fn tj_push_recall_env_disables() {
+fn push_recall_shows_each_hit_once_per_session() {
     let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-a");
+    join_session(dir.path(), &task_id, "s-b");
 
-    let payload = serde_json::json!({
-        "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
-        "tool_name": "Bash",
-        "tool_input": { "command": "let's switch the server to axum" },
-        "tool_response": { "output": "" }
-    })
-    .to_string();
+    let first = post_tool_use(dir.path(), Some("s-a"), "Bash", AXUM);
+    assert!(first.contains("⚠ recall"), "{first}");
 
-    let out = Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", dir.path())
-        .env("TJ_PUSH_RECALL", "0")
-        .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
-            "finding",
-            "--mock-task-id",
-            &task_id,
-            "--mock-confidence",
-            "0.9",
-        ])
-        .write_stdin(payload)
-        .assert()
-        .success()
-        .get_output()
-        .stdout
-        .clone();
-    let body = String::from_utf8(out).unwrap();
-    assert!(
-        !body.contains("additionalContext"),
-        "TJ_PUSH_RECALL=0 must suppress the recall envelope, got: {body:?}"
-    );
+    let again = post_tool_use(dir.path(), Some("s-a"), "Bash", AXUM);
+    assert!(!again.contains("recall"), "{again}");
+    let via_mcp = post_tool_use(dir.path(), Some("s-a"), "mcp__x__do", AXUM);
+    assert!(!via_mcp.contains("recall"), "{via_mcp}");
+
+    let other = post_tool_use(dir.path(), Some("s-b"), "Bash", AXUM);
+    assert!(other.contains("⚠ recall"), "{other}");
 }
 
+/// No more than one recall per ten tool calls of a session.
 #[test]
-fn post_tool_use_skips_recall_for_mcp_tools() {
-    // Dedup gate vs claude-memory-7km: mcp__ tool turns are 7km's territory
-    // (updatedMCPToolOutput). This path must stay silent for them.
+fn push_recall_waits_ten_calls_between_two_recalls() {
     let (dir, task_id) = seed_axum_rejection();
-
-    let payload = serde_json::json!({
-        "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
-        "tool_name": "mcp__task-journal__task_search",
-        "tool_input": { "query": "let's switch the server to axum" },
-        "tool_response": { "output": "" }
-    })
-    .to_string();
-
-    let out = Command::cargo_bin("task-journal")
+    Command::cargo_bin("task-journal")
         .unwrap()
         .env("XDG_DATA_HOME", dir.path())
         .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
-            "finding",
-            "--mock-task-id",
+            "event",
             &task_id,
-            "--mock-confidence",
-            "0.9",
+            "--type",
+            "rejection",
+            "--text",
+            "Rejected the warp server too: switch to axum was the plan, warp broke stdio as well.",
         ])
-        .write_stdin(payload)
         .assert()
-        .success()
-        .get_output()
-        .stdout
-        .clone();
-    let body = String::from_utf8(out).unwrap();
+        .success();
+    join_session(dir.path(), &task_id, "s-pace");
+
+    let shown = (0..11)
+        .map(|_| post_tool_use_paced(dir.path(), Some("s-pace"), "Bash", AXUM, true))
+        .map(|out| out.contains("⚠ recall"))
+        .collect::<Vec<_>>();
+    assert!(shown[0], "the first call may recall");
+    assert!(shown[1..10].iter().all(|s| !s), "{shown:?}");
     assert!(
-        !body.contains("additionalContext"),
-        "mcp__ tool turns must not emit a recall envelope (7km owns them), got: {body:?}"
+        shown[10],
+        "the eleventh call may recall the other one: {shown:?}"
     );
 }
 
-// --- Push-recall via updatedMCPToolOutput (claude-memory-7km) ----------
-
+/// The agent just wrote that rejection on its own task in this session —
+/// echoing it back is noise. Another session still gets it.
 #[test]
-fn post_tool_use_mcp_prepends_recall_banner() {
-    // An MCP tool call whose input echoes a prior rejection must have a recall
-    // banner PREPENDED to what Claude sees of its output, with the real output
-    // preserved below the banner (7km's updatedMCPToolOutput path).
-    let (dir, task_id) = seed_axum_rejection();
-
-    let payload = serde_json::json!({
-        "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
-        "tool_name": "mcp__some-server__do_thing",
-        "tool_input": { "approach": "let's switch the server to axum" },
-        "tool_response": { "output": "REAL TOOL OUTPUT 12345" }
-    })
+fn push_recall_skips_what_this_session_wrote_on_its_task() {
+    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", "Own session host"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
     .to_string();
-
-    let out = Command::cargo_bin("task-journal")
+    Command::cargo_bin("task-journal")
         .unwrap()
         .env("XDG_DATA_HOME", dir.path())
         .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
-            "finding",
-            "--mock-task-id",
+            "event",
             &task_id,
-            "--mock-confidence",
-            "0.9",
+            "--type",
+            "rejection",
+            "--text",
+            "Tried to switch the server to axum but it broke rmcp stdio.",
+            "--session",
+            "s-own",
         ])
-        .write_stdin(payload)
         .assert()
-        .success()
-        .get_output()
-        .stdout
-        .clone();
-    let body = String::from_utf8(out).unwrap();
+        .success();
+    join_session(dir.path(), &task_id, "s-other");
 
-    let env_line = body
-        .lines()
-        .find(|l| l.contains("updatedMCPToolOutput"))
-        .unwrap_or_else(|| panic!("no updatedMCPToolOutput envelope on stdout, got: {body:?}"));
-    let v: serde_json::Value = serde_json::from_str(env_line.trim()).unwrap();
-    let updated = v
-        .get("hookSpecificOutput")
-        .and_then(|h| h.get("updatedMCPToolOutput"))
-        .and_then(|s| s.as_str())
-        .expect("updatedMCPToolOutput missing");
-    assert!(
-        updated.starts_with('\u{26a0}'),
-        "must start with banner: {updated}"
-    );
-    assert!(
-        updated.contains("axum"),
-        "banner must mention the recall: {updated}"
-    );
-    assert!(
-        updated.contains("REAL TOOL OUTPUT 12345"),
-        "original tool output must be preserved: {updated}"
-    );
-    assert_eq!(
-        v.get("hookSpecificOutput")
-            .and_then(|h| h.get("hookEventName"))
-            .and_then(|s| s.as_str()),
-        Some("PostToolUse"),
-    );
+    let own = post_tool_use(dir.path(), Some("s-own"), "Bash", AXUM);
+    assert!(!own.contains("recall"), "{own}");
+
+    let other = post_tool_use(dir.path(), Some("s-other"), "Bash", AXUM);
+    assert!(other.contains("⚠ recall"), "{other}");
+}
+
+/// The journal's own tools never get recall: their output is the journal.
+#[test]
+fn post_tool_use_skips_recall_for_the_journals_own_tools() {
+    let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-own-tools");
+
+    for tool in [
+        "mcp__task-journal__task_search",
+        "mcp__plugin_task-journal_task-journal__event_add",
+    ] {
+        let out = post_tool_use(dir.path(), Some("s-own-tools"), tool, AXUM);
+        assert!(!out.contains("recall"), "{tool}: {out}");
+    }
 }
 
 #[test]
-fn post_tool_use_non_mcp_tool_emits_no_mcp_output() {
-    // The 7km path is MCP-only: a non-MCP tool (Bash) must never emit
-    // updatedMCPToolOutput, even when its input echoes a rejection.
+fn tj_push_recall_env_disables() {
     let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-off");
 
     let payload = serde_json::json!({
         "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
+        "session_id": "s-off",
         "tool_name": "Bash",
-        "tool_input": { "command": "let's switch the server to axum" },
-        "tool_response": { "output": "REAL TOOL OUTPUT 12345" }
+        "tool_input": { "command": AXUM },
+        "tool_response": { "output": "" }
     })
     .to_string();
-
     let out = Command::cargo_bin("task-journal")
         .unwrap()
         .env("XDG_DATA_HOME", dir.path())
-        .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
-            "finding",
-            "--mock-task-id",
-            &task_id,
-            "--mock-confidence",
-            "0.9",
-        ])
+        .env("TJ_PUSH_RECALL", "0")
+        .env("TJ_RECALL_EVERY", "0")
+        .env("TJ_DISABLE_CLASSIFY_SPAWN", "1")
+        .args(["ingest-hook", "--backend", "heuristic"])
         .write_stdin(payload)
         .assert()
         .success()
@@ -6773,23 +6729,23 @@ fn post_tool_use_non_mcp_tool_emits_no_mcp_output() {
         .clone();
     let body = String::from_utf8(out).unwrap();
     assert!(
-        !body.contains("updatedMCPToolOutput"),
-        "non-MCP tool turns must not emit updatedMCPToolOutput, got: {body:?}"
+        !body.contains("additionalContext"),
+        "TJ_PUSH_RECALL=0 must suppress the recall envelope, got: {body:?}"
     );
 }
 
 #[test]
-fn post_tool_use_mcp_no_recall_passes_through() {
-    // MCP tool, but its input matches no rejection: emit nothing, pass through.
+fn push_recall_does_not_drop_capture() {
+    // The push-recall block falls through to the normal capture path: the
+    // tool call is still ingested (the mock path writes it as an event).
     let (dir, task_id) = seed_axum_rejection();
+    join_session(dir.path(), &task_id, "s-recall");
 
     let payload = serde_json::json!({
         "hook_event_name": "PostToolUse",
         "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
         "tool_name": "mcp__some-server__do_thing",
-        "tool_input": { "approach": "update the frontend stylesheet colors" },
+        "tool_input": { "approach": AXUM },
         "tool_response": { "output": "REAL TOOL OUTPUT 12345" }
     })
     .to_string();
@@ -6797,6 +6753,7 @@ fn post_tool_use_mcp_no_recall_passes_through() {
     let out = Command::cargo_bin("task-journal")
         .unwrap()
         .env("XDG_DATA_HOME", dir.path())
+        .env("TJ_RECALL_EVERY", "0")
         .args([
             "ingest-hook",
             "--backend",
@@ -6814,66 +6771,14 @@ fn post_tool_use_mcp_no_recall_passes_through() {
         .get_output()
         .stdout
         .clone();
-    let body = String::from_utf8(out).unwrap();
-    assert!(
-        !body.contains("updatedMCPToolOutput"),
-        "no-hit MCP turn must pass through (no envelope), got: {body:?}"
-    );
-}
-
-#[test]
-fn push_recall_mcp_does_not_drop_capture() {
-    // The push-recall block must fall through to the normal capture path:
-    // the MCP tool call is still ingested as an event (mock path emits the
-    // new event_id on stdout).
-    let (dir, task_id) = seed_axum_rejection();
-
-    let payload = serde_json::json!({
-        "hook_event_name": "PostToolUse",
-        "session_id": "s-recall",
-        "transcript_path": "/tmp/x",
-        "cwd": "/tmp",
-        "tool_name": "mcp__some-server__do_thing",
-        "tool_input": { "approach": "let's switch the server to axum" },
-        "tool_response": { "output": "REAL TOOL OUTPUT 12345" }
-    })
-    .to_string();
-
-    Command::cargo_bin("task-journal")
-        .unwrap()
-        .env("XDG_DATA_HOME", dir.path())
-        .args([
-            "ingest-hook",
-            "--backend",
-            "cli",
-            "--mock-event-type",
-            "finding",
-            "--mock-task-id",
-            &task_id,
-            "--mock-confidence",
-            "0.9",
-        ])
-        .write_stdin(payload)
-        .assert()
-        .success();
+    let out = String::from_utf8(out).unwrap();
+    assert!(out.contains("⚠ recall"), "{out}");
 
-    // The captured finding lands in the task pack — capture is unaffected by
-    // the push-recall envelope.
-    let pack = String::from_utf8(
-        Command::cargo_bin("task-journal")
-            .unwrap()
-            .env("XDG_DATA_HOME", dir.path())
-            .args(["pack", &task_id, "--mode", "full"])
-            .assert()
-            .success()
-            .get_output()
-            .stdout
-            .clone(),
-    )
-    .unwrap();
+    let hash = tj_core::project_hash::from_path(std::env::current_dir().unwrap()).unwrap();
+    let journal = project_events(dir.path(), &hash);
     assert!(
-        pack.contains("do_thing"),
-        "MCP tool call must still be captured into the journal, pack: {pack}"
+        journal.contains("do_thing"),
+        "the MCP tool call must still be captured into the journal: {journal}"
     );
 }
 
@@ -6948,82 +6853,128 @@ fn session_start_additional_context_with(extra: serde_json::Value) -> String {
         .to_string()
 }
 
+/// The session start says one thing: which open task this session most
+/// likely continues, and how to resume it. Packs, honesty scores, artifact
+/// lists and constraints are on request — three packs on every start were
+/// thousands of tokens, mostly about other work.
 #[test]
-fn session_start_compact_prepends_active_task_reminder() {
-    let ctx = session_start_additional_context("compact");
-    assert!(
-        ctx.starts_with("[Active task after compaction]"),
-        "compact SessionStart must lead with the reminder: {ctx}"
-    );
-    assert!(
-        ctx.contains("Ship the widget"),
-        "reminder must include the task title: {ctx}"
-    );
-    assert!(
-        ctx.contains("Goal: Ship the dashboard widget"),
-        "reminder must include the goal: {ctx}"
-    );
-    assert!(
-        ctx.contains("Must ship before Friday"),
-        "reminder must include the in-force constraint: {ctx}"
-    );
-    assert!(
-        ctx.contains("task-journal-distiller"),
-        "compact SessionStart must advise delegating to the distiller subagent: {ctx}"
-    );
-}
-
-/// A conversation picked up the next day keeps its transcript, but what it was
-/// doing is no longer fresh — re-inject the active task. Claude Code 2.1.251+
-/// reports the gap in `seconds_since_last_response` on `resume` and `fork`.
-#[test]
-fn session_start_reinjects_active_task_after_a_long_idle_gap() {
-    for source in ["resume", "fork"] {
-        let ctx = session_start_additional_context_with(serde_json::json!({
-            "source": source,
-            "seconds_since_last_response": 32_400, // 9h
-            "prompt_cache_likely_expired": true,
-        }));
-        assert!(
-            ctx.starts_with("[Active task, idle for 9h]"),
-            "{source} after a long gap must lead with the reminder: {ctx}"
-        );
-        assert!(
-            ctx.contains("Must ship before Friday"),
-            "reminder must carry the in-force constraint: {ctx}"
-        );
-        assert!(
-            !ctx.contains("task-journal-distiller"),
-            "no compaction happened, so no distiller advice: {ctx}"
-        );
+fn session_start_is_one_line_about_the_task() {
+    let ctx = session_start_additional_context("startup");
+    assert!(!ctx.contains('\n'), "one line: {ctx}");
+    assert!(ctx.contains("\"Ship the widget\""), "{ctx}");
+    assert!(ctx.contains("goal: Ship the dashboard widget"), "{ctx}");
+    assert!(ctx.contains("task_pack(\"tj-"), "{ctx}");
+    for noise in [
+        "honesty",
+        "Completeness",
+        "Must ship before Friday",
+        "Chronicle",
+        "distiller",
+    ] {
+        assert!(!ctx.contains(noise), "{noise}: {ctx}");
     }
 }
 
-/// A session resumed minutes later still has everything in context — the
-/// reminder would just be noise.
+/// After a compaction without the mod, the line comes with the distiller
+/// advice; the mod catches up on its own.
 #[test]
-fn session_start_resume_after_short_gap_has_no_reminder() {
-    let ctx = session_start_additional_context_with(serde_json::json!({
-        "source": "resume",
-        "seconds_since_last_response": 120,
-    }));
-    assert!(
-        !ctx.contains("[Active task"),
-        "a fresh resume must NOT inject the reminder: {ctx}"
-    );
+fn session_start_after_compaction_points_at_the_distiller() {
+    let ctx = session_start_additional_context("compact");
+    assert!(ctx.contains("\"Ship the widget\""), "{ctx}");
+    assert!(ctx.contains("task-journal-distiller"), "{ctx}");
 }
 
+/// A session that already wrote to a task (a resume, a compaction) gets that
+/// task, not the folder's latest; a new one gets the task its branch names.
 #[test]
-fn session_start_startup_has_no_reminder() {
-    let ctx = session_start_additional_context("startup");
-    assert!(
-        !ctx.contains("[Active task after compaction]"),
-        "non-compact SessionStart must NOT inject the reminder: {ctx}"
-    );
+fn session_start_names_the_sessions_own_task_then_the_branchs() {
+    let xdg = assert_fs::TempDir::new().unwrap();
+    let proj = assert_fs::TempDir::new().unwrap();
+    std::fs::create_dir_all(proj.path().join(".git")).unwrap();
+    std::fs::write(
+        proj.path().join(".git").join("HEAD"),
+        "ref: refs/heads/feat/DEV-4621-write\n",
+    )
+    .unwrap();
+    let create = |title: &str| {
+        String::from_utf8(
+            Command::cargo_bin("task-journal")
+                .unwrap()
+                .env("XDG_DATA_HOME", xdg.path())
+                .current_dir(proj.path())
+                .args(["create", title])
+                .assert()
+                .success()
+                .get_output()
+                .stdout
+                .clone(),
+        )
+        .unwrap()
+        .trim()
+        .to_string()
+    };
+    let issue_task = create("DEV-4621: move the write path");
+    let resumed = create("Fix the login redirect");
+    let latest = create("Tidy the README");
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", xdg.path())
+        .current_dir(proj.path())
+        .args([
+            "event",
+            &resumed,
+            "--type",
+            "finding",
+            "--text",
+            "Redirect loses ?next.",
+            "--session",
+            "s-old",
+        ])
+        .assert()
+        .success();
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", xdg.path())
+        .current_dir(proj.path())
+        .args([
+            "event",
+            &latest,
+            "--type",
+            "finding",
+            "--text",
+            "README is stale.",
+        ])
+        .assert()
+        .success();
+
+    let start = |sid: &str| -> String {
+        let out = Command::cargo_bin("task-journal")
+            .unwrap()
+            .env("XDG_DATA_HOME", xdg.path())
+            .current_dir(proj.path())
+            .args(["ingest-hook"])
+            .write_stdin(
+                serde_json::json!({ "hook_event_name": "SessionStart", "session_id": sid })
+                    .to_string(),
+            )
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone();
+        String::from_utf8(out).unwrap()
+    };
+
+    let own = start("s-old");
     assert!(
-        !ctx.contains("task-journal-distiller"),
-        "non-compact SessionStart must NOT advise the distiller: {ctx}"
+        own.contains(&resumed) && own.contains("this session's task"),
+        "{own}"
     );
+    assert!(own.contains("2 more open"), "{own}");
+
+    let new = start("s-new");
+    assert!(new.contains(&issue_task), "{new}");
+    assert!(new.contains("branch feat/DEV-4621-write"), "{new}");
 }
 
 /// Recursively collect file names under `dir` that match a predicate.
@@ -7612,11 +7563,17 @@ fn install_hooks_proactive_recall_wires_recall_hook() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir.path())
-        .args(["install-hooks", "--scope", "user", "--proactive-recall"])
+        .args([
+            "install-hooks",
+            "--scope",
+            "user",
+            "--client",
+            "codex",
+            "--proactive-recall",
+        ])
         .assert()
         .success();
-    let content =
-        std::fs::read_to_string(dir.path().join(".claude").join("settings.json")).unwrap();
+    let content = std::fs::read_to_string(dir.path().join(".codex").join("hooks.json")).unwrap();
     assert!(
         content.contains("task-journal recall-hook"),
         "--proactive-recall must wire the recall-hook; got: {content}"
@@ -7630,10 +7587,10 @@ fn install_hooks_proactive_recall_wires_recall_hook() {
     Command::cargo_bin("task-journal")
         .unwrap()
         .env("HOME", dir2.path())
-        .args(["install-hooks", "--scope", "user"])
+        .args(["install-hooks", "--scope", "user", "--client", "codex"])
         .assert()
         .success();
-    let c2 = std::fs::read_to_string(dir2.path().join(".claude").join("settings.json")).unwrap();
+    let c2 = std::fs::read_to_string(dir2.path().join(".codex").join("hooks.json")).unwrap();
     assert!(
         !c2.contains("recall-hook"),
         "default install must not wire proactive recall"
@@ -8744,8 +8701,10 @@ fn unknown_module_and_bad_slug_fail_before_writing() {
     );
 }
 
+/// The chronicle's gaps are on request (module_list, `task-journal state`),
+/// not a line at every session start.
 #[test]
-fn session_start_names_the_top_chronicle_gap() {
+fn session_start_leaves_the_chronicle_gaps_out() {
     let (xdg, proj) = (
         assert_fs::TempDir::new().unwrap(),
         assert_fs::TempDir::new().unwrap(),
@@ -8760,7 +8719,8 @@ fn session_start_names_the_top_chronicle_gap() {
         .as_str()
         .unwrap();
 
-    assert!(ctx.contains("📚 Chronicle: no module map yet"), "{ctx}");
+    assert!(ctx.contains("Some work"), "{ctx}");
+    assert!(!ctx.contains("Chronicle"), "{ctx}");
 }
 
 #[test]
@@ -8874,10 +8834,9 @@ fn a_worktree_shares_the_main_checkouts_module_map() {
         .stdout(contains(id.as_str()).not());
 }
 
+/// No open task: nothing to resume, and the chronicle waits to be asked.
 #[test]
-fn session_start_names_the_chronicle_gap_with_no_open_task() {
-    // A project whose tasks are all closed has no resume pack to show, yet
-    // the chronicle still has something to say.
+fn session_start_with_only_closed_tasks_says_nothing() {
     let (xdg, proj) = (
         assert_fs::TempDir::new().unwrap(),
         assert_fs::TempDir::new().unwrap(),
@@ -8892,10 +8851,5 @@ fn session_start_names_the_chronicle_gap_with_no_open_task() {
 
     let mut hook = tj();
     hook.args(["ingest-hook", "--kind", "SessionStart", "--text", ""]);
-    let out: serde_json::Value = serde_json::from_str(&stdout_of(hook)).unwrap();
-    let ctx = out["hookSpecificOutput"]["additionalContext"]
-        .as_str()
-        .unwrap_or("");
-
-    assert!(ctx.contains("📚 Chronicle: no module map yet"), "{out}");
+    assert_eq!(stdout_of(hook), "");
 }
diff --git a/crates/tj-core/src/classifier/heuristic.rs b/crates/tj-core/src/classifier/heuristic.rs
index 6861f5e..4910944 100644
--- a/crates/tj-core/src/classifier/heuristic.rs
+++ b/crates/tj-core/src/classifier/heuristic.rs
@@ -30,6 +30,19 @@ pub fn try_heuristic(input: &ClassifyInput) -> Option<ClassifyOutput> {
     let lower = text.to_lowercase();
     let task_id_guess = input.recent_tasks.first().map(|t| t.task_id.clone());
 
+    // A rejection first, so "tried X, didn't work; we'll use Y" is not a
+    // decision — but only an explicit one, never from tool output.
+    if !input.tool_output && super::is_explicit_rejection(text) {
+        return Some(ClassifyOutput {
+            event_type: EventType::Rejection,
+            task_id_guess,
+            confidence: 0.85,
+            evidence_strength: None,
+            suggested_text: truncate(text, SUGGESTED_TEXT_MAX),
+            artifacts: None,
+        });
+    }
+
     for (patterns, etype, confidence) in RULES {
         // Tool output is JSON and logs full of "must be" / "requires" /
         // "rejected": only a test result is a reliable signal there.
@@ -52,27 +65,9 @@ pub fn try_heuristic(input: &ClassifyInput) -> Option<ClassifyOutput> {
     None
 }
 
-/// Pattern table. Order matters — rejection should test before decision
-/// because "decided to abandon" should land as Rejection, not Decision.
+/// Pattern table, after the rejection check above. Order matters: the first
+/// rule that matches wins.
 const RULES: &[(&[&str], EventType, f64)] = &[
-    // Rejection: explicit abandonment / "this doesn't work".
-    (
-        &[
-            "won't work",
-            "doesn't work",
-            "didn't work",
-            "rejected",
-            "abandoned",
-            "tried but failed",
-            "tried that, didn't",
-            "не работает",
-            "не подходит",
-            "отказались",
-            "отказался",
-        ],
-        EventType::Rejection,
-        0.85,
-    ),
     // Evidence: test outcomes / experiment results.
     (
         &[
@@ -220,6 +215,34 @@ mod tests {
         assert_eq!(out.event_type, EventType::Rejection);
     }
 
+    /// A rejection rules an approach out. A bug report, a log line or a long
+    /// answer that merely says "rejected" / "не работает" is not one.
+    #[test]
+    fn only_an_explicit_rejection_is_a_rejection() {
+        for text in [
+            "Decided against the Redis cache: one more service to run for a 5% gain.",
+            "Отказались от chown -R в Dockerfile: веб-корень становится записываемым.",
+            "Попробовал ленивую загрузку, не работает с SSR — оставляем как было.",
+        ] {
+            let out = try_heuristic(&input(text)).unwrap();
+            assert_eq!(out.event_type, EventType::Rejection, "{text}");
+        }
+
+        let long_answer = format!(
+            "Here is the summary of the release. {} The PR was rejected by CI once.",
+            "Details follow. ".repeat(60)
+        );
+        for text in [
+            "The login page doesn't work after the deploy, looking at logs now.",
+            "Тест падает: страница не работает после деплоя, смотрю логи.",
+            "The upload was rejected 2 files because of their size limits.",
+            long_answer.as_str(),
+        ] {
+            let kind = try_heuristic(&input(text)).map(|o| o.event_type);
+            assert_ne!(kind, Some(EventType::Rejection), "{text}");
+        }
+    }
+
     #[test]
     fn matches_evidence_for_test_results() {
         let out = try_heuristic(&input(
diff --git a/crates/tj-core/src/classifier/mod.rs b/crates/tj-core/src/classifier/mod.rs
index bd22b1e..296d04a 100644
--- a/crates/tj-core/src/classifier/mod.rs
+++ b/crates/tj-core/src/classifier/mod.rs
@@ -59,6 +59,67 @@ pub fn decide_status(confidence: f64) -> EventStatus {
     }
 }
 
+/// The longest a rejection can be: a sentence or two on what was ruled out
+/// and why. A whole answer that happens to say "rejected" is not one.
+pub const REJECTION_MAX_CHARS: usize = 600;
+
+/// Phrases that rule an approach out on their own.
+const REJECTION_CUES: &[&str] = &[
+    "decided against",
+    "won't work because",
+    "ruled out",
+    "rule it out",
+    "won't use",
+    "will not use",
+    "not going to use",
+    "not going with",
+    "gave up on",
+    "giving up on",
+    "abandoned the",
+    "abandon the",
+    "rejected the",
+    "rejecting the",
+    "отказались от",
+    "отказался от",
+    "отказываемся от",
+    "отказ от",
+    "отклонил",
+    "отклонён",
+    "отклонен",
+    "отклоняем",
+    "отверг",
+    "не будем использовать",
+    "не стали использовать",
+];
+
+/// An attempt and its failure together: "tried X, it didn't work".
+const TRIED: &[&str] = &["tried", "attempted", "пробовал", "попробовал"];
+const FAILED: &[&str] = &[
+    "instead",
+    "doesn't work",
+    "didn't work",
+    "won't work",
+    "failed",
+    "вместо",
+    "не работает",
+    "не сработал",
+    "не подходит",
+];
+
+/// True when `text` rules an approach out: a short statement with an
+/// explicit cue. A bug report ("X doesn't work"), a log line ("rejected 2
+/// files"), a tool call or a whole answer is not a rejection.
+pub fn is_explicit_rejection(text: &str) -> bool {
+    if text.chars().count() > REJECTION_MAX_CHARS || crate::noise::machine_text(text).is_some() {
+        return false;
+    }
+
+    let lower = text.to_lowercase();
+    let has = |cues: &[&str]| cues.iter().any(|c| lower.contains(c));
+
+    has(REJECTION_CUES) || (has(TRIED) && has(FAILED))
+}
+
 /// Parse a model's raw text reply into a strict-JSON `ClassifyOutput`,
 /// tolerating ```json code-fence wrapping. Shared by the HTTP and agent-sdk
 /// backends so the two never diverge on how they read the verdict.
diff --git a/crates/tj-core/src/classifier/prompt.rs b/crates/tj-core/src/classifier/prompt.rs
index 07fbda9..440998e 100644
--- a/crates/tj-core/src/classifier/prompt.rs
+++ b/crates/tj-core/src/classifier/prompt.rs
@@ -62,7 +62,7 @@ pub fn build(input: &ClassifyInput) -> String {
          - finding: A VERIFIED discovery backed by code reading or logs (\"found that function X does Y at line Z\", \"the config sets X=Y\").\n\
          - evidence: Test results, benchmarks, QA outcomes, reproduction steps, logs proving something works/fails. Set evidence_strength: weak (anecdotal), medium (single test), strong (comprehensive/e2e).\n\
          - decision: A chosen approach or architecture choice (\"will use strategy X because Y\"). The team commits to this.\n\
-         - rejection: An approach explicitly REJECTED (\"tried X but it won't work because Y\"). Important for avoiding repeated work.\n\
+         - rejection: An approach explicitly ruled out (\"tried X but it won't work because Y\", \"decided against X\"). Not a bug report, a failing command, a log line, a tool call or a summary. Important for avoiding repeated work.\n\
          - constraint: An external limitation discovered (\"API rate limit is 100/min\", \"must support PHP 7.4\").\n\
          - correction: The chunk CORRECTS a previous finding/hypothesis that turned out wrong. Use when the text says \"actually\", \"correction\", \"was wrong about\".\n\
          - close: Task is done — fix shipped, PR merged, verified. Use when text indicates completion.\n\
diff --git a/crates/tj-core/src/db.rs b/crates/tj-core/src/db.rs
index 88f008a..8341a97 100644
--- a/crates/tj-core/src/db.rs
+++ b/crates/tj-core/src/db.rs
@@ -457,6 +457,9 @@ pub fn upsert_task_from_event(
                 rusqlite::params![event.task_id, title, event.timestamp],
             )?;
         }
+        // A cleanup touches old tasks; it must not lift them to the top of
+        // every "newest first" list.
+        _ if event.meta.get("kind").and_then(|v| v.as_str()) == Some(NOISE_CLEANUP) => {}
         _ => {
             conn.execute(
                 "UPDATE tasks SET last_event_at=?2 WHERE task_id=?1",
@@ -1150,12 +1153,17 @@ pub(crate) fn fts_rowid(event_id: &str) -> i64 {
     (hash >> 1) as i64
 }
 
+/// `meta.kind` of the correction `cleanup-noise` writes over machine text the
+/// classifier once filed as reasoning.
+pub const NOISE_CLEANUP: &str = "noise_cleanup";
+
 /// Machine-written bookkeeping, not reasoning: the PreCompact boundary marker
-/// (a `decision`) and the model-switch note (a `constraint`). Known by
-/// `meta.kind`; events written before the writers set it, by text prefix.
+/// (a `decision`), the model-switch note (a `constraint`) and the
+/// `cleanup-noise` correction. Known by `meta.kind`; events written before
+/// the writers set it, by text prefix.
 pub fn is_bookkeeping(event: &Event) -> bool {
     match event.meta.get("kind").and_then(|v| v.as_str()) {
-        Some(kind) => matches!(kind, "compaction_marker" | "model_switch"),
+        Some(kind) => matches!(kind, "compaction_marker" | "model_switch" | NOISE_CLEANUP),
         None => match event.event_type {
             EventType::Decision => event.text.starts_with("Conversation compacted at"),
             EventType::Constraint => event
diff --git a/crates/tj-core/src/lib.rs b/crates/tj-core/src/lib.rs
index 4b4155f..42802c0 100644
--- a/crates/tj-core/src/lib.rs
+++ b/crates/tj-core/src/lib.rs
@@ -74,6 +74,7 @@ pub mod harvest;
 pub mod llm;
 pub mod memory;
 pub mod modules;
+pub mod noise;
 pub mod pack;
 pub mod paths;
 pub mod project_hash;
diff --git a/crates/tj-core/src/noise.rs b/crates/tj-core/src/noise.rs
new file mode 100644
index 0000000..fc79992
--- /dev/null
+++ b/crates/tj-core/src/noise.rs
@@ -0,0 +1,102 @@
+//! Machine text: what Claude Code and the tools produce, never reasoning.
+//! A raw tool call, a compaction summary or a harness notification once got
+//! filed as a decision or a rejection; packs, recall, the classifier and the
+//! `cleanup-noise` command all tell it apart here, the same way.
+
+/// Why `text` is machine output rather than reasoning, or `None` when it
+/// reads as reasoning. Conservative: only shapes no person writes.
+pub fn machine_text(text: &str) -> Option<&'static str> {
+    let t = text.trim_start();
+
+    let summary = [
+        "This session is being continued from a previous conversation",
+        "Conversation compacted at",
+        "[Conversation compacted",
+        "Caveat: The messages below were generated by the user",
+    ];
+    if summary.iter().any(|p| t.starts_with(p)) {
+        return Some("compaction summary");
+    }
+
+    let tags = [
+        "<task-notification",
+        "<system-reminder",
+        "<command-name>",
+        "<command-message>",
+        "<local-command-",
+        "<bash-input>",
+        "<bash-stdout>",
+    ];
+    if tags.iter().any(|p| t.starts_with(p)) {
+        return Some("harness notification");
+    }
+
+    if is_tool_payload(t) {
+        return Some("raw tool call");
+    }
+
+    if t.starts_with(CLEANUP_PREFIX) {
+        return Some("journal cleanup");
+    }
+
+    None
+}
+
+/// How the correction `cleanup-noise` writes begins: the journal's own
+/// bookkeeping, kept out of packs like the rest of this module's text.
+pub const CLEANUP_PREFIX: &str = "[cleanup-noise]";
+
+/// `Bash: {"command": …}` or `mcp__server__tool: {…}`: how a hook renders a
+/// tool call — the tool's name, a colon, then its JSON input.
+fn is_tool_payload(t: &str) -> bool {
+    let Some((name, rest)) = t.split_once(": ") else {
+        return false;
+    };
+    let is_name = !name.is_empty()
+        && name.chars().next().is_some_and(|c| c.is_ascii_alphabetic())
+        && name
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-');
+
+    is_name && (rest.starts_with('{') || rest.starts_with('['))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::machine_text;
+
+    #[test]
+    fn tool_calls_summaries_and_notifications_are_machine_text() {
+        let cases = [
+            (r#"Bash: {"command":"git push"} → {"stdout":""}"#, "raw tool call"),
+            (r#"Edit: {"file_path":"/x/y.rs","old_string":"a"}"#, "raw tool call"),
+            (r#"mcp__plugin_context-mode_context-mode__ctx_execute: {"code":"x"}"#, "raw tool call"),
+            (
+                "This session is being continued from a previous conversation that ran out of context.",
+                "compaction summary",
+            ),
+            ("Conversation compacted at 2026-06-07T11:47:33Z; …", "compaction summary"),
+            ("  [Conversation compacted]", "compaction summary"),
+            ("<task-notification> <task-id>wl08</task-id>", "harness notification"),
+            ("<system-reminder>Whenever you read a file", "harness notification"),
+            ("[cleanup-noise] not a rejection: raw tool call", "journal cleanup"),
+        ];
+
+        for (text, why) in cases {
+            assert_eq!(machine_text(text), Some(why), "{text}");
+        }
+    }
+
+    #[test]
+    fn reasoning_is_not_machine_text() {
+        for text in [
+            "Use axum for the server because it has better middleware.",
+            "Rejected: per-stage sessions lose accumulated context.",
+            "Отклонён chown -R www-data public в Dockerfile: он делает веб-корень записываемым.",
+            "Note: the config {a: 1} is read once at start.",
+            "",
+        ] {
+            assert_eq!(machine_text(text), None, "{text}");
+        }
+    }
+}
diff --git a/crates/tj-core/src/pack.rs b/crates/tj-core/src/pack.rs
index b694a58..1bd9618 100644
--- a/crates/tj-core/src/pack.rs
+++ b/crates/tj-core/src/pack.rs
@@ -29,17 +29,11 @@ use anyhow::Context;
 use rusqlite::Connection;
 use std::collections::HashSet;
 
-/// Auto-recorded compaction / session-continuation markers are not real
-/// reasoning — Claude Code injects them when a conversation is compacted or
-/// resumed, and the classifier sometimes files them as decisions. Drop them
-/// from the pack so the reasoning reads clean. Conservative: only well-known
-/// machine-generated prefixes.
+/// Compaction summaries, harness notifications and raw tool calls are not
+/// reasoning, though the classifier sometimes filed them as decisions or
+/// rejections. Drop them from the pack so the reasoning reads clean.
 pub(crate) fn is_noise(text: &str) -> bool {
-    let t = text.trim_start();
-    t.starts_with("This session is being continued from a previous conversation")
-        || t.starts_with("Conversation compacted at")
-        || t.starts_with("[Conversation compacted")
-        || t.starts_with("Caveat: The messages below were generated by the user")
+    crate::noise::machine_text(text).is_some()
 }
 
 fn render_recent_events(conn: &Connection, task_id: &str, limit: usize) -> anyhow::Result<String> {
diff --git a/crates/tj-core/src/recall.rs b/crates/tj-core/src/recall.rs
index abf6d65..2ec5e0e 100644
--- a/crates/tj-core/src/recall.rs
+++ b/crates/tj-core/src/recall.rs
@@ -1,9 +1,16 @@
-//! Read-only proactive-recall engine. Given the current tool context,
-//! return the most relevant prior confirmed `rejection`/`decision` events
-//! so the agent doesn't re-walk a ruled-out path. Shared by the PostToolUse
-//! push path (claude-memory-60m) and the MCP-output push path (7km).
+//! Read-only proactive recall. After a tool call, find a prior confirmed
+//! `rejection`/`decision` of the session's own task — or of a task in the
+//! same module — that the call clearly touches, so the agent doesn't re-walk
+//! a ruled-out path. Shared by the PostToolUse push path (claude-memory-60m)
+//! and the MCP-output push path (7km).
+//!
+//! It stays quiet unless the match is strong: recall that fires on one
+//! shared word, across unrelated tasks, or on machine text the classifier
+//! once filed as reasoning, buried the agent in noise (dozens of hits per
+//! session, almost none about the work at hand).
 
 use crate::event::EventType;
+use std::collections::HashSet;
 
 /// One recalled high-signal event that matched the current context.
 #[derive(Debug, Clone, PartialEq)]
@@ -15,10 +22,11 @@ pub struct RecallHit {
     pub score: f64,
 }
 
-/// Max hits surfaced per call. Autonomously-chosen default, flagged for review.
-pub const DEFAULT_MAX_HITS: usize = 2;
-/// Min blended score to surface. Autonomously-chosen default, flagged for review.
-pub const RELEVANCE_THRESHOLD: f64 = 1.0;
+/// Max hits surfaced per call.
+pub const DEFAULT_MAX_HITS: usize = 1;
+/// Shared meaningful words that make a match strong when no file, issue or
+/// commit is shared.
+pub const MIN_SHARED_WORDS: usize = 3;
 
 /// Common, low-signal words dropped from the OR-token query. Without this,
 /// a shared stopword like "the" between an unrelated tool call and a prior
@@ -32,7 +40,7 @@ const STOPWORDS: &[&str] = &[
 ];
 
 /// The meaningful words of `text`: alphanumeric runs of 3+ chars, lowercased,
-/// stopwords dropped. Shared by recall's FTS query and module suggestions.
+/// stopwords dropped. Shared by recall and module suggestions.
 pub(crate) fn keywords(text: &str) -> Vec<String> {
     text.split(|c: char| !c.is_alphanumeric())
         .filter(|t| t.chars().count() >= 3)
@@ -41,149 +49,93 @@ pub(crate) fn keywords(text: &str) -> Vec<String> {
         .collect()
 }
 
-/// Build an FTS5 OR-of-tokens query from a free-text context string. A raw
-/// multi-word context like "let's switch to axum" parses as an implicit AND
-/// under FTS5, so it would never match a short rejection that only shares one
-/// token. We instead OR the individual word tokens (punctuation stripped,
-/// short tokens and stopwords dropped) so any shared *meaningful* keyword
-/// scores a hit — the same recall intent as `run_rejected`'s MATCH, widened
-/// for prose input. Returns `None` when no usable token survives (caller
-/// then falls back to a raw LIKE on the query).
-fn fts_or_query(query_text: &str) -> Option<String> {
-    let tokens = keywords(query_text);
-    if tokens.is_empty() {
-        return None;
-    }
-    Some(tokens.join(" OR "))
-}
-
-/// Search confirmed `rejection`/`decision` events for ones relevant to the
-/// current context, blending an FTS5/LIKE text signal with artifact overlap.
+/// Prior confirmed rejections and decisions that `query_text` (what a tool
+/// call did) clearly touches, for a session working on `task_id`.
 ///
-/// Read-only: never mutates the JSONL log or any derived table. Returns at
-/// most `max_hits` hits scoring >= [`RELEVANCE_THRESHOLD`], sorted by score
-/// descending with `Rejection` winning ties over `Decision`.
-pub fn relevant_recall(
+/// Only what the agent or the user recorded — classifier output is not
+/// trusted here — on `task_id` itself or on a task sharing a module with it,
+/// never machine text, never a corrected or bookkeeping event. A match is
+/// strong when the call and the event share a file, an issue or a commit, or
+/// at least [`MIN_SHARED_WORDS`] meaningful words. Returns at most `max_hits`,
+/// best first, a rejection ahead of a decision on a tie. Read-only.
+pub fn recall_for_task(
     conn: &rusqlite::Connection,
+    task_id: &str,
     query_text: &str,
     max_hits: usize,
 ) -> anyhow::Result<Vec<RecallHit>> {
-    use std::collections::HashMap;
-    if query_text.trim().is_empty() {
+    // A path is a file, not words: `/home/u/proj/crates/tj-core/src/db.rs`
+    // alone would share "crates", "core" and "src" with any note on the crate.
+    let (paths, prose): (Vec<&str>, Vec<&str>) = query_text
+        .split_whitespace()
+        .map(|t| t.trim_matches(|c: char| "\"'`,;:()[]{}<>|".contains(c)))
+        .partition(|t| t.contains('/'));
+    let words: HashSet<String> = keywords(&prose.join(" ")).into_iter().collect();
+    let arts = crate::artifacts::extract(query_text);
+    let needles: Vec<String> = arts
+        .linked_issues
+        .iter()
+        .chain(arts.commit_hashes.iter())
+        .map(|n| format!("\"{n}\""))
+        .collect();
+    if words.is_empty() && needles.is_empty() && paths.is_empty() {
         return Ok(Vec::new());
     }
 
-    // score keyed by event_id; carry (task_id, type, text) for output.
-    let mut scores: HashMap<String, f64> = HashMap::new();
-    let mut meta: HashMap<String, (String, EventType, String)> = HashMap::new();
-
-    // 1) Text signal: FTS5 OR-of-tokens MATCH, restricted to confirmed
-    //    rejection/decision (mirrors run_rejected's join). The tokenizer
-    //    strips all punctuation, so the resulting `a OR b OR c` query is
-    //    always FTS-safe even when the raw context is noisy tool-call JSON
-    //    (`Bash: {"command":"…"}`) full of `:`/`"`/`{}` that would otherwise
-    //    trip the FTS5 parser. Falls back to a raw LIKE substring only when
-    //    no usable token survives — the same fallback shape run_search uses.
-    let fts_or = fts_or_query(query_text);
-    let use_fts = fts_or.is_some();
-    let sql = if use_fts {
-        "SELECT ei.event_id, ei.task_id, ei.type, sf.text
+    let mut stmt = conn.prepare(
+        "SELECT ei.event_id, ei.task_id, ei.type, sf.text, COALESCE(ei.artifacts, '')
          FROM events_index ei
          JOIN search_fts sf ON sf.event_id = ei.event_id
          WHERE ei.status = 'confirmed'
            AND ei.type IN ('rejection','decision')
            AND ei.bookkeeping = 0
            AND ei.corrected_by IS NULL
-           AND search_fts MATCH ?1"
-    } else {
-        "SELECT ei.event_id, ei.task_id, ei.type, sf.text
-         FROM events_index ei
-         JOIN search_fts sf ON sf.event_id = ei.event_id
-         WHERE ei.status = 'confirmed'
-           AND ei.type IN ('rejection','decision')
-           AND ei.bookkeeping = 0
-           AND ei.corrected_by IS NULL
-           AND sf.text LIKE ?1"
-    };
-    let bind = if let Some(or_query) = fts_or {
-        or_query
-    } else {
-        crate::fts::like_pattern(query_text)
-    };
-    if let Ok(mut stmt) = conn.prepare(sql) {
-        let rows = stmt.query_map(rusqlite::params![bind], |r| {
-            Ok((
-                r.get::<_, String>(0)?,
-                r.get::<_, String>(1)?,
-                r.get::<_, String>(2)?,
-                r.get::<_, String>(3)?,
-            ))
-        });
-        if let Ok(rows) = rows {
-            for row in rows.flatten() {
-                let (eid, tid, ty, text) = row;
-                let et = parse_type(&ty);
-                *scores.entry(eid.clone()).or_insert(0.0) += 1.0; // text-match weight
-                meta.entry(eid).or_insert((tid, et, text));
-            }
+           AND ei.author IN ('user','agent')
+           AND (ei.task_id = ?1 OR ei.task_id IN (
+                 SELECT other.task_id FROM task_modules mine
+                 JOIN task_modules other ON other.module_id = mine.module_id
+                 WHERE mine.task_id = ?1))",
+    )?;
+    let rows = stmt.query_map(rusqlite::params![task_id], |r| {
+        Ok((
+            r.get::<_, String>(0)?,
+            r.get::<_, String>(1)?,
+            r.get::<_, String>(2)?,
+            r.get::<_, String>(3)?,
+            r.get::<_, String>(4)?,
+        ))
+    })?;
+
+    let mut hits = Vec::new();
+    for row in rows {
+        let (event_id, task_id, ty, text, artifacts) = row?;
+        if crate::noise::machine_text(&text).is_some() {
+            continue;
         }
-    }
 
-    // 2) Artifact signal: overlap of artifacts::extract(query_text) against
-    //    events_index.artifacts (mirrors find_related_tasks LIKE scan), same
-    //    confirmed rejection/decision restriction. +weight per shared artifact.
-    let arts = crate::artifacts::extract(query_text);
-    for needle in arts
-        .linked_issues
-        .iter()
-        .chain(arts.commit_hashes.iter())
-        .chain(arts.files.iter())
-    {
-        let pattern = format!("%\"{}\"%", needle.replace('%', "\\%"));
-        if let Ok(mut stmt) = conn.prepare(
-            "SELECT ei.event_id, ei.task_id, ei.type, sf.text
-             FROM events_index ei
-             JOIN search_fts sf ON sf.event_id = ei.event_id
-             WHERE ei.status = 'confirmed'
-               AND ei.type IN ('rejection','decision')
-               AND ei.bookkeeping = 0
-               AND ei.corrected_by IS NULL
-               AND ei.artifacts LIKE ?1",
-        ) {
-            let rows = stmt.query_map(rusqlite::params![pattern], |r| {
-                Ok((
-                    r.get::<_, String>(0)?,
-                    r.get::<_, String>(1)?,
-                    r.get::<_, String>(2)?,
-                    r.get::<_, String>(3)?,
-                ))
-            });
-            if let Ok(rows) = rows {
-                for row in rows.flatten() {
-                    let (eid, tid, ty, text) = row;
-                    let et = parse_type(&ty);
-                    *scores.entry(eid.clone()).or_insert(0.0) += 0.5; // artifact weight
-                    meta.entry(eid).or_insert((tid, et, text));
-                }
-            }
+        let shared_arts = needles
+            .iter()
+            .filter(|n| artifacts.contains(n.as_str()))
+            .count()
+            + shared_files(&paths, &artifacts);
+        let shared_words = keywords(&text)
+            .into_iter()
+            .collect::<HashSet<_>>()
+            .intersection(&words)
+            .count();
+        if shared_arts == 0 && shared_words < MIN_SHARED_WORDS {
+            continue;
         }
+
+        hits.push(RecallHit {
+            event_id,
+            task_id,
+            event_type: parse_type(&ty),
+            text,
+            score: (shared_arts * 2 + shared_words) as f64,
+        });
     }
 
-    // 3) Threshold + rank. Sort by score desc; tie → Rejection before Decision.
-    let mut hits: Vec<RecallHit> = scores
-        .into_iter()
-        .filter(|(_, s)| *s >= RELEVANCE_THRESHOLD)
-        .filter_map(|(eid, score)| {
-            meta.remove(&eid)
-                .map(|(task_id, event_type, text)| RecallHit {
-                    event_id: eid,
-                    task_id,
-                    event_type,
-                    text,
-                    score,
-                })
-        })
-        .collect();
     hits.sort_by(|a, b| {
         b.score
             .partial_cmp(&a.score)
@@ -191,9 +143,29 @@ pub fn relevant_recall(
             .then_with(|| rank(a.event_type).cmp(&rank(b.event_type)))
     });
     hits.truncate(max_hits);
+
     Ok(hits)
 }
 
+/// Files of an event (its `artifacts` JSON) that one of `paths` names. An
+/// event keeps `src/pack.rs` while a tool call names the absolute path, so a
+/// match is the same path or one ending in the other at a `/`.
+fn shared_files(paths: &[&str], artifacts: &str) -> usize {
+    if paths.is_empty() || artifacts.is_empty() {
+        return 0;
+    }
+    let Ok(arts) = serde_json::from_str::<crate::artifacts::Artifacts>(artifacts) else {
+        return 0;
+    };
+    let same =
+        |a: &str, b: &str| a == b || a.ends_with(&format!("/{b}")) || b.ends_with(&format!("/{a}"));
+
+    arts.files
+        .iter()
+        .filter(|f| paths.iter().any(|p| same(p, f)))
+        .count()
+}
+
 fn parse_type(s: &str) -> EventType {
     match s {
         "rejection" => EventType::Rejection,
@@ -215,7 +187,10 @@ mod tests {
     use crate::db;
     use crate::event::{Author, Event, EventStatus, EventType, Source};
 
-    // Open a temp db and ingest a slice of events through the same
+    const TASK: &str = "tj-1";
+    const AXUM_CALL: &str = r#"{"command":"switch the server to axum"}"#;
+
+    // Open a temp db and index a slice of events through the same
     // `index_event` path db.rs tests use (db::open + index_event).
     fn seeded(events: &[Event]) -> (tempfile::TempDir, rusqlite::Connection) {
         let d = tempfile::TempDir::new().unwrap();
@@ -232,148 +207,181 @@ mod tests {
         e
     }
 
+    fn rejection(task: &str, text: &str) -> Event {
+        ev(task, EventType::Rejection, text, EventStatus::Confirmed)
+    }
+
     #[test]
-    fn returns_matching_confirmed_rejection() {
-        let rej = ev(
-            "tj-1",
-            EventType::Rejection,
-            "Tried switching the server to axum but it broke rmcp stdio.",
-            EventStatus::Confirmed,
-        );
-        let (_d, conn) = seeded(&[rej]);
+    fn returns_a_strong_match_on_the_task() {
+        let (_d, conn) = seeded(&[rejection(
+            TASK,
+            "Tried to switch the server to axum but it broke rmcp stdio.",
+        )]);
 
-        let hits = relevant_recall(&conn, "let's switch to axum", DEFAULT_MAX_HITS).unwrap();
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, DEFAULT_MAX_HITS).unwrap();
         assert_eq!(hits.len(), 1);
         assert_eq!(hits[0].event_type, EventType::Rejection);
         assert!(hits[0].text.contains("axum"));
     }
 
+    /// One shared word used to be enough: "server" or "test" matched
+    /// rejections from any task in the project.
+    #[test]
+    fn one_or_two_shared_words_are_not_a_match() {
+        let (_d, conn) = seeded(&[rejection(
+            TASK,
+            "Rejected the axum migration for the server: rmcp stdio broke.",
+        )]);
+
+        let hits = recall_for_task(&conn, TASK, r#"{"command":"restart the server"}"#, 2).unwrap();
+        assert!(hits.is_empty(), "got: {hits:?}");
+        let hits = recall_for_task(&conn, TASK, r#"{"command":"axum server up"}"#, 2).unwrap();
+        assert!(hits.is_empty(), "got: {hits:?}");
+    }
+
+    #[test]
+    fn a_shared_file_is_a_match() {
+        let (_d, conn) = seeded(&[rejection(
+            TASK,
+            "Rejected caching in src/pack.rs: it was never reused.",
+        )]);
+
+        let hits = recall_for_task(&conn, TASK, "/home/u/proj/src/pack.rs x", 2).unwrap();
+        assert_eq!(hits.len(), 1, "got: {hits:?}");
+    }
+
+    /// The words of a path are not words of the work: another file of the
+    /// same crate shares "crates", "core" and "src", and that is no match.
+    #[test]
+    fn a_path_counts_as_a_file_not_as_words() {
+        let (_d, conn) = seeded(&[rejection(
+            TASK,
+            "Rejected caching in crates/tj-core/src/pack.rs: it was never reused.",
+        )]);
+
+        let other =
+            recall_for_task(&conn, TASK, "/home/u/proj/crates/tj-core/src/db.rs", 2).unwrap();
+        assert!(other.is_empty(), "got: {other:?}");
+        let same =
+            recall_for_task(&conn, TASK, "/home/u/proj/crates/tj-core/src/pack.rs", 2).unwrap();
+        assert_eq!(same.len(), 1, "got: {same:?}");
+    }
+
+    #[test]
+    fn other_tasks_are_out_unless_they_share_a_module() {
+        let text = "Tried to switch the server to axum but it broke rmcp stdio.";
+        let (_d, conn) = seeded(&[rejection("tj-other", text)]);
+
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, 2).unwrap();
+        assert!(hits.is_empty(), "another task, no module: {hits:?}");
+
+        for task in [TASK, "tj-other"] {
+            conn.execute(
+                "INSERT INTO task_modules(project_hash, task_id, module_id) VALUES ('p', ?1, 'mcp')",
+                rusqlite::params![task],
+            )
+            .unwrap();
+        }
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, 2).unwrap();
+        assert_eq!(hits.len(), 1, "same module: {hits:?}");
+    }
+
+    /// The classifier filed whole answers, tool calls and summaries as
+    /// confirmed rejections; recall trusts only what a person or the agent
+    /// recorded, and never machine text.
+    #[test]
+    fn classifier_output_and_machine_text_are_never_recalled() {
+        let mut by_classifier =
+            rejection(TASK, "Tried to switch the server to axum, it broke stdio.");
+        by_classifier.author = Author::Classifier;
+        let payload = rejection(TASK, r#"Bash: {"command":"switch the server to axum"}"#);
+        let summary = rejection(
+            TASK,
+            "This session is being continued from a previous conversation: switch the server to axum.",
+        );
+        let (_d, conn) = seeded(&[by_classifier, payload, summary]);
+
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, 3).unwrap();
+        assert!(hits.is_empty(), "got: {hits:?}");
+    }
+
     #[test]
     fn ignores_suggested_and_wrong_type() {
         let suggested = ev(
-            "tj-1",
+            TASK,
             EventType::Rejection,
-            "Rejected the axum migration tentatively.",
+            "Rejected switching the server to axum tentatively.",
             EventStatus::Suggested,
         );
         let finding = ev(
-            "tj-1",
+            TASK,
             EventType::Finding,
-            "The axum server starts fine in isolation.",
+            "The axum server starts fine in isolation after the switch.",
             EventStatus::Confirmed,
         );
         let (_d, conn) = seeded(&[suggested, finding]);
 
-        let hits = relevant_recall(&conn, "axum", DEFAULT_MAX_HITS).unwrap();
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, 2).unwrap();
         assert!(hits.is_empty(), "got: {hits:?}");
     }
 
     #[test]
-    fn caps_at_max_hits() {
-        let events: Vec<Event> = (0..5)
-            .map(|i| {
-                ev(
-                    "tj-1",
-                    EventType::Rejection,
-                    &format!("Rejected widget approach number {i} for the dashboard"),
-                    EventStatus::Confirmed,
-                )
-            })
-            .collect();
-        let (_d, conn) = seeded(&events);
-
-        let hits = relevant_recall(&conn, "dashboard widget", 2).unwrap();
-        assert_eq!(hits.len(), 2);
-    }
-
-    #[test]
-    fn rejection_wins_tie_over_decision() {
+    fn rejection_wins_a_tie_and_hits_are_capped() {
         let decision = ev(
-            "tj-1",
+            TASK,
             EventType::Decision,
-            "Decided to use the postgres connector.",
-            EventStatus::Confirmed,
-        );
-        let rejection = ev(
-            "tj-2",
-            EventType::Rejection,
-            "Rejected the postgres connector for latency.",
+            "Decided to switch the server to axum.",
             EventStatus::Confirmed,
         );
-        let (_d, conn) = seeded(&[decision, rejection]);
+        let rej = rejection(TASK, "Rejected: switch the server to axum.");
+        let (_d, conn) = seeded(&[decision, rej]);
 
-        let hits = relevant_recall(&conn, "postgres connector", DEFAULT_MAX_HITS).unwrap();
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, 2).unwrap();
         assert_eq!(hits.len(), 2);
-        // Same text-match score (1.0 each) → rejection ranks first.
         assert_eq!(hits[0].event_type, EventType::Rejection);
-        assert_eq!(hits[1].event_type, EventType::Decision);
-    }
-
-    #[test]
-    fn below_threshold_returns_empty() {
-        // No textual or artifact overlap → score stays 0 < threshold.
-        let rej = ev(
-            "tj-1",
-            EventType::Rejection,
-            "Rejected the kafka pipeline for cost reasons.",
-            EventStatus::Confirmed,
-        );
-        let (_d, conn) = seeded(&[rej]);
 
-        let hits = relevant_recall(&conn, "frontend styling refactor", DEFAULT_MAX_HITS).unwrap();
-        assert!(hits.is_empty(), "got: {hits:?}");
+        let hits = recall_for_task(&conn, TASK, AXUM_CALL, 1).unwrap();
+        assert_eq!(hits.len(), 1);
     }
 
     #[test]
     fn empty_query_returns_empty() {
-        let rej = ev(
-            "tj-1",
-            EventType::Rejection,
-            "Rejected axum.",
-            EventStatus::Confirmed,
-        );
-        let (_d, conn) = seeded(&[rej]);
-
-        assert!(relevant_recall(&conn, "", DEFAULT_MAX_HITS)
-            .unwrap()
-            .is_empty());
-        assert!(relevant_recall(&conn, "   ", DEFAULT_MAX_HITS)
-            .unwrap()
-            .is_empty());
+        let (_d, conn) = seeded(&[rejection(TASK, "Rejected axum.")]);
+
+        assert!(recall_for_task(&conn, TASK, "", 2).unwrap().is_empty());
+        assert!(recall_for_task(&conn, TASK, "   ", 2).unwrap().is_empty());
     }
 
     #[test]
     fn compaction_markers_are_never_recalled() {
         // An old marker (recognised by its text) and a new one (by meta.kind).
         let old = ev(
-            "tj-1",
+            TASK,
             EventType::Decision,
             "Conversation compacted at 2026-01-01T00:00:00Z; preceding events should be treated as a single reasoning unit.",
             EventStatus::Confirmed,
         );
         let mut new = ev(
-            "tj-1",
+            TASK,
             EventType::Decision,
-            "Compaction boundary: reasoning unit closed.",
+            "Compaction boundary: preceding reasoning unit closed.",
             EventStatus::Confirmed,
         );
         new.meta = serde_json::json!({ "kind": "compaction_marker" });
         let (_d, conn) = seeded(&[old, new]);
 
-        let hits = relevant_recall(&conn, "reasoning unit", DEFAULT_MAX_HITS).unwrap();
+        let hits = recall_for_task(&conn, TASK, "preceding reasoning unit", 2).unwrap();
         assert!(hits.is_empty(), "got: {hits:?}");
     }
 
     #[test]
     fn corrected_events_are_never_recalled() {
-        let rej = ev(
-            "tj-1",
-            EventType::Rejection,
-            "Rejected axum for the server in src/server.rs.",
-            EventStatus::Confirmed,
+        let rej = rejection(
+            TASK,
+            "Rejected switching the server to axum in src/server.rs.",
         );
         let mut corr = ev(
-            "tj-1",
+            TASK,
             EventType::Correction,
             "That was wrong: the stdio issue was unrelated.",
             EventStatus::Confirmed,
@@ -381,8 +389,8 @@ mod tests {
         corr.corrects = Some(rej.event_id.clone());
         let (_d, conn) = seeded(&[rej, corr]);
 
-        // Both the text and the artifact path must skip the corrected event.
-        let hits = relevant_recall(&conn, "axum src/server.rs", DEFAULT_MAX_HITS).unwrap();
+        // Both the word and the file path must skip the corrected event.
+        let hits = recall_for_task(&conn, TASK, "switch server axum src/server.rs", 2).unwrap();
         assert!(hits.is_empty(), "got: {hits:?}");
     }
 }
diff --git a/crates/tj-core/src/session/extractor.rs b/crates/tj-core/src/session/extractor.rs
index d940cdd..4ee8d30 100644
--- a/crates/tj-core/src/session/extractor.rs
+++ b/crates/tj-core/src/session/extractor.rs
@@ -261,33 +261,20 @@ fn classify_text_heuristic(task_id: &str, text: &str, timestamp: &str) -> Option
         }
     }
 
-    // Rejection patterns.
-    let rejection_patterns = [
-        "won't work",
-        "doesn't work",
-        "can't use",
-        "не работает",
-        "не подходит",
-        "отказались",
-        "tried but",
-        "rejected",
-        "abandoned",
-    ];
-    for pattern in &rejection_patterns {
-        if lower.contains(pattern) {
-            let mut ev = Event::new(
-                task_id,
-                EventType::Rejection,
-                Author::Agent,
-                Source::Cli,
-                truncate(text, 300),
-            );
-            ev.timestamp = timestamp.to_string();
-            ev.confidence = Some(0.6);
-            ev.status = EventStatus::Suggested;
-            ev.meta = serde_json::json!({"backfill": true, "heuristic": "rejection_keyword"});
-            return Some(ev);
-        }
+    // Only an approach explicitly ruled out, the same rule the classifier uses.
+    if crate::classifier::is_explicit_rejection(text) {
+        let mut ev = Event::new(
+            task_id,
+            EventType::Rejection,
+            Author::Agent,
+            Source::Cli,
+            truncate(text, 300),
+        );
+        ev.timestamp = timestamp.to_string();
+        ev.confidence = Some(0.6);
+        ev.status = EventStatus::Suggested;
+        ev.meta = serde_json::json!({"backfill": true, "heuristic": "rejection_keyword"});
+        return Some(ev);
     }
 
     // Constraint patterns.
diff --git a/crates/tj-mcp/src/main.rs b/crates/tj-mcp/src/main.rs
index a05c145..5a73dad 100644
--- a/crates/tj-mcp/src/main.rs
+++ b/crates/tj-mcp/src/main.rs
@@ -124,39 +124,13 @@ fn cached_open(state_path: &Path) -> anyhow::Result<Arc<Mutex<Connection>>> {
 
 /// MCP instructions delivered to every Claude Code session where this plugin is installed.
 /// This is the primary mechanism for self-contained plugin behavior — no manual CLAUDE.md edits needed.
-const MCP_INSTRUCTIONS: &str = r#"Task Journal — reasoning-chain memory. NON-NEGOTIABLE: you are the recorder.
-The code shows WHAT changed; only you can record WHY. If you don't log it the
-moment it happens, it is lost. This memory only works if you actually call the
-tools — so call them, every session, without being asked.
-
-THE RITUAL — do this on EVERY coding session, not optional:
-
-1. START. task_search(status="open") lists open tasks, newest first (add a
-   `query` to narrow; each entry in `tasks` has title + goal) → task_pack to
-   resume one; if nothing fits, task_create(title, goal=<one sentence: what the
-   user is trying to accomplish>). Hold the returned task_id for the whole session.
-2. AT THE MOMENT you commit to an approach → event_add(event_type="decision",
-   ...) and pass `alternatives` (the options you weighed). Right then — not at
-   the end, or you will forget.
-3. AT THE MOMENT you rule an approach out → event_add(event_type="rejection").
-4. When you verify a fact from code/logs → event_add(event_type="finding").
-   When a test/benchmark proves something → event_add(event_type="evidence").
-5. SELF-CHECK before you finish (or before the context compacts): "did I log
-   every decision, rejection, and key finding from this session?" If not, log
-   them NOW.
-6. DONE → task_close(reason, outcome, outcome_tag).
-7. MODULES: task_create(modules=[..]), read module_page first;
-   task_close(module_notes=[..]). "📚 Chronicle: …" names a gap: fix it after.
-
-Record in the user's language, terse and specific (file:line, ids, names). One
-task = one objective — don't spawn a new task per turn; events accumulate under
-the held task_id. Append-only: never edit — correct a mistake with a
-`correction` event (set `corrects`).
-
-event_type: hypothesis (unverified "maybe") | finding (verified from code/logs)
-| evidence (a test proved it) | decision (committed choice) | rejection (ruled
-out) | constraint (external limit) | correction (fixes an earlier event).
-`alternatives` is decision-only.
+const MCP_INSTRUCTIONS: &str = r#"Task Journal keeps why the work went the way it did; the code only shows what changed.
+When real work starts, resume an open task (task_search status="open", then task_pack) or open one with task_create and a one-sentence goal.
+Record as it happens with event_add: decision (pass the alternatives you weighed), rejection (an approach ruled out, and why), finding (a fact checked in code or logs), evidence (what a test or run proved), constraint (an outside limit).
+Write in the user's language, short and specific: files, lines, ids, numbers.
+One task per objective. The journal is append-only: fix an entry with a correction event (corrects=<event_id>).
+If the project has a module map (module_list), read the module's module_page first, pass modules= to task_create and module_notes= to task_close.
+When the work is done, close the task with task_close(reason, outcome).
 "#;
 
 #[derive(Clone, Default)]
@@ -261,9 +235,6 @@ pub struct TaskCreateResult {
     pub suggested_modules: Vec<tj_core::modules::Suggestion>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub warnings: Vec<String>,
-    /// The chronicle's most important gap, to close once the current work is done.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub chronicle: Option<String>,
 }
 
 #[derive(Debug, Serialize, schemars::JsonSchema)]
@@ -579,36 +550,30 @@ fn has_journal() -> anyhow::Result<bool> {
 }
 
 /// What a new task's reply says about the chronicle: its modules with their
-/// state, or modules that look like a fit, and the archive's top gap.
+/// state, or modules that look like a fit. The archive's gaps are on request
+/// (module_list): a gap line on every task_create was noise about other work.
 fn new_task_chronicle(
-    task_id: &str,
     text: &str,
     linked: &[String],
-) -> anyhow::Result<(
-    Vec<ModuleBrief>,
-    Vec<tj_core::modules::Suggestion>,
-    Option<String>,
-)> {
-    with_chronicle(|chr, conn, project_hash| {
-        let mut modules = Vec::new();
-        for id in linked {
-            if let Some(m) = tj_core::modules::get(&chr.home, &chr.home_hash, id)? {
-                modules.push(ModuleBrief {
-                    module_id: m.module_id,
-                    name: m.name,
-                    state: m.state,
-                });
-            }
+) -> anyhow::Result<(Vec<ModuleBrief>, Vec<tj_core::modules::Suggestion>)> {
+    let chr = chronicle()?;
+    let mut modules = Vec::new();
+    for id in linked {
+        if let Some(m) = tj_core::modules::get(&chr.home, &chr.home_hash, id)? {
+            modules.push(ModuleBrief {
+                module_id: m.module_id,
+                name: m.name,
+                state: m.state,
+            });
         }
-        let suggested = if linked.is_empty() {
-            tj_core::modules::suggest(&chr.home, &chr.home_hash, text, &[])?
-        } else {
-            Vec::new()
-        };
-        let gaps = tj_core::archive::gaps(chr, conn, project_hash, Some(task_id))?;
+    }
+    let suggested = if linked.is_empty() {
+        tj_core::modules::suggest(&chr.home, &chr.home_hash, text, &[])?
+    } else {
+        Vec::new()
+    };
 
-        Ok((modules, suggested, tj_core::archive::headline(&gaps)))
-    })
+    Ok((modules, suggested))
 }
 
 /// What a closed task's modules still need: a link, or a fresh state.
@@ -999,8 +964,8 @@ impl TaskJournalServer {
                     p.goal.as_deref().unwrap_or(""),
                     p.initial_context.as_deref().unwrap_or("")
                 );
-                let (modules, suggested_modules, chronicle) =
-                    new_task_chronicle(&task_id, &text, &linked).unwrap_or_default();
+                let (modules, suggested_modules) =
+                    new_task_chronicle(&text, &linked).unwrap_or_default();
 
                 Ok(TaskCreateResult {
                     task_id,
@@ -1008,7 +973,6 @@ impl TaskJournalServer {
                     modules,
                     suggested_modules,
                     warnings: resolved.map(|(r, _)| r.warnings).unwrap_or_default(),
-                    chronicle,
                 })
             })
             .await
@@ -2680,11 +2644,21 @@ mod tests {
         assert!(l.links[0].remove.is_empty());
     }
 
+    /// Newer models follow plain instructions; shouting (capitals,
+    /// "NON-NEGOTIABLE") and length only crowd the context.
     #[test]
-    fn instructions_teach_the_chronicle() {
-        for needle in ["modules=", "module_page", "module_notes", "📚 Chronicle"] {
+    fn instructions_are_short_plain_and_teach_the_modules() {
+        for needle in ["modules=", "module_page", "module_notes"] {
             assert!(MCP_INSTRUCTIONS.contains(needle), "{needle}");
         }
+
+        assert!(MCP_INSTRUCTIONS.lines().count() <= 7, "{MCP_INSTRUCTIONS}");
+        assert!(!MCP_INSTRUCTIONS.contains("NON-NEGOTIABLE"));
+        let shouted = MCP_INSTRUCTIONS
+            .split(|c: char| !c.is_alphabetic())
+            .filter(|w| w.chars().count() > 3 && w.chars().all(|c| c.is_uppercase()))
+            .collect::<Vec<_>>();
+        assert!(shouted.is_empty(), "{shouted:?}");
     }
 
     #[tokio::test]
@@ -2808,7 +2782,9 @@ mod tests {
             "{:?}",
             created.suggested_modules
         );
-        assert!(created.chronicle.is_some());
+        // The archive's gaps are on request (module_list), not in every reply.
+        let reply = serde_json::to_value(&created).unwrap();
+        assert!(reply.get("chronicle").is_none(), "{reply}");
 
         let candidates = server
             .module_backfill_candidates(Parameters(BackfillParams {
diff --git a/plugin/hooks/hooks.json b/plugin/hooks/hooks.json
index fbc71ee..aba3aeb 100644
--- a/plugin/hooks/hooks.json
+++ b/plugin/hooks/hooks.json
@@ -1,4 +1,29 @@
 {
   "modules": ["./register.tsx"],
-  "hooks": {}
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "task-journal ingest-hook --from-plugin || true", "timeout": 20 }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "task-journal ingest-hook --from-plugin || true", "async": true }
+        ]
+      }
+    ],
+    "PostModelSwitch": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "task-journal ingest-hook --from-plugin || true", "async": true }
+        ]
+      }
+    ]
+  }
 }
diff --git a/plugin/hooks/journal.test.ts b/plugin/hooks/journal.test.ts
index e6c1ad8..625fc7b 100644
--- a/plugin/hooks/journal.test.ts
+++ b/plugin/hooks/journal.test.ts
@@ -1,8 +1,6 @@
 import { describe, expect, test } from 'claude-code/testing'
 
 import {
-  chronicleKeys,
-  chronicleNudge,
   journalTool,
   nudgeText,
   parseDistill,
@@ -37,7 +35,7 @@ describe('parseState', () => {
 
   test('no active task is a state, not a failure', () => {
     const s = parseState(JSON.stringify({ schema: 'tj-state/1', open_tasks: 0, active: null }))
-    expect(s).toEqual({ active: null, open_tasks: 0, archive: [] })
+    expect(s).toEqual({ active: null, open_tasks: 0 })
   })
 
   test('rejects garbage and other schemas', () => {
@@ -54,7 +52,7 @@ describe('parseState', () => {
 
 describe('texts', () => {
   const s = parseState(ACTIVE) as JournalState
-  const none: JournalState = { active: null, open_tasks: 3, archive: [] }
+  const none: JournalState = { active: null, open_tasks: 3 }
 
   test('status line names the task and its counts', () => {
     expect(statusText(s)).toBe('📓 tj-abc · 3 decisions · 1 rejected · 0 evidence')
@@ -62,7 +60,7 @@ describe('texts', () => {
 
   test('no task in the session, no status line', () => {
     expect(statusText(none)).toBe(null)
-    expect(statusText({ active: null, open_tasks: 0, archive: [] })).toBe(null)
+    expect(statusText({ active: null, open_tasks: 0 })).toBe(null)
   })
 
   test('the prompt section holds nothing that changes per entry', () => {
@@ -79,81 +77,24 @@ describe('texts', () => {
   })
 })
 
-describe('chronicle', () => {
-  const withGaps = (archive: unknown[], modules: string[] = []) =>
+describe('modules', () => {
+  const withModules = (modules: string[]) =>
     parseState(
       JSON.stringify({
         schema: 'tj-state/1',
         open_tasks: 1,
-        archive,
         active: { task_id: 'tj-a', title: 'T', goal: null, counts: {}, recent: [], modules },
       }),
     ) as JournalState
 
   test('status line names the task modules', () => {
-    expect(statusText(withGaps([], ['Stars', 'Auth']))).toBe(
-      '📓 tj-a [Stars, Auth] · 0 decisions · 0 rejected · 0 evidence',
-    )
+    expect(statusText(withModules(['Stars', 'Auth']))).toBe('📓 tj-a [Stars, Auth] · 0 decisions · 0 rejected · 0 evidence')
   })
 
-  test('an older CLI without archive or modules parses as none', () => {
+  test('an older CLI without modules parses as none', () => {
     const s = parseState(ACTIVE) as JournalState
-    expect(s.archive).toEqual([])
     expect(s.active?.modules).toEqual([])
   })
-
-  test('the active task without a module comes first', () => {
-    const s = withGaps([
-      { kind: 'unlinked_tasks', count: 4 },
-      { kind: 'task_without_module', task_id: 'tj-a' },
-    ])
-    const n = chronicleNudge(s)
-    expect(n?.key).toBe('task_without_module:tj-a')
-    expect(n?.text).toContain('📚 Chronicle: the active task tj-a belongs to no module')
-  })
-
-  test('otherwise the first gap, keyed so a changed count is not new', () => {
-    const a = chronicleNudge(withGaps([{ kind: 'unlinked_tasks', count: 4 }]))
-    const b = chronicleNudge(withGaps([{ kind: 'unlinked_tasks', count: 5 }]))
-    expect(a?.key).toBe(b?.key)
-    expect(a?.text).toContain('module_backfill_candidates')
-    expect(chronicleNudge(withGaps([{ kind: 'no_map', tasks: 3 }]))?.text).toContain('/task-journal:map')
-    expect(chronicleNudge(withGaps([{ kind: 'stale_module', module_id: 'stars', closed_since: 2 }]))?.key).toBe(
-      'stale_module:stars',
-    )
-  })
-
-  test('a gap seen once in a session is not brought up again', () => {
-    // The session starts with unlinked tasks; the new task has no module;
-    // once it is linked, the start gap must not come back.
-    const start = withGaps([{ kind: 'unlinked_tasks', count: 4 }])
-    const seen = new Set(chronicleKeys(start))
-    expect(chronicleNudge(start, seen)).toBe(null)
-
-    const created = withGaps([
-      { kind: 'task_without_module', task_id: 'tj-a' },
-      { kind: 'unlinked_tasks', count: 5 },
-    ])
-    const n = chronicleNudge(created, seen)
-    expect(n?.key).toBe('task_without_module:tj-a')
-    seen.add(n!.key)
-
-    const linked = withGaps([{ kind: 'unlinked_tasks', count: 4 }])
-    expect(chronicleNudge(linked, seen)).toBe(null)
-  })
-
-  test('the first unseen gap is brought up even behind a seen one', () => {
-    const s = withGaps([
-      { kind: 'stale_module', module_id: 'stars', closed_since: 1 },
-      { kind: 'stale_module', module_id: 'auth', closed_since: 1 },
-    ])
-    expect(chronicleNudge(s, new Set(['stale_module:stars']))?.key).toBe('stale_module:auth')
-  })
-
-  test('no gaps, or only unknown ones, is no nudge', () => {
-    expect(chronicleNudge(withGaps([]))).toBe(null)
-    expect(chronicleNudge(withGaps([{ kind: 'from_the_future' }]))).toBe(null)
-  })
 })
 
 describe('REFRESH_TOOLS', () => {
diff --git a/plugin/hooks/journal.ts b/plugin/hooks/journal.ts
index 9e17d0a..df29ef2 100644
--- a/plugin/hooks/journal.ts
+++ b/plugin/hooks/journal.ts
@@ -13,14 +13,9 @@ export type ActiveTask = {
   modules: string[]
 }
 
-/** What the project chronicle is missing: `kind` plus its own fields. */
-export type ArchiveGap = { kind: string; [field: string]: unknown }
-
 export type JournalState = {
   active: ActiveTask | null
   open_tasks: number
-  /** Most important first. Empty from a CLI older than 0.31. */
-  archive: ArchiveGap[]
 }
 
 export const STATE_SCHEMA = 'tj-state/1'
@@ -59,14 +54,9 @@ export function parseState(stdout: string): JournalState | null {
   if (v.schema !== STATE_SCHEMA) return null
 
   const open = typeof v.open_tasks === 'number' ? v.open_tasks : 0
-  const archive = Array.isArray(v.archive)
-    ? v.archive.filter(
-        (g): g is ArchiveGap => typeof g === 'object' && g !== null && typeof (g as ArchiveGap).kind === 'string',
-      )
-    : []
   const a = v.active as Record<string, unknown> | null | undefined
   if (a === null || a === undefined || typeof a.task_id !== 'string') {
-    return { active: null, open_tasks: open, archive }
+    return { active: null, open_tasks: open }
   }
 
   const recent = Array.isArray(a.recent)
@@ -86,7 +76,6 @@ export function parseState(stdout: string): JournalState | null {
       modules: Array.isArray(a.modules) ? a.modules.filter((m): m is string => typeof m === 'string') : [],
     },
     open_tasks: open,
-    archive,
   }
 }
 
@@ -101,48 +90,6 @@ export function statusText(state: JournalState): string | null {
   return `📓 ${a.task_id}${where} · ${n('decision')} decisions · ${n('rejection')} rejected · ${n('evidence')} evidence`
 }
 
-const GAP_TEXT: Record<string, (g: ArchiveGap) => string> = {
-  no_map: g =>
-    `no module map yet (${g.tasks} tasks) — map the project with /task-journal:map and confirm the modules with the user`,
-  unlinked_tasks: g =>
-    `${g.count} task(s) belong to no module — sort them with module_backfill_candidates, confirm with the user, then module_link (leftovers go to a catch-all module)`,
-  stale_module: g =>
-    `module ${g.module_id}: ${g.closed_since} closed task(s) not reflected in its state — read module_page and rewrite it with module_save(state=...)`,
-  task_without_module: g => `the active task ${g.task_id} belongs to no module — link it with module_link (module_list shows the map)`,
-}
-
-// The field that tells one gap of a kind from another; counts are left out,
-// so a gap whose count moved is not new.
-const GAP_SUBJECT: Record<string, string> = { stale_module: 'module_id', task_without_module: 'task_id' }
-
-function gapKey(gap: ArchiveGap): string {
-  const subject = GAP_SUBJECT[gap.kind]
-
-  return subject === undefined ? gap.kind : `${gap.kind}:${String(gap[subject])}`
-}
-
-/** Keys of the gaps a state names: what the session start already showed. */
-export function chronicleKeys(state: JournalState): string[] {
-  return state.archive.filter(g => GAP_TEXT[g.kind] !== undefined).map(gapKey)
-}
-
-/**
- * The chronicle gap to bring up, if one is new to this session (`seen`
- * holds the keys already shown). The session's own task without a module
- * comes first: it is the one gap the agent can close right now.
- */
-export function chronicleNudge(
-  state: JournalState,
-  seen: ReadonlySet<string> = new Set(),
-): { key: string; text: string } | null {
-  const fresh = state.archive.filter(g => GAP_TEXT[g.kind] !== undefined && !seen.has(gapKey(g)))
-  const gap = fresh.find(g => g.kind === 'task_without_module') ?? fresh[0]
-  const describe = gap === undefined ? undefined : GAP_TEXT[gap.kind]
-  if (gap === undefined || describe === undefined) return null
-
-  return { key: gapKey(gap), text: `📚 Chronicle: ${describe(gap)}. Close this gap once the current work is done.` }
-}
-
 /**
  * The system-prompt section. It sits before the conversation, so every
  * change re-sends the whole conversation uncached: it names only what
diff --git a/plugin/hooks/register.test.ts b/plugin/hooks/register.test.ts
index c6e2a99..d4c97ac 100644
--- a/plugin/hooks/register.test.ts
+++ b/plugin/hooks/register.test.ts
@@ -9,11 +9,17 @@ const state = (active: unknown) => JSON.stringify({ schema: 'tj-state/1', open_t
 const TASK = { task_id: 'tj-abc', title: 'Fix refresh', counts: { decision: 2 }, modules: ['auth'] }
 
 // The engine beneath the mod: `task-journal state` answers `stdout`, and
-// another plugin's band sits under the mod's line.
-function session(on: On, stdout: string) {
+// another plugin's band sits under the mod's line. `env` collects what the
+// mod sets for the hooks.
+function session(on: On, stdout: string, env: Record<string, string | undefined> = {}) {
   on('session.start', (_$, e) => ({ cwd: e.cwd }))
   on('session.id', () => ({ value: 'session-1' }))
   on('process.run', () => ({ value: ran(stdout) }))
+  on('env.set', (_$, e) => {
+    env[e.name] = e.value
+
+    return { value: undefined }
+  })
   on('ui.render', { component: 'AbovePrompt' }, ($, e) => $.ui.resolve(e).Text({ children: 'other band' }))
   mock.env(on, {})
 }
@@ -49,3 +55,14 @@ describe('band above the prompt', () => {
     expect(await band($)).toBe('other band')
   })
 })
+
+describe('hooks beside the mod', () => {
+  test('tells the hooks the plugin ships its own, also before the journal answers', async ($, on) => {
+    const set: Record<string, string | undefined> = {}
+    session(on, 'error: journal unreadable', set)
+    await $.session.start(START)
+
+    expect(set.TJ_PLUGIN_HOOKS).toBe('1')
+    expect(set.TJ_MOD_ACTIVE).toBe(undefined)
+  })
+})
diff --git a/plugin/hooks/register.tsx b/plugin/hooks/register.tsx
index c2ea6e3..e63fca1 100644
--- a/plugin/hooks/register.tsx
+++ b/plugin/hooks/register.tsx
@@ -7,20 +7,17 @@
 //   its own active task;
 // - shows the task in a band above the prompt and a toast on every entry;
 // - reminds the agent to log only after N turns without an entry;
-// - brings up a project-chronicle gap that opened during the session (the
-//   session start already showed the one it began with);
 // - before a compaction, asks the model (from its own prompt cache) what
 //   was not logged and records it as suggested events.
 //
 // It sets TJ_MOD_ACTIVE=1 for the hooks Claude Code starts, so the classic
 // hooks skip what the mod does here (the reminder, per-message
-// classification, the transcript catch-ups) and keep the rest.
+// classification, the transcript catch-ups), and TJ_PLUGIN_HOOKS=1, so a
+// hook left in settings.json leaves the rest to the plugin's own hooks.
 
 import type { EngineInterface, Register } from 'claude-code'
 
 import {
-  chronicleKeys,
-  chronicleNudge,
   compactInstruction,
   distillPrompt,
   journalTool,
@@ -67,9 +64,6 @@ const mod = {
   pinned: null as string | null,
   turnsSinceEntry: 0,
   workSinceEntry: 0,
-  // Chronicle gaps this session has been told about. Seeded at its start
-  // with every gap the SessionStart hook showed, so none is repeated.
-  chronicleSeen: new Set<string>(),
 }
 
 type CliResult =
@@ -131,10 +125,7 @@ async function refresh($: EngineInterface): Promise<void> {
     return
   }
 
-  if (mod.session !== session) {
-    mod.pinned = null
-    mod.chronicleSeen = new Set(chronicleKeys(state))
-  }
+  if (mod.session !== session) mod.pinned = null
   mod.session = session
   mod.state = state
   mod.pinned = state.active?.task_id ?? null
@@ -218,6 +209,9 @@ export const register: Register = (on, options) => {
     }
 
     mod.cwd = e.cwd
+    // The plugin's hooks run beside the mod; a task-journal hook an earlier
+    // version left in settings.json stands down when it sees this.
+    await $.env.set('TJ_PLUGIN_HOOKS', '1')
     await refresh($)
     if (mod.state !== null) await $.env.set('TJ_MOD_ACTIVE', '1')
 
@@ -231,7 +225,6 @@ export const register: Register = (on, options) => {
     mod.retryAt = 0
     mod.turnsSinceEntry = 0
     mod.workSinceEntry = 0
-    mod.chronicleSeen = new Set()
 
     return next(e)
   })
@@ -276,25 +269,17 @@ export const register: Register = (on, options) => {
     const state = await current($)
     if (state === null) return next(e)
 
-    // Both reminders ride in the prompt's context, never in the system
-    // prompt: a change there would re-send the conversation uncached.
-    const added: string[] = []
-    const chronicle = chronicleNudge(state, mod.chronicleSeen)
-    if (chronicle !== null) {
-      mod.chronicleSeen.add(chronicle.key)
-      added.push(chronicle.text)
-    }
-
+    // The reminder rides in the prompt's context, never in the system
+    // prompt: a change there would re-send the conversation uncached. The
+    // chronicle's gaps are on request (module_list), not reminders.
     mod.turnsSinceEntry += 1
     const isDue =
       nudgeAfter > 0 && mod.turnsSinceEntry > nudgeAfter && (state.active !== null || mod.workSinceEntry > 0)
-    if (isDue) {
-      mod.turnsSinceEntry = 0
-      added.push(nudgeText(state, nudgeAfter))
-    }
-    if (added.length === 0) return next(e)
+    if (!isDue) return next(e)
+
+    mod.turnsSinceEntry = 0
 
-    return next({ ...e, context: [...(e.context ?? []), ...added] })
+    return next({ ...e, context: [...(e.context ?? []), nudgeText(state, nudgeAfter)] })
   })
 
   on('tool.call', async ($, e, next) => {
diff --git a/plugin/skills/task-journal/SKILL.md b/plugin/skills/task-journal/SKILL.md
index d05bc22..57d85f7 100644
--- a/plugin/skills/task-journal/SKILL.md
+++ b/plugin/skills/task-journal/SKILL.md
@@ -124,9 +124,9 @@ apply, and its tasks join their history.
 - **Done:** `task_close(..., module_notes=[{"module": "stars", "text": "ranking by Wilson score"}])`
   — one line per module on what changed. If the module works differently now, rewrite its
   `state` with `module_save(module_id, state=...)`.
-- **Gaps:** a line starting with `📚 Chronicle:` (session start, `task_create`, `module_list`)
-  names what the chronicle is missing — no map, tasks without a module, a module whose
-  state lags behind its tasks. Close it once the current work is done.
+- **Gaps:** `module_list` (its `📚 Chronicle: …` line and `gaps`) names what the chronicle is
+  missing — no map, tasks without a module, a module whose state lags behind its tasks.
+  Check it when the user asks about the map, or once the current work is done.
 
 ### Mapping a project (no map yet, or `/task-journal:map`)
 

From b775c29514d7a78d5bcf065411f966962265e8b3 Mon Sep 17 00:00:00 2001
From: Mher Shahinyan <shahinyanm@gmail.com>
Date: Fri, 6 Nov 2026 10:33:52 +0400
Subject: [PATCH 2/5] fix: review fixes: safer cleanup-noise, keep tool
 evidence, tighter recall, one model-switch record

---
 CHANGELOG.md                               |  41 ++-
 INSTALL.md                                 |   8 +-
 README.md                                  |   2 +-
 crates/tj-cli/src/main.rs                  | 359 ++++++++++++++++-----
 crates/tj-cli/tests/cli.rs                 | 233 +++++++++++++
 crates/tj-core/src/classifier/heuristic.rs |   6 +
 crates/tj-core/src/classifier/mod.rs       |  83 ++++-
 crates/tj-core/src/recall.rs               |  59 +++-
 crates/tj-core/src/session/extractor.rs    |  44 ++-
 crates/tj-core/src/storage.rs              |  38 +++
 10 files changed, 730 insertions(+), 143 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 22a4d8a..8305ae7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,8 +14,10 @@ added to tool results 13,696 times, almost never about the work at hand.
 - **Push-recall only on a strong match with the session's task.** A hit must be a
   rejection or decision the agent or the user recorded (classifier output is not
   trusted) on the session's active task or a task of the same module, sharing a
-  file, issue or commit with the tool call, or at least three meaningful words —
-  one shared word used to be enough. Paths count as files, not words. No session
+  file, issue or commit with the tool call, or at least three meaningful words
+  (more for a long call) — one shared word used to be enough. Paths count as
+  files, not words; what an edit writes (`content`, `old_string`, `new_string`)
+  doesn't count at all; `UTF-8` or `SHA-256` is not an issue key. No session
   task, no recall. At most one hit, at most once per ten tool calls of a session
   (`TJ_RECALL_EVERY`), never for the journal's own tools. It arrives as
   `additionalContext` for every tool: the async hook's `updatedMCPToolOutput`
@@ -33,23 +35,32 @@ added to tool results 13,696 times, almost never about the work at hand.
   push-recall and model switches (`ingest-hook --from-plugin`, never the classifier
   queue). `install-hooks` for Claude Code now only takes the hooks earlier versions
   wrote out of `settings.json`, after copying it to
-  `settings.json.task-journal-backup-<time>`; Codex is unchanged. While the mod runs,
-  a hook still left in `settings.json` stands down, so no event is handled twice.
-  `--auto-capture` and `--proactive-recall` no longer apply to Claude Code.
+  `settings.json.task-journal-backup-<time>`, and only once it finds an installed
+  plugin that ships the hooks; Codex is unchanged. Beside the plugin's hooks (the mod
+  sets `TJ_PLUGIN_HOOKS`), a hook, `nudge` or `recall-hook` still left in
+  `settings.json` stands down, and a model switch is recorded once even where both
+  run (Claude Code without the mod). `--auto-capture` and `--proactive-recall` no
+  longer apply to Claude Code, and `/rewind` in a prompt is no longer recorded there
+  (the built-in command never reached the hook).
 - **The classic nudge runs on a session's first prompt and then every sixth**
   (`TJ_NUDGE_EVERY`), not on every prompt, and no longer shouts.
-- **A rejection is an approach ruled out in so many words** ("decided against",
-  "ruled out", "отказались от", "tried X … didn't work"), at most 600 characters.
-  The classifier and `backfill` no longer file bug reports, log lines or whole
-  answers as rejections, and the classifier drops raw tool calls, compaction
-  summaries and notifications instead of recording them.
+- **Rejections.** The keyword heuristic and `backfill` file a rejection only for an
+  approach ruled out in so many words ("decided against", "ruled out",
+  "Rejected: …", "отказались от", "tried X … didn't work"), not for a bug report, a
+  log line or a test report. Whatever its words, a classified rejection must read
+  like one: at most 600 characters, no paragraphs, headings, tables or code, not a
+  question. The classifier drops compaction summaries and notifications, and a raw
+  tool call unless it is evidence.
 
 ### Added
-- `task-journal cleanup-noise [--dry-run] [--all]` retires what the classifier once
-  filed as reasoning but is not: raw tool calls, compaction summaries, harness
-  notifications, and rejections that rule no approach out. Each gets a correction
-  (the journal stays append-only), which keeps it out of packs, recall and exports
-  without moving its task up the "newest first" lists. Only classifier entries are
+- `task-journal cleanup-noise [--dry-run] [--all] [--yes]` retires what the
+  classifier once filed as reasoning but is not: raw tool calls (except as
+  evidence), compaction summaries, harness notifications, and "rejections" that are
+  whole answers or questions. Each gets a correction stamped with the entry's own
+  time (the journal stays append-only), which keeps it out of packs and recall
+  without moving anything in the "newest first" views. A correction cannot be taken
+  back: `--dry-run` lists every entry in a file, and `--all` writes only with
+  `--yes`. Only classifier entries and old `backfill` keyword rejections are
   touched.
 
 ## [0.31.2] - 2026-10-05
diff --git a/INSTALL.md b/INSTALL.md
index 42d6187..afb1941 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -79,9 +79,11 @@ the model-switch record. Full packs, honesty scores and chronicle gaps are on
 request (`task_pack`, `task-journal check`, `module_list`).
 
 If an earlier version's `task-journal install-hooks` wrote hooks into
-`settings.json`, run it once more: for Claude Code it now only takes them out,
-after copying the file to `settings.json.task-journal-backup-<time>`. Until
-then they stand down while the mod runs, so no event is handled twice.
+`settings.json`, update the plugin, restart Claude Code and run it once more:
+for Claude Code it now only takes them out, after copying the file to
+`settings.json.task-journal-backup-<time>` — and only once it finds the
+installed plugin's hooks. Until then they stand down beside the plugin's hooks,
+so no event is handled twice.
 
 ### Older Claude Code, or without the plugin
 
diff --git a/README.md b/README.md
index 429fc76..6f6a719 100644
--- a/README.md
+++ b/README.md
@@ -197,7 +197,7 @@ task-journal pack tj-x9rz1f --mode full
 | `rebuild-state` | Rebuild SQLite from JSONL |
 | `migrate-project` | Re-key data when a project moves on disk |
 | `install-hooks [--client claude\|codex] [--scope user\|project] [--auto-capture] [--backend hybrid\|agent-sdk\|api\|heuristic]` | Codex: wire its hooks (default: the read-only SessionStart hook; `--auto-capture` adds the per-message classifier). Claude Code: its hooks come with the plugin, so this takes the ones earlier versions wrote out of `settings.json`, after a backup. |
-| `cleanup-noise [--dry-run] [--all]` | Retire what the classifier once filed as reasoning but is not — raw tool calls, compaction summaries, notifications, "rejections" that rule no approach out — with one correction each (the journal stays append-only). |
+| `cleanup-noise [--dry-run] [--all] [--yes]` | Retire what the classifier once filed as reasoning but is not — raw tool calls, compaction summaries, notifications, "rejections" that are whole answers — with one correction each (the journal stays append-only, and a correction cannot be taken back). `--dry-run` lists every entry in a file; `--all` writes only with `--yes`. |
 
 ## MCP tools
 
diff --git a/crates/tj-cli/src/main.rs b/crates/tj-cli/src/main.rs
index 92a5c1e..5d2128d 100644
--- a/crates/tj-cli/src/main.rs
+++ b/crates/tj-cli/src/main.rs
@@ -1238,17 +1238,21 @@ enum Commands {
         all: bool,
     },
     /// Retire what the classifier once filed as reasoning but is not: raw
-    /// tool calls, compaction summaries, harness notifications, and
-    /// "rejections" that rule no approach out. The journal is append-only,
-    /// so each one gets a correction, which takes it out of packs, recall and
-    /// exports. Only classifier entries are touched, never the agent's or yours.
+    /// tool calls (except as evidence), compaction summaries, harness
+    /// notifications, and "rejections" that are whole answers or questions.
+    /// The journal is append-only, so each one gets a correction, which keeps
+    /// it out of packs and recall — and cannot be taken back. Only classifier
+    /// and old backfill-keyword entries are touched, never the agent's or yours.
     CleanupNoise {
-        /// Show what would be retired; write nothing.
+        /// Write nothing; list every entry that would be retired in a file.
         #[arg(long)]
         dry_run: bool,
         /// Clean every project's journal, not just the current one.
         #[arg(long)]
         all: bool,
+        /// Confirm writing to every journal with --all.
+        #[arg(long)]
+        yes: bool,
     },
     /// Set or update the goal of an existing task.
     Goal {
@@ -2282,8 +2286,8 @@ fn real_main() -> Result<()> {
                 );
             }
         }
-        Commands::CleanupNoise { dry_run, all } => {
-            run_cleanup_noise(dry_run, all)?;
+        Commands::CleanupNoise { dry_run, all, yes } => {
+            run_cleanup_noise(dry_run, all, yes)?;
         }
         Commands::PendingGc { days, all } => {
             let pending_dir = tj_core::paths::events_dir()?
@@ -2515,6 +2519,19 @@ fn real_main() -> Result<()> {
             // settings.json entries earlier versions wrote ran next to them,
             // so for Claude Code this only takes ours out again.
             let is_claude = client == "claude";
+            // Taking ours out is only safe once the plugin's own hooks are
+            // there to take over; otherwise the session-start line, recall
+            // and model switches would just stop.
+            if is_claude && !uninstall && !plugin_ships_hooks() {
+                eprintln!(
+                    "The installed task-journal plugin ships no hooks yet (or is not installed), \
+                     so the ones in {} stay. Update the plugin (/plugin update \
+                     task-journal@task-journal), restart Claude Code, then run this again. To \
+                     remove them anyway: --uninstall.",
+                    settings_path.display()
+                );
+                return Ok(());
+            }
             if uninstall || is_claude {
                 remove_task_journal_hooks(hooks_obj);
                 if is_claude && !uninstall && (auto_capture || proactive_recall) {
@@ -2993,10 +3010,26 @@ never closes tasks."
                 // MODEL_SWITCH_TEXT_PREFIX.
                 event.meta = serde_json::json!({ "kind": "model_switch" });
                 tj_core::session_id::stamp_session_id(&mut event.meta, live_session_id.as_deref());
+                // Claude Code without the mod runs the plugin's hook and one
+                // left in settings.json side by side: one switch, one record.
                 let mut writer = tj_core::storage::JsonlWriter::open(&events_path)?;
-                writer.append(&event)?;
-                writer.flush_durable()?;
-                println!("{}", event.event_id);
+                let now = chrono::Utc::now();
+                let appended = writer.append_unless(&event, |tail| {
+                    tail.lines()
+                        .filter_map(|l| serde_json::from_str::<tj_core::event::Event>(l).ok())
+                        .any(|e| {
+                            e.task_id == event.task_id
+                                && e.text == event.text
+                                && e.meta.get("kind") == event.meta.get("kind")
+                                && chrono::DateTime::parse_from_rfc3339(&e.timestamp).is_ok_and(
+                                    |t| (now - t.with_timezone(&chrono::Utc)).num_seconds() < 60,
+                                )
+                        })
+                })?;
+                if appended {
+                    writer.flush_durable()?;
+                    println!("{}", event.event_id);
+                }
                 return Ok(());
             }
 
@@ -3400,7 +3433,7 @@ never closes tasks."
                     let Some(tid) = out.task_id_guess else {
                         return Ok(());
                     };
-                    if !worth_recording(out.event_type, &out.suggested_text, &text) {
+                    if !worth_recording(out.event_type, &out.suggested_text) {
                         return Ok(());
                     }
 
@@ -4791,8 +4824,9 @@ fn run_nudge() -> anyhow::Result<()> {
     if std::env::var(tj_core::classifier::agent_sdk::IN_CLASSIFIER_ENV).is_ok() {
         return Ok(());
     }
-    // The Claude Code mod nudges by itself (after N turns without an entry).
-    if mod_active() {
+    // The Claude Code mod nudges by itself (after N turns without an entry),
+    // and beside the plugin's hooks a leftover settings.json hook stands down.
+    if mod_active() || env_flag("TJ_PLUGIN_HOOKS") {
         return Ok(());
     }
 
@@ -4916,7 +4950,9 @@ fn run_session_end_catchup(
 /// or error exits silently with no output.
 fn run_recall_hook() -> anyhow::Result<()> {
     // Opt-out and recursion guard (never inject into our own classifier spawn).
-    if std::env::var("TJ_PROACTIVE_RECALL").as_deref() == Ok("0") {
+    // Beside the plugin's hooks, a recall-hook left in settings.json stands
+    // down: the plugin's push-recall is the one, scoped to the session's task.
+    if std::env::var("TJ_PROACTIVE_RECALL").as_deref() == Ok("0") || env_flag("TJ_PLUGIN_HOOKS") {
         return Ok(());
     }
     if std::env::var(tj_core::classifier::agent_sdk::IN_CLASSIFIER_ENV).is_ok() {
@@ -4963,7 +4999,10 @@ fn run_recall_hook() -> anyhow::Result<()> {
     let mut ctx = String::from(
         "📓 task-journal — relevant prior reasoning from your history (you may have decided this before):\n",
     );
-    for h in &hits {
+    for h in hits
+        .iter()
+        .filter(|h| tj_core::noise::machine_text(&h.text).is_none())
+    {
         let snippet: String = h.text.chars().take(160).collect();
         let proj: String = h.project_hash.chars().take(8).collect();
         let line = format!(
@@ -5089,39 +5128,66 @@ fn session_start_line(
 
 /// The open task the branch names: one whose events carry the branch, or
 /// carry (or whose title holds) the issue key in it — `feat/DEV-4621-x`
-/// names DEV-4621. Newest first.
+/// names DEV-4621, and DEV-46 is not DEV-4621. Newest first.
 fn task_for_branch(conn: &rusqlite::Connection, branch: &str) -> anyhow::Result<Option<String>> {
     use rusqlite::OptionalExtension;
 
-    let mut needles = vec![(branch.to_string(), false)];
-    needles.extend(
-        tj_core::artifacts::extract(branch)
-            .linked_issues
-            .into_iter()
-            .map(|issue| (issue, true)),
-    );
+    // An exact element of an event's artifacts, quotes included; `_` and
+    // `%` in a branch name are literal.
+    let escape = |s: &str| {
+        s.replace('\\', "\\\\")
+            .replace('%', "\\%")
+            .replace('_', "\\_")
+    };
+    let by_artifact = |needle: &str| -> rusqlite::Result<Option<String>> {
+        conn.query_row(
+            "SELECT t.task_id FROM tasks t
+             WHERE t.status = 'open'
+               AND EXISTS (SELECT 1 FROM events_index ei
+                           WHERE ei.task_id = t.task_id AND ei.artifacts LIKE ?1 ESCAPE '\\')
+             ORDER BY t.last_event_at DESC LIMIT 1",
+            rusqlite::params![format!("%\"{}\"%", escape(needle))],
+            |r| r.get(0),
+        )
+        .optional()
+    };
+    if let Some(id) = by_artifact(branch)? {
+        return Ok(Some(id));
+    }
 
-    for (needle, by_title) in needles {
-        let id: Option<String> = conn
-            .query_row(
-                "SELECT t.task_id FROM tasks t
-                 WHERE t.status = 'open'
-                   AND ((?3 AND t.title LIKE ?2)
-                        OR EXISTS (SELECT 1 FROM events_index ei
-                                   WHERE ei.task_id = t.task_id AND ei.artifacts LIKE ?1))
-                 ORDER BY t.last_event_at DESC LIMIT 1",
-                rusqlite::params![format!("%\"{needle}\"%"), format!("%{needle}%"), by_title],
-                |r| r.get(0),
-            )
-            .optional()?;
-        if id.is_some() {
-            return Ok(id);
+    let issues = tj_core::artifacts::extract(branch).linked_issues;
+    if issues.is_empty() {
+        return Ok(None);
+    }
+    let mut stmt = conn.prepare(
+        "SELECT task_id, title FROM tasks WHERE status = 'open' ORDER BY last_event_at DESC",
+    )?;
+    let open: Vec<(String, String)> = stmt
+        .query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?
+        .collect::<Result<_, _>>()?;
+    for issue in &issues {
+        if let Some(id) = by_artifact(issue)? {
+            return Ok(Some(id));
+        }
+        if let Some((id, _)) = open.iter().find(|(_, title)| holds_key(title, issue)) {
+            return Ok(Some(id.clone()));
         }
     }
 
     Ok(None)
 }
 
+/// Whether `text` holds `key` as a whole token: no letter or digit right
+/// before or after it.
+fn holds_key(text: &str, key: &str) -> bool {
+    text.match_indices(key).any(|(at, _)| {
+        let before = text[..at].chars().next_back();
+        let after = text[at + key.len()..].chars().next();
+
+        !before.is_some_and(char::is_alphanumeric) && !after.is_some_and(char::is_alphanumeric)
+    })
+}
+
 /// The checked-out branch of the repository holding `dir`, read from its
 /// `HEAD` (a worktree's `.git` file points at its own). `None` outside a
 /// repository or on a detached HEAD.
@@ -5161,6 +5227,35 @@ fn emit_session_context(ctx: &str) {
     println!("{env}");
 }
 
+/// Whether an installed task-journal plugin ships the hooks that replace the
+/// settings.json ones: its `hooks/hooks.json` runs `ingest-hook --from-plugin`.
+/// Read from Claude Code's plugin registry (`$CLAUDE_CONFIG_DIR`, else
+/// `~/.claude`); false when it cannot be read.
+fn plugin_ships_hooks() -> bool {
+    let config = std::env::var_os("CLAUDE_CONFIG_DIR")
+        .map(std::path::PathBuf::from)
+        .or_else(|| std::env::var_os("HOME").map(|h| std::path::PathBuf::from(h).join(".claude")));
+    let Some(registry) = config
+        .map(|c| c.join("plugins").join("installed_plugins.json"))
+        .and_then(|p| std::fs::read_to_string(p).ok())
+        .and_then(|body| serde_json::from_str::<serde_json::Value>(&body).ok())
+    else {
+        return false;
+    };
+
+    registry["plugins"]
+        .as_object()
+        .into_iter()
+        .flatten()
+        .filter(|(name, _)| name.starts_with("task-journal@"))
+        .flat_map(|(_, installs)| installs.as_array().into_iter().flatten())
+        .filter_map(|install| install["installPath"].as_str())
+        .any(|path| {
+            std::fs::read_to_string(std::path::Path::new(path).join("hooks").join("hooks.json"))
+                .is_ok_and(|hooks| hooks.contains("--from-plugin"))
+        })
+}
+
 /// Takes task-journal's hooks (`ingest-hook`, `nudge`, `recall-hook`) and its
 /// legacy env key out of a settings.json / hooks.json object. Surgical: other
 /// tools' hooks and env entries stay (the old `remove("hooks")` nuked
@@ -5214,9 +5309,13 @@ fn remove_task_journal_hooks(settings: &mut serde_json::Map<String, serde_json::
     }
 }
 
-/// Why `event` is noise the classifier filed as reasoning, or `None` when it
-/// stays: only classifier entries of a reasoning type are judged — machine
-/// text of any type, and a rejection that rules no approach out.
+/// Why `event` is noise filed as reasoning, or `None` when it stays. Judged
+/// are the classifier's entries of a reasoning type and the rejections the
+/// old `backfill` keyword rule wrote; the agent's and the user's own never.
+/// Retired: a compaction summary or a notification; a raw tool call, except
+/// as evidence (a test run's record is the call); a "rejection" that is a
+/// whole answer or a question. A short rejection stays whatever its words —
+/// a correction cannot be taken back, so this errs on keeping.
 fn cleanup_reason(event: &tj_core::event::Event) -> Option<&'static str> {
     use tj_core::event::{Author, EventType};
 
@@ -5229,23 +5328,37 @@ fn cleanup_reason(event: &tj_core::event::Event) -> Option<&'static str> {
             | EventType::Hypothesis
             | EventType::Constraint
     );
+    let by_classifier = event.author == Author::Classifier;
+    let by_backfill_keyword = event.event_type == EventType::Rejection
+        && event.meta.get("heuristic").and_then(|v| v.as_str()) == Some("rejection_keyword");
     // Compaction markers and model switches are the journal's own
     // bookkeeping, already kept out of packs and recall.
-    if event.author != Author::Classifier || !reasoning || tj_core::db::is_bookkeeping(event) {
+    if !reasoning || !(by_classifier || by_backfill_keyword) || tj_core::db::is_bookkeeping(event) {
         return None;
     }
 
-    tj_core::noise::machine_text(&event.text).or_else(|| {
-        (event.event_type == EventType::Rejection
-            && !tj_core::classifier::is_explicit_rejection(&event.text))
-        .then_some("rejection that rules no approach out")
-    })
+    match tj_core::noise::machine_text(&event.text) {
+        Some("raw tool call") if event.event_type == EventType::Evidence => None,
+        Some(why) => Some(why),
+        None => (event.event_type == EventType::Rejection
+            && !tj_core::classifier::reads_like_a_rejection(&event.text))
+        .then_some("rejection that is a whole answer or a question"),
+    }
 }
 
-/// `task-journal cleanup-noise [--dry-run] [--all]`: one bookkeeping
+/// `task-journal cleanup-noise [--dry-run] [--all] [--yes]`: one bookkeeping
 /// correction per noise entry not corrected yet, so a second run finds
-/// nothing. Prints counts by reason per journal, with samples on a dry run.
-fn run_cleanup_noise(dry_run: bool, all: bool) -> Result<()> {
+/// nothing. A correction cannot be taken back, so a dry run writes the full
+/// list to a file to read first, and writing to every journal (`--all`)
+/// needs `--yes`.
+fn run_cleanup_noise(dry_run: bool, all: bool, yes: bool) -> Result<()> {
+    if all && !dry_run && !yes {
+        anyhow::bail!(
+            "--all writes a correction into every project's journal, and a correction cannot be \
+             taken back: run with --dry-run first, read the list it writes, then add --yes"
+        );
+    }
+
     let events_dir = tj_core::paths::events_dir()?;
     let journals: Vec<std::path::PathBuf> = if all {
         let mut paths: Vec<_> = std::fs::read_dir(&events_dir)?
@@ -5260,6 +5373,7 @@ fn run_cleanup_noise(dry_run: bool, all: bool) -> Result<()> {
     };
 
     let mut total = 0usize;
+    let mut listing = String::from("journal\tevent_id\ttask_id\ttype\treason\ttext\n");
     for path in journals.iter().filter(|p| p.exists()) {
         let events = read_events_lenient(path, "cleanup-noise")?;
         let corrected: std::collections::HashSet<&str> = events
@@ -5275,25 +5389,28 @@ fn run_cleanup_noise(dry_run: bool, all: bool) -> Result<()> {
             continue;
         }
 
-        let mut by_reason: std::collections::BTreeMap<&str, Vec<&tj_core::event::Event>> =
-            Default::default();
+        let name = path.file_stem().and_then(|n| n.to_str()).unwrap_or("?");
+        let mut by_reason: std::collections::BTreeMap<&str, usize> = Default::default();
         for (e, why) in &noise {
-            by_reason.entry(why).or_default().push(e);
+            *by_reason.entry(why).or_default() += 1;
+            let text: String = e
+                .text
+                .chars()
+                .take(300)
+                .map(|c| if c == '\t' || c == '\n' { ' ' } else { c })
+                .collect();
+            listing.push_str(&format!(
+                "{name}\t{}\t{}\t{:?}\t{why}\t{text}\n",
+                e.event_id, e.task_id, e.event_type
+            ));
         }
-        let name = path.file_stem().and_then(|n| n.to_str()).unwrap_or("?");
         println!(
             "{name}: {} entr{}",
             noise.len(),
             if noise.len() == 1 { "y" } else { "ies" }
         );
-        for (why, list) in &by_reason {
-            println!("  {why}: {}", list.len());
-            if dry_run {
-                for e in list.iter().take(3) {
-                    let sample: String = e.text.chars().take(100).collect();
-                    println!("    {:?}: {}", e.event_type, sample.replace('\n', " "));
-                }
-            }
+        for (why, n) in &by_reason {
+            println!("  {why}: {n}");
         }
         total += noise.len();
 
@@ -5307,6 +5424,10 @@ fn run_cleanup_noise(dry_run: bool, all: bool) -> Result<()> {
                     tj_core::event::Source::Cli,
                     format!("{} not reasoning: {why}", tj_core::noise::CLEANUP_PREFIX),
                 );
+                // The entry's own time: a correction stamped "now" would
+                // crowd the newest-first views (recent events, the catch-up
+                // point, the classifier's context) out of real entries.
+                fix.timestamp = e.timestamp.clone();
                 fix.corrects = Some(e.event_id.clone());
                 fix.status = tj_core::event::EventStatus::Confirmed;
                 fix.meta = serde_json::json!({ "kind": tj_core::db::NOISE_CLEANUP });
@@ -5316,10 +5437,22 @@ fn run_cleanup_noise(dry_run: bool, all: bool) -> Result<()> {
         }
     }
 
-    match (total, dry_run) {
-        (0, _) => println!("nothing to clean"),
-        (n, true) => println!("{n} entries would be retired; run without --dry-run to retire them"),
-        (n, false) => println!("{n} entries retired"),
+    if total == 0 {
+        println!("nothing to clean");
+    } else if dry_run {
+        let stamp = chrono::Utc::now().format("%Y%m%d%H%M%S");
+        let list = tj_core::paths::data_dir()?.join(format!("cleanup-noise-{stamp}.tsv"));
+        std::fs::write(&list, listing)?;
+        println!(
+            "{total} entries would be retired; every one is listed in {}",
+            list.display()
+        );
+        println!(
+            "run without --dry-run{} to retire them",
+            if all { " and with --yes" } else { "" }
+        );
+    } else {
+        println!("{total} entries retired");
     }
 
     Ok(())
@@ -6513,24 +6646,22 @@ fn process_pending_entry(
     Ok(())
 }
 
-/// Whether a classified chunk is worth an event: its text is reasoning, not
-/// a raw tool call, a summary or a notification, and a rejection rules an
-/// approach out in so many words. Whole answers, tool payloads and summaries
-/// filed as rejections were most of what recall later pushed back.
-fn worth_recording(
-    event_type: tj_core::event::EventType,
-    suggested_text: &str,
-    chunk: &str,
-) -> bool {
-    use tj_core::classifier::is_explicit_rejection;
+/// Whether a classified chunk is worth an event. Never a compaction summary
+/// or a notification; a raw tool call only as evidence (a test run is
+/// evidence by nature, and its record is the call). A rejection must read
+/// like one — a sentence or two, not a whole answer — whatever its words:
+/// the model phrases a ruled-out approach any way it likes.
+fn worth_recording(event_type: tj_core::event::EventType, suggested_text: &str) -> bool {
+    use tj_core::event::EventType;
 
-    if tj_core::noise::machine_text(suggested_text).is_some() {
-        return false;
+    match tj_core::noise::machine_text(suggested_text) {
+        Some("raw tool call") if event_type == EventType::Evidence => true,
+        Some(_) => false,
+        None => {
+            event_type != EventType::Rejection
+                || tj_core::classifier::reads_like_a_rejection(suggested_text)
+        }
     }
-
-    event_type != tj_core::event::EventType::Rejection
-        || is_explicit_rejection(suggested_text)
-        || is_explicit_rejection(chunk)
 }
 
 /// What became of one classified chunk.
@@ -6646,7 +6777,7 @@ fn classify_chunk(
     let Some(tid) = out.task_id_guess else {
         return Ok(ChunkOutcome::Dropped);
     };
-    if !worth_recording(out.event_type, &out.suggested_text, text) {
+    if !worth_recording(out.event_type, &out.suggested_text) {
         return Ok(ChunkOutcome::Dropped);
     }
 
@@ -6838,14 +6969,22 @@ fn session_recall(
 }
 
 /// What a tool call did, as text: the string values of its input, without
-/// the JSON keys (`file_path`, `old_string` say nothing about the work) and
-/// without the output (a log or a file's content is not the agent's intent).
+/// the JSON keys (`file_path` says nothing about the work), without the
+/// output (a log or a file's content is not the agent's intent), and without
+/// what an edit writes (`content`, `old_string`, `new_string`, `new_source`):
+/// a big file shares three words with nearly any note. An edit still counts
+/// by its path.
 fn tool_input_text(payload: &serde_json::Value) -> String {
+    const WRITTEN: &[&str] = &["content", "old_string", "new_string", "new_source"];
+
     fn strings<'a>(v: &'a serde_json::Value, out: &mut Vec<&'a str>) {
         match v {
             serde_json::Value::String(s) => out.push(s),
             serde_json::Value::Array(items) => items.iter().for_each(|x| strings(x, out)),
-            serde_json::Value::Object(map) => map.values().for_each(|x| strings(x, out)),
+            serde_json::Value::Object(map) => map
+                .iter()
+                .filter(|(k, _)| !WRITTEN.contains(&k.as_str()))
+                .for_each(|(_, x)| strings(x, out)),
             _ => {}
         }
     }
@@ -6891,7 +7030,8 @@ const SESSION_COUNTER_CAP: usize = 500;
 /// `next(current)` and returns the new value. Best-effort: an unreadable file
 /// counts as empty, a failed write is ignored.
 // ponytail: read-modify-write without a lock; two parallel hooks can lose
-// one count, which only shifts the next reminder by a call.
+// one count, which only shifts the next reminder by a call. The file itself
+// is never seen half-written (see `write_whole`).
 fn session_counter(
     path: &std::path::Path,
     sid: &str,
@@ -6911,11 +7051,21 @@ fn session_counter(
     let own = format!("{sid} {value}");
     lines.push(&own);
     let keep = &lines[lines.len().saturating_sub(SESSION_COUNTER_CAP)..];
-    let _ = std::fs::write(path, keep.join("\n") + "\n");
+    write_whole(path, &(keep.join("\n") + "\n"));
 
     value
 }
 
+/// Replaces `path` with `body` through a temporary file and a rename, so a
+/// hook reading it in parallel sees the old file or the new one, never an
+/// empty one it would then write back over everyone's lines. Best-effort.
+fn write_whole(path: &std::path::Path, body: &str) {
+    let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
+    if std::fs::write(&tmp, body).is_ok() && std::fs::rename(&tmp, path).is_err() {
+        let _ = std::fs::remove_file(&tmp);
+    }
+}
+
 /// Most `<session> <event_id>` lines the shown-recall log keeps.
 const RECALL_SHOWN_CAP: usize = 2000;
 
@@ -6961,7 +7111,7 @@ fn fresh_recall_hits(
     let mut lines: Vec<String> = body.lines().map(str::to_string).collect();
     lines.extend(fresh.iter().map(|h| format!("{sid} {}", h.event_id)));
     let keep = &lines[lines.len().saturating_sub(RECALL_SHOWN_CAP)..];
-    let _ = std::fs::write(&log, keep.join("\n") + "\n");
+    write_whole(&log, &(keep.join("\n") + "\n"));
 
     fresh
 }
@@ -7277,6 +7427,37 @@ mod inline_tests {
         assert_eq!(recall_hits_json(&[]), "[]");
     }
 
+    /// A branch names an issue as a whole token: DEV-46 is not DEV-4621.
+    #[test]
+    fn holds_key_needs_a_whole_token() {
+        assert!(holds_key("DEV-4621: move the write path", "DEV-4621"));
+        assert!(holds_key("Fix (DEV-46) redirect", "DEV-46"));
+        assert!(!holds_key("DEV-4621: move the write path", "DEV-46"));
+        assert!(!holds_key("XDEV-46 thing", "DEV-46"));
+    }
+
+    /// What an edit writes is not the agent's intent; its path and a
+    /// command's words are.
+    #[test]
+    fn tool_input_text_skips_what_an_edit_writes() {
+        let edit = serde_json::json!({ "tool_input": {
+            "file_path": "src/pack.rs",
+            "old_string": "fn rejected_state() {}",
+            "new_string": "fn plain_state_file() {}",
+            "edits": [{ "old_string": "a", "new_string": "b" }],
+        }});
+        assert_eq!(tool_input_text(&edit), "src/pack.rs");
+
+        let bash = serde_json::json!({ "tool_input": {
+            "command": "cargo test", "description": "Run the tests",
+        }});
+        let text = tool_input_text(&bash);
+        assert!(
+            text.contains("cargo test") && text.contains("Run the tests"),
+            "{text}"
+        );
+    }
+
     #[test]
     fn fmt_tokens_scales_units() {
         assert_eq!(fmt_tokens(980), "980");
diff --git a/crates/tj-cli/tests/cli.rs b/crates/tj-cli/tests/cli.rs
index 36ca1b5..a6af2f0 100644
--- a/crates/tj-cli/tests/cli.rs
+++ b/crates/tj-cli/tests/cli.rs
@@ -25,6 +25,7 @@ impl Command {
             "TJ_PLUGIN_HOOKS",
             "TJ_RECALL_EVERY",
             "TJ_NUDGE_EVERY",
+            "CLAUDE_CONFIG_DIR",
         ] {
             cmd.env_remove(var);
         }
@@ -1720,6 +1721,156 @@ fn event_correct_links_to_corrected_event() {
         .stdout(contains("Migration was NOT done").and(contains("[correction]")));
 }
 
+/// A task-journal plugin in Claude Code's registry under `home`, shipping
+/// the hooks that replace the settings.json ones.
+fn install_plugin_with_hooks(home: &std::path::Path) {
+    let install = home.join("plugin-cache").join("task-journal");
+    std::fs::create_dir_all(install.join("hooks")).unwrap();
+    std::fs::write(
+        install.join("hooks").join("hooks.json"),
+        r#"{"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"task-journal ingest-hook --from-plugin || true"}]}]}}"#,
+    )
+    .unwrap();
+    let registry = home.join(".claude").join("plugins");
+    std::fs::create_dir_all(&registry).unwrap();
+    std::fs::write(
+        registry.join("installed_plugins.json"),
+        serde_json::json!({
+            "version": 2,
+            "plugins": { "task-journal@task-journal": [{ "installPath": install }] }
+        })
+        .to_string(),
+    )
+    .unwrap();
+}
+
+/// cleanup-noise retires only plain noise: a whole answer filed as a
+/// rejection and a raw tool call filed as a decision go; a short rejection
+/// in the classifier's own words and a test run's evidence stay. A dry run
+/// writes nothing but the full list; corrections keep the entries' own time,
+/// so the newest real entry still leads the pack's recent events.
+#[test]
+fn cleanup_noise_retires_only_plain_noise() {
+    use tj_core::event::{Author, Event, EventStatus, EventType, Source};
+
+    let xdg = assert_fs::TempDir::new().unwrap();
+    let proj = assert_fs::TempDir::new().unwrap();
+    let tj = || {
+        let mut c = Command::cargo_bin("task-journal").unwrap();
+        c.env("XDG_DATA_HOME", xdg.path()).current_dir(proj.path());
+        c
+    };
+    let task = String::from_utf8(
+        tj().args(["create", "Cleanup host"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap()
+    .trim()
+    .to_string();
+    let hash = tj_core::project_hash::from_path(proj.path()).unwrap();
+    let journal_path = xdg
+        .path()
+        .join("task-journal")
+        .join("events")
+        .join(format!("{hash}.jsonl"));
+
+    let mut writer = tj_core::storage::JsonlWriter::open(&journal_path).unwrap();
+    for (ty, text) in [
+        (
+            EventType::Rejection,
+            "## Release\n\nThe PR was rejected once by CI, then merged.",
+        ),
+        (
+            EventType::Decision,
+            r#"Bash: {"command":"git push"} → {"stdout":""}"#,
+        ),
+        (
+            EventType::Rejection,
+            "Unsplash was rejected as the demo photo source: its licence forbids hot-linking.",
+        ),
+        (
+            EventType::Evidence,
+            r#"Bash: {"command":"cargo test"} → {"stdout":"all 12 tests pass"}"#,
+        ),
+    ] {
+        let mut e = Event::new(&task, ty, Author::Classifier, Source::Hook, text.into());
+        e.timestamp = "2026-01-01T00:00:00Z".into();
+        e.status = EventStatus::Confirmed;
+        writer.append(&e).unwrap();
+    }
+    writer.flush_durable().unwrap();
+    tj().args([
+        "event",
+        &task,
+        "--type",
+        "decision",
+        "--text",
+        "Decided to cache the pack per task.",
+    ])
+    .assert()
+    .success();
+    let before = std::fs::read_to_string(&journal_path).unwrap();
+
+    tj().args(["cleanup-noise", "--dry-run"])
+        .assert()
+        .success()
+        .stdout(contains("2 entries would be retired"));
+    assert_eq!(
+        std::fs::read_to_string(&journal_path).unwrap(),
+        before,
+        "a dry run writes nothing"
+    );
+    let list = std::fs::read_dir(xdg.path().join("task-journal"))
+        .unwrap()
+        .map(|e| e.unwrap().path())
+        .find(|p| p.to_string_lossy().contains("cleanup-noise-"))
+        .expect("the dry run lists every entry in a file");
+    let list = std::fs::read_to_string(list).unwrap();
+    assert!(
+        list.contains("## Release") && list.contains("git push"),
+        "{list}"
+    );
+    assert!(
+        !list.contains("Unsplash") && !list.contains("cargo test"),
+        "{list}"
+    );
+
+    tj().args(["cleanup-noise", "--all"])
+        .assert()
+        .failure()
+        .stderr(contains("--yes"));
+
+    tj().args(["cleanup-noise"])
+        .assert()
+        .success()
+        .stdout(contains("2 entries retired"));
+    tj().args(["cleanup-noise"])
+        .assert()
+        .success()
+        .stdout(contains("nothing to clean"));
+
+    let pack = String::from_utf8(
+        tj().args(["pack", &task, "--mode", "full"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone(),
+    )
+    .unwrap();
+    assert!(pack.contains("Unsplash"), "{pack}");
+    assert!(!pack.contains("## Release"), "{pack}");
+    let recent = pack
+        .split("## Recent events")
+        .nth(1)
+        .expect("recent events section");
+    assert!(recent.contains("Decided to cache the pack"), "{recent}");
+}
+
 /// Claude Code takes its hooks from the plugin; the ones earlier versions
 /// wrote to settings.json ran next to them. install-hooks for Claude Code now
 /// takes ours out — after a copy of the file — and keeps everyone else's.
@@ -1752,6 +1903,14 @@ fn install_hooks_for_claude_code_removes_its_hooks_after_a_backup() {
             .assert()
             .success()
     };
+    // No plugin with hooks to take over yet: nothing is removed.
+    run().stderr(contains("ships no hooks yet"));
+    assert_eq!(
+        std::fs::read_to_string(claude_dir.join("settings.json")).unwrap(),
+        original
+    );
+
+    install_plugin_with_hooks(dir.path());
     run().stdout(contains("backup:"));
 
     let content = std::fs::read_to_string(claude_dir.join("settings.json")).unwrap();
@@ -2571,6 +2730,80 @@ fn plugin_hooks_keep_session_start_and_model_switch_and_never_queue() {
     }
 }
 
+/// Claude Code without the mod runs the plugin's hook and one left in
+/// settings.json side by side; a model switch is still recorded once.
+#[test]
+fn a_model_switch_is_recorded_once_by_two_hooks() {
+    let xdg = assert_fs::TempDir::new().unwrap();
+    let proj = assert_fs::TempDir::new().unwrap();
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", xdg.path())
+        .current_dir(proj.path())
+        .args(["create", "Switch host"])
+        .assert()
+        .success();
+    let payload = serde_json::json!({
+        "hook_event_name": "PostModelSwitch",
+        "session_id": "s-twice",
+        "from_model": "claude-opus-5-5",
+        "to_model": "claude-sonnet-5-5",
+        "source": "user",
+    })
+    .to_string();
+
+    for args in [vec!["ingest-hook"], vec!["ingest-hook", "--from-plugin"]] {
+        Command::cargo_bin("task-journal")
+            .unwrap()
+            .env("XDG_DATA_HOME", xdg.path())
+            .current_dir(proj.path())
+            .args(args)
+            .write_stdin(payload.clone())
+            .assert()
+            .success();
+    }
+
+    let hash = tj_core::project_hash::from_path(proj.path()).unwrap();
+    let journal = project_events(xdg.path(), &hash);
+    assert_eq!(journal.matches("\"model_switch\"").count(), 1, "{journal}");
+}
+
+/// A test run is evidence by nature, and its record is the call: the
+/// heuristic's evidence from tool output is kept, not dropped as a raw call.
+#[test]
+fn evidence_from_tool_output_is_recorded() {
+    let xdg = assert_fs::TempDir::new().unwrap();
+    let proj = assert_fs::TempDir::new().unwrap();
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", xdg.path())
+        .current_dir(proj.path())
+        .args(["create", "Evidence host"])
+        .assert()
+        .success();
+    let payload = serde_json::json!({
+        "hook_event_name": "PostToolUse",
+        "tool_name": "Bash",
+        "tool_input": { "command": "cargo test" },
+        "tool_response": { "stdout": "test result: ok. all 12 tests pass" },
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", xdg.path())
+        .env("TJ_INGEST_SYNC", "1")
+        .current_dir(proj.path())
+        .args(["ingest-hook", "--backend", "heuristic"])
+        .write_stdin(payload)
+        .assert()
+        .success();
+
+    let hash = tj_core::project_hash::from_path(proj.path()).unwrap();
+    let journal = project_events(xdg.path(), &hash);
+    assert!(journal.contains("\"evidence\""), "{journal}");
+}
+
 /// Push-recall is the plugin hook's job under the mod: a tool call that
 /// clearly touches a prior rejection of the session's task gets it, as
 /// additionalContext for any tool, and nothing is queued.
diff --git a/crates/tj-core/src/classifier/heuristic.rs b/crates/tj-core/src/classifier/heuristic.rs
index 4910944..808ecbd 100644
--- a/crates/tj-core/src/classifier/heuristic.rs
+++ b/crates/tj-core/src/classifier/heuristic.rs
@@ -223,6 +223,8 @@ mod tests {
             "Decided against the Redis cache: one more service to run for a 5% gain.",
             "Отказались от chown -R в Dockerfile: веб-корень становится записываемым.",
             "Попробовал ленивую загрузку, не работает с SSR — оставляем как было.",
+            "Rejected: a second SQLite table for the counter, a plain state file is enough.",
+            "Unsplash was rejected because its licence forbids hot-linking in the demo.",
         ] {
             let out = try_heuristic(&input(text)).unwrap();
             assert_eq!(out.event_type, EventType::Rejection, "{text}");
@@ -233,6 +235,10 @@ mod tests {
             "Details follow. ".repeat(60)
         );
         for text in [
+            "The server rejected the request with a 401, checking the token next.",
+            "Стандартное отклонение задержки выросло вдвое после деплоя.",
+            "Отказ отправки письма: SMTP вернул 550, смотрю логи.",
+            "Tried running the suite again: 2 tests failed in auth.",
             "The login page doesn't work after the deploy, looking at logs now.",
             "Тест падает: страница не работает после деплоя, смотрю логи.",
             "The upload was rejected 2 files because of their size limits.",
diff --git a/crates/tj-core/src/classifier/mod.rs b/crates/tj-core/src/classifier/mod.rs
index 296d04a..1960e79 100644
--- a/crates/tj-core/src/classifier/mod.rs
+++ b/crates/tj-core/src/classifier/mod.rs
@@ -63,6 +63,26 @@ pub fn decide_status(confidence: f64) -> EventStatus {
 /// and why. A whole answer that happens to say "rejected" is not one.
 pub const REJECTION_MAX_CHARS: usize = 600;
 
+/// Whether `text` has the shape of a rejection: a sentence or two, not
+/// machine text, not a whole answer (paragraphs, headings, tables, code
+/// fences) and not a question. It says nothing about the words: a model or a
+/// person phrases a ruled-out approach any way they like, so this is what
+/// filters and cleans what the classifier filed as a rejection — erring on
+/// keeping it.
+pub fn reads_like_a_rejection(text: &str) -> bool {
+    let t = text.trim();
+    let is_structured = t.contains("\n\n")
+        || t.lines()
+            .map(str::trim_start)
+            .any(|l| l.starts_with('#') || l.starts_with("```") || l.starts_with('|'));
+
+    !t.is_empty()
+        && t.chars().count() <= REJECTION_MAX_CHARS
+        && crate::noise::machine_text(t).is_none()
+        && !is_structured
+        && !t.ends_with('?')
+}
+
 /// Phrases that rule an approach out on their own.
 const REJECTION_CUES: &[&str] = &[
     "decided against",
@@ -77,17 +97,25 @@ const REJECTION_CUES: &[&str] = &[
     "giving up on",
     "abandoned the",
     "abandon the",
-    "rejected the",
-    "rejecting the",
-    "отказались от",
-    "отказался от",
-    "отказываемся от",
-    "отказ от",
+    "rejected the approach",
+    "rejected the idea",
+    "rejected this approach",
+    "rejected that approach",
+    "rejected:",
+    "was rejected because",
+    "were rejected because",
+    "отказались от ",
+    "отказался от ",
+    "отказываемся от ",
+    "отказ от ",
     "отклонил",
     "отклонён",
-    "отклонен",
+    "отклонен ",
+    "отклонена",
+    "отклонено",
     "отклоняем",
-    "отверг",
+    "отвергли",
+    "отвергнут",
     "не будем использовать",
     "не стали использовать",
 ];
@@ -99,18 +127,21 @@ const FAILED: &[&str] = &[
     "doesn't work",
     "didn't work",
     "won't work",
-    "failed",
+    "but it failed",
+    "but failed",
     "вместо",
     "не работает",
     "не сработал",
     "не подходит",
 ];
 
-/// True when `text` rules an approach out: a short statement with an
-/// explicit cue. A bug report ("X doesn't work"), a log line ("rejected 2
-/// files"), a tool call or a whole answer is not a rejection.
+/// True when raw text rules an approach out in so many words: the shape of a
+/// rejection plus an explicit cue. What a keyword heuristic may file as a
+/// rejection on its own — a bug report ("X doesn't work"), a log line
+/// ("rejected 2 files", "the server rejected the request") or a test report
+/// ("tried it, 2 tests failed") is not.
 pub fn is_explicit_rejection(text: &str) -> bool {
-    if text.chars().count() > REJECTION_MAX_CHARS || crate::noise::machine_text(text).is_some() {
+    if !reads_like_a_rejection(text) {
         return false;
     }
 
@@ -147,6 +178,32 @@ pub mod telemetry;
 mod tests {
     use super::*;
 
+    /// A rejection the classifier phrased any way it liked keeps its place;
+    /// a whole answer, a question or machine text does not.
+    #[test]
+    fn a_rejection_is_a_short_statement_whatever_its_words() {
+        for text in [
+            "Windows Terminal split feature rejected: probing wt.exe closed the whole window; use tmux.",
+            "Reverted 83f53ebd: the approach conflated the two caches.",
+            "Local curl testing was insufficient to catch the null payload.",
+        ] {
+            assert!(reads_like_a_rejection(text), "{text}");
+        }
+
+        let long = "One more sentence about the release. ".repeat(20);
+        for text in [
+            "## Release notes\n\nThe PR was rejected once by CI.",
+            "First paragraph.\n\nSecond paragraph, rejected.",
+            "Should we drop the cache?",
+            r#"Bash: {"command":"git push"}"#,
+            "<task-notification> <task-id>x</task-id>",
+            long.as_str(),
+            "  ",
+        ] {
+            assert!(!reads_like_a_rejection(text), "{text}");
+        }
+    }
+
     /// The HTTP backend must honour `TJ_CLASSIFIER_MODEL`. Wraps the
     /// read-set-restore steps in one test to avoid env-var races with
     /// other tests in this crate.
diff --git a/crates/tj-core/src/recall.rs b/crates/tj-core/src/recall.rs
index 2ec5e0e..264e0e6 100644
--- a/crates/tj-core/src/recall.rs
+++ b/crates/tj-core/src/recall.rs
@@ -75,6 +75,7 @@ pub fn recall_for_task(
     let needles: Vec<String> = arts
         .linked_issues
         .iter()
+        .filter(|issue| !is_a_standard(issue))
         .chain(arts.commit_hashes.iter())
         .map(|n| format!("\"{n}\""))
         .collect();
@@ -118,12 +119,13 @@ pub fn recall_for_task(
             .filter(|n| artifacts.contains(n.as_str()))
             .count()
             + shared_files(&paths, &artifacts);
-        let shared_words = keywords(&text)
-            .into_iter()
-            .collect::<HashSet<_>>()
-            .intersection(&words)
-            .count();
-        if shared_arts == 0 && shared_words < MIN_SHARED_WORDS {
+        let event_words = keywords(&text).into_iter().collect::<HashSet<_>>();
+        let shared_words = event_words.intersection(&words).count();
+        // The bar rises with the call's length (one word in six, at least
+        // MIN_SHARED_WORDS): a long command or script shares three words
+        // with a note by chance alone.
+        let needed = MIN_SHARED_WORDS.max(words.len().div_ceil(6));
+        if shared_arts == 0 && shared_words < needed {
             continue;
         }
 
@@ -147,6 +149,19 @@ pub fn recall_for_task(
     Ok(hits)
 }
 
+/// `UTF-8`, `SHA-256`, `ISO-8601`: names of standards shaped like an issue
+/// key (`DEV-4621`) that tie a tool call to nothing.
+fn is_a_standard(issue: &str) -> bool {
+    const STANDARDS: &[&str] = &[
+        "UTF", "UCS", "SHA", "MD", "ISO", "RFC", "IEEE", "ECMA", "AES", "RSA", "TLS", "SSL",
+        "HTTP", "CRC", "PEP",
+    ];
+
+    issue
+        .split_once('-')
+        .is_some_and(|(prefix, _)| STANDARDS.contains(&prefix))
+}
+
 /// Files of an event (its `artifacts` JSON) that one of `paths` names. An
 /// event keeps `src/pack.rs` while a tool call names the absolute path, so a
 /// match is the same path or one ending in the other at a `/`.
@@ -250,6 +265,38 @@ mod tests {
         assert_eq!(hits.len(), 1, "got: {hits:?}");
     }
 
+    /// `UTF-8` has the shape of an issue key and used to be enough for a hit.
+    #[test]
+    fn a_standards_name_is_not_a_shared_issue() {
+        let (_d, conn) = seeded(&[ev(
+            TASK,
+            EventType::Decision,
+            "Decided to write the CSV export as UTF-8 with a BOM for Excel.",
+            EventStatus::Confirmed,
+        )]);
+
+        let query = "curl -H charset=UTF-8 localhost:3000/health";
+        let hits = recall_for_task(&conn, TASK, query, 2).unwrap();
+        assert!(hits.is_empty(), "got: {hits:?}");
+    }
+
+    /// Three shared words are enough for a short call, not for a long one.
+    #[test]
+    fn a_long_call_needs_more_shared_words() {
+        let (_d, conn) = seeded(&[rejection(
+            TASK,
+            "Tried to switch the server to axum but it broke rmcp stdio.",
+        )]);
+        let filler = (0..30)
+            .map(|i| format!("word{i}"))
+            .collect::<Vec<_>>()
+            .join(" ");
+        let long = format!("switch the server to axum {filler}");
+
+        let hits = recall_for_task(&conn, TASK, &long, 2).unwrap();
+        assert!(hits.is_empty(), "got: {hits:?}");
+    }
+
     /// The words of a path are not words of the work: another file of the
     /// same crate shares "crates", "core" and "src", and that is no match.
     #[test]
diff --git a/crates/tj-core/src/session/extractor.rs b/crates/tj-core/src/session/extractor.rs
index 4ee8d30..446633e 100644
--- a/crates/tj-core/src/session/extractor.rs
+++ b/crates/tj-core/src/session/extractor.rs
@@ -233,6 +233,24 @@ fn classify_text_heuristic(task_id: &str, text: &str, timestamp: &str) -> Option
         return None;
     }
 
+    // A rejection first, so "не будем использовать X" is not read as the
+    // decision "будем использовать"; only an approach explicitly ruled out,
+    // the same rule the classifier uses.
+    if crate::classifier::is_explicit_rejection(text) {
+        let mut ev = Event::new(
+            task_id,
+            EventType::Rejection,
+            Author::Agent,
+            Source::Cli,
+            truncate(text, 300),
+        );
+        ev.timestamp = timestamp.to_string();
+        ev.confidence = Some(0.6);
+        ev.status = EventStatus::Suggested;
+        ev.meta = serde_json::json!({"backfill": true, "heuristic": "rejection_keyword"});
+        return Some(ev);
+    }
+
     // Decision patterns.
     let decision_patterns = [
         "decided to",
@@ -261,22 +279,6 @@ fn classify_text_heuristic(task_id: &str, text: &str, timestamp: &str) -> Option
         }
     }
 
-    // Only an approach explicitly ruled out, the same rule the classifier uses.
-    if crate::classifier::is_explicit_rejection(text) {
-        let mut ev = Event::new(
-            task_id,
-            EventType::Rejection,
-            Author::Agent,
-            Source::Cli,
-            truncate(text, 300),
-        );
-        ev.timestamp = timestamp.to_string();
-        ev.confidence = Some(0.6);
-        ev.status = EventStatus::Suggested;
-        ev.meta = serde_json::json!({"backfill": true, "heuristic": "rejection_keyword"});
-        return Some(ev);
-    }
-
     // Constraint patterns.
     let constraint_patterns = [
         "rate limit",
@@ -431,6 +433,16 @@ mod tests {
         assert_eq!(ev.unwrap().event_type, EventType::Rejection);
     }
 
+    #[test]
+    fn test_not_going_to_use_is_a_rejection_not_a_decision() {
+        let ev = classify_text_heuristic(
+            "tj-test",
+            "Мы не будем использовать Redis для очереди: лишний сервис ради пяти процентов.",
+            "2026-01-01T00:00:00Z",
+        );
+        assert_eq!(ev.unwrap().event_type, EventType::Rejection);
+    }
+
     #[test]
     fn test_classify_short_text_skipped() {
         let ev = classify_text_heuristic("tj-test", "OK, done.", "2026-01-01T00:00:00Z");
diff --git a/crates/tj-core/src/storage.rs b/crates/tj-core/src/storage.rs
index d1ad73a..2c5a506 100644
--- a/crates/tj-core/src/storage.rs
+++ b/crates/tj-core/src/storage.rs
@@ -64,6 +64,44 @@ impl JsonlWriter {
         Ok(())
     }
 
+    /// Appends `event` unless `seen` finds it in the log's last 16 KiB, read
+    /// under the same exclusive lock as the write — two hooks firing for one
+    /// event cannot both miss each other. Returns whether it appended.
+    pub fn append_unless(
+        &mut self,
+        event: &Event,
+        seen: impl FnOnce(&str) -> bool,
+    ) -> anyhow::Result<bool> {
+        const TAIL: u64 = 16 * 1024;
+
+        let mut line = serde_json::to_string(event).context("serialize event")?;
+        line.push('\n');
+        let mut guard = self.lock.write().context("acquire exclusive file lock")?;
+
+        let len = guard.seek(SeekFrom::End(0)).context("seek the log's end")?;
+        guard
+            .seek(SeekFrom::Start(len.saturating_sub(TAIL)))
+            .context("seek the log's tail")?;
+        let mut tail = Vec::new();
+        guard
+            .read_to_end(&mut tail)
+            .context("read the log's tail")?;
+        if seen(&String::from_utf8_lossy(&tail)) {
+            return Ok(false);
+        }
+
+        if ends_without_newline(&mut guard).context("check the log's last byte")? {
+            guard
+                .write_all(b"\n")
+                .context("terminate a torn last line")?;
+        }
+        guard
+            .write_all(line.as_bytes())
+            .context("write event line")?;
+
+        Ok(true)
+    }
+
     /// Force the file's bytes through to durable storage. Holds the
     /// exclusive lock so no concurrent writer can sneak an append
     /// between us and the fsync.

From 4cb299fd803102dc69c6886c7b07d05c90f8ec9b Mon Sep 17 00:00:00 2001
From: Mher Shahinyan <shahinyanm@gmail.com>
Date: Fri, 6 Nov 2026 10:35:55 +0400
Subject: [PATCH 3/5] chore: bump version to v0.32.0

---
 .claude-plugin/marketplace.json   | 4 ++--
 CHANGELOG.md                      | 2 ++
 Cargo.lock                        | 6 +++---
 Cargo.toml                        | 4 ++--
 plugin/.claude-plugin/plugin.json | 2 +-
 plugin/package.json               | 2 +-
 6 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 64c245a..da85a11 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Task Journal — append-only reasoning chain memory for AI-coding tasks",
-    "version": "0.31.2"
+    "version": "0.32.0"
   },
   "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.31.2",
+      "version": "0.32.0",
       "author": {
         "name": "Digital-Threads"
       },
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8305ae7..071bd93 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.32.0] - 2026-11-06
+
 Less noise in the agent's context. Measured on 300 sessions: push-recall was
 added to tool results 13,696 times, almost never about the work at hand.
 
diff --git a/Cargo.lock b/Cargo.lock
index b11cc3d..96d83a6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2516,7 +2516,7 @@ dependencies = [
 
 [[package]]
 name = "task-journal-cli"
-version = "0.31.2"
+version = "0.32.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2540,7 +2540,7 @@ dependencies = [
 
 [[package]]
 name = "task-journal-core"
-version = "0.31.2"
+version = "0.32.0"
 dependencies = [
  "anyhow",
  "chrono",
@@ -2565,7 +2565,7 @@ dependencies = [
 
 [[package]]
 name = "task-journal-mcp"
-version = "0.31.2"
+version = "0.32.0"
 dependencies = [
  "anyhow",
  "chrono",
diff --git a/Cargo.toml b/Cargo.toml
index 17857aa..a00b266 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.31.2"
+version = "0.32.0"
 edition = "2021"
 rust-version = "1.88"
 license = "MIT"
@@ -20,7 +20,7 @@ categories = ["command-line-utilities", "development-tools"]
 [workspace.dependencies]
 # `version` must equal workspace.package.version: `cargo publish` uploads it as
 # the requirement on core. Cargo can't inherit it; plugin_metadata.rs checks it.
-tj-core = { package = "task-journal-core", version = "0.31.2", path = "crates/tj-core", default-features = false }
+tj-core = { package = "task-journal-core", version = "0.32.0", path = "crates/tj-core", default-features = false }
 anyhow = "1"
 thiserror = "1"
 serde = { version = "1", features = ["derive"] }
diff --git a/plugin/.claude-plugin/plugin.json b/plugin/.claude-plugin/plugin.json
index 677c788..e9e7768 100644
--- a/plugin/.claude-plugin/plugin.json
+++ b/plugin/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "task-journal",
-  "version": "0.31.2",
+  "version": "0.32.0",
   "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"
diff --git a/plugin/package.json b/plugin/package.json
index 241a347..139f23f 100644
--- a/plugin/package.json
+++ b/plugin/package.json
@@ -1,6 +1,6 @@
 {
   "name": "task-journal",
-  "version": "0.31.2",
+  "version": "0.32.0",
   "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",

From 40cb9569392428d46cc62a6453a04c9c2011c0f1 Mon Sep 17 00:00:00 2001
From: Mher Shahinyan <shahinyanm@gmail.com>
Date: Fri, 6 Nov 2026 10:36:35 +0400
Subject: [PATCH 4/5] docs: changelog states what changed for /rewind, not why

---
 CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 071bd93..2bb98f4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -42,8 +42,8 @@ added to tool results 13,696 times, almost never about the work at hand.
   sets `TJ_PLUGIN_HOOKS`), a hook, `nudge` or `recall-hook` still left in
   `settings.json` stands down, and a model switch is recorded once even where both
   run (Claude Code without the mod). `--auto-capture` and `--proactive-recall` no
-  longer apply to Claude Code, and `/rewind` in a prompt is no longer recorded there
-  (the built-in command never reached the hook).
+  longer apply to Claude Code, and `/rewind` typed in a prompt is no longer recorded
+  there.
 - **The classic nudge runs on a session's first prompt and then every sixth**
   (`TJ_NUDGE_EVERY`), not on every prompt, and no longer shouts.
 - **Rejections.** The keyword heuristic and `backfill` file a rejection only for an

From 7ef7a68cf846b6952dfb41dbcc4f1a1684ba9687 Mon Sep 17 00:00:00 2001
From: Mher Shahinyan <shahinyanm@gmail.com>
Date: Fri, 6 Nov 2026 10:48:16 +0400
Subject: [PATCH 5/5] fix(deps): rustls 0.23.46, rustls-webpki 0.103.16,
 webpki-roots 1.0.11 for RUSTSEC-2026-0346..0349, 0381, 0382

---
 Cargo.lock | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 96d83a6..962bd2b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2170,9 +2170,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.45"
+version = "0.23.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
 dependencies = [
  "log",
  "once_cell",
@@ -2194,9 +2194,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.15"
+version = "0.103.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -3057,14 +3057,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.7",
+ "webpki-roots 1.0.11",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.7"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d"
+checksum = "f5f280bbb2b287bc8e7de7e3852945a0ff50d1bbcb5ed42b6c7a568c546df171"
 dependencies = [
  "rustls-pki-types",
 ]