feat(v0.9.0)!: remove cli backend entirely + clean docs

BREAKING: --backend=cli is gone. The v0.8.0 deprecation alias is
deleted along with the ClaudeCliClassifier implementation, the
--classifier-command flag, and the TJ_CLASSIFIER_CLI env-var write
path. Uninstall still strips the legacy env key (back-compat).

Why now: claude -p no longer rides the Pro/Max subscription —
running it bills tokens separately. Keeping the alias one release
was enough notice; carrying a deprecated free-fallback that isn't
free is a worse contract than just removing it.

Removed:
  - crates/tj-core/src/classifier/cli.rs (ClaudeCliClassifier + tests)
  - crates/tj-core/tests/classifier_eval.rs + fixtures dir
  - InstallHooks::classifier_command flag
  - TJ_CLASSIFIER_CLI write on install (strip-on-uninstall kept)
  - Two install_hooks tests that exercised the removed flag

Public API:
  - tj_core::classifier::cli module — gone
  - --backend=cli value — now errors out
  - --classifier-command flag — gone

Docs:
  - README: rewritten around the hybrid model (heuristic + API),
    no more `claude -p` / subscription references. Env-var table
    trimmed to ANTHROPIC_API_KEY + TJ_CLASSIFIER_MODEL.
  - SKILL.md: drop the Pro/Max subscription claim.
  - PreCompact description updated to mention transcript catch-up.

Tests: 64 cli integration + 158 core lib pass (2 pre-existing
migrate_project /tmp canonicalization failures unrelated).

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

Author: Shahinyanm

CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-05-17
+
+**Breaking — `cli` backend removed.** v0.8.0 left it as a deprecated
+alias for `hybrid`; v0.9.0 deletes the implementation. With it goes
+the `--classifier-command` flag, the `TJ_CLASSIFIER_CLI` env var
+(only the back-compat strip on uninstall stays), and the
+`ClaudeCliClassifier` struct.
+
+If you upgraded to v0.8.0 you saw a one-line deprecation warning on
+every hook; that's the whole migration story. On v0.9.0 the value
+`--backend=cli` errors with `unknown backend: cli (expected hybrid,
+api, or heuristic)`.
+
+### Removed
+- `tj_core::classifier::cli::ClaudeCliClassifier` and the entire
+  `tj_core::classifier::cli` module.
+- `crates/tj-core/tests/classifier_eval.rs` and its fixtures — the
+  eval harness depended on `ClaudeCliClassifier`.
+- `task-journal install-hooks --classifier-command <CMD>` flag.
+- `TJ_CLASSIFIER_CLI` env var write on install. The variable is
+  still **stripped** on `--uninstall` to clean up settings.json from
+  pre-0.9 installs (back-compat).
+- Default value handling for `--backend=cli`. It now hits the
+  generic `unknown backend` error path.
+
+### Documentation
+- README rewritten around the hybrid model — heuristic stage
+  characterized, API stage as the optional fallback, no `claude -p`
+  references anywhere.
+- Plugin skill description (`SKILL.md`) drops the Pro/Max
+  subscription claim that was no longer true.
+- Configuration table trimmed to the two env vars that still matter:
+  `ANTHROPIC_API_KEY` and `TJ_CLASSIFIER_MODEL`.
+
+### Migration
+- Re-run `task-journal install-hooks --scope user` to refresh
+  `~/.claude/settings.json` without the legacy `--backend=cli` flag
+  and without `TJ_CLASSIFIER_CLI` in `env`.
+- If you want the API stage (recommended for full coverage), set
+  `ANTHROPIC_API_KEY` in your shell or in the same `settings.json`
+  `env` block.
+
 ## [0.8.0] - 2026-05-17
 
 **Breaking — classifier backend reshaped.** Anthropic changed `claude -p`

Cargo.lock

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

Cargo.toml

@@ -75,12 +75,12 @@ That's it. Restart Claude Code, start working, and the journal fills itself.
 
 ## How it works
 
-- **Auto-capture via Claude Code hooks.** Every prompt, tool call, and Claude reply is classified by a small `claude -p` invocation and appended as a typed event (`finding` / `decision` / `evidence` / `rejection` / …). Hook returns in <100 ms — classification happens in the background, never blocks your session.
+- **Auto-capture via Claude Code hooks.** Every prompt, tool call, and Claude reply runs through a two-stage classifier and lands as a typed event (`finding` / `decision` / `evidence` / `rejection` / …). Stage 1 is a fast in-process heuristic — pattern-matches obvious phrasing in EN+RU for zero cost. Stage 2 falls back to the Anthropic API (`ANTHROPIC_API_KEY`) only when the heuristic is uncertain. Hook returns in <100 ms — both stages run in a detached background worker, never blocking your session.
 - **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: `PreCompact` drops a marker decision when Claude Code is about to compact, and 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.
+- **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.
 
-Source of truth is an append-only JSONL log per project. SQLite holds derived state and is fully rebuildable. Nothing is sent off-machine except the classifier prompt to your own `claude -p` (subscription) or the Anthropic API.
+Source of truth is an append-only JSONL log per project. SQLite holds derived state and is fully rebuildable. Nothing is sent off-machine except the classifier prompt to the Anthropic API — and only when the local heuristic is uncertain. With no `ANTHROPIC_API_KEY` set, Task Journal still works: the heuristic handles the obvious cases, and anything it can't classify sits in the local pending queue for later retry.
 
 ### Statusline integration
 
@@ -183,9 +183,8 @@ The MCP server exposes five tools to Claude Code (and any MCP client):
 
 | Env var | Effect | Default |
 |---------|--------|---------|
-| `TJ_CLASSIFIER_CLI` | Classifier command. When set to bare `claude`, Task Journal automatically injects `--strict-mcp-config --mcp-config '{"mcpServers":{}}'` so the inner classifier session does not load every plugin in your settings (keeps classifier startup fast). | `claude` |
-| `TJ_CLASSIFIER_MODEL` | Model alias for the classifier (`claude -p` or HTTP API). | `haiku` (CLI) / `claude-haiku-4-5-20251001` (API) |
-| `ANTHROPIC_API_KEY` | Required for `--backend=api` (HTTP classifier). | _unset_ |
+| `ANTHROPIC_API_KEY` | Powers the API stage of `--backend=hybrid` (default) and is required for `--backend=api`. Without it, only the offline heuristic runs and ambiguous chunks land in the local pending queue. | _unset_ |
+| `TJ_CLASSIFIER_MODEL` | Override the Anthropic model used by the API stage. | `claude-haiku-4-5-20251001` |
 | `TJ_AUTO_OPEN_TASKS` | Set to `0` / `false` to disable auto-opening a task from `UserPromptSubmit` when no open task exists. | `1` |
 
 ## Event types

README.md

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

crates/tj-cli/Cargo.toml

@@ -718,11 +718,6 @@ enum Commands {
         /// Remove our hook entries instead of installing.
         #[arg(long)]
         uninstall: bool,
-        /// Override classifier command. Writes env.TJ_CLASSIFIER_CLI into settings.json
-        /// so wrappers (aimux, litellm, etc.) work without manual env setup.
-        /// Default: classifier uses `claude -p`.
-        #[arg(long)]
-        classifier_command: Option<String>,
         /// After installing hooks, retro-import existing Claude Code session
         /// history for the current project. Equivalent to running
         /// `task-journal backfill` afterwards. Onboarding shortcut.
@@ -1271,7 +1266,6 @@ fn main() -> Result<()> {
         Commands::InstallHooks {
             scope,
             uninstall,
-            classifier_command,
             backfill,
         } => {
             let settings_path = match scope.as_str() {
@@ -1388,23 +1382,6 @@ fn main() -> Result<()> {
                     "PreCompact":      [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
                 });
                 hooks_obj.insert("hooks".into(), entries);
-
-                // Optional: set env.TJ_CLASSIFIER_CLI for users running classifier
-                // through a wrapper (aimux, litellm, etc.). Claude Code reads this
-                // env block and propagates the var to hook subprocesses, so users
-                // don't need to mess with bashrc.
-                if let Some(cmd) = classifier_command {
-                    let env = hooks_obj
-                        .entry("env".to_string())
-                        .or_insert_with(|| serde_json::json!({}));
-                    let env_obj = env
-                        .as_object_mut()
-                        .ok_or_else(|| anyhow::anyhow!("settings.env is not a JSON object"))?;
-                    env_obj.insert(
-                        "TJ_CLASSIFIER_CLI".to_string(),
-                        serde_json::Value::String(cmd),
-                    );
-                }
             }
             std::fs::write(&settings_path, serde_json::to_string_pretty(&current)?)?;
             println!("{}", settings_path.display());
@@ -1806,18 +1783,6 @@ fn main() -> Result<()> {
                         "hybrid" | "" => Box::new(
                             tj_core::classifier::hybrid::HybridClassifier::from_env(),
                         ),
-                        // Legacy alias — keeps existing settings.json + plugin
-                        // hooks installed by 0.7.x working without manual edits.
-                        // Same dispatch as hybrid; the warning lands on stderr
-                        // which Claude Code captures into hook logs.
-                        "cli" => {
-                            eprintln!(
-                                "warn: --backend=cli is deprecated (claude -p no longer rides Pro/Max). Routing to --backend=hybrid."
-                            );
-                            Box::new(
-                                tj_core::classifier::hybrid::HybridClassifier::from_env(),
-                            )
-                        }
                         "api" => {
                             Box::new(tj_core::classifier::http::AnthropicClassifier::from_env()?)
                         }
@@ -3127,9 +3092,31 @@ fn process_pending_entry(
 
     use tj_core::classifier::Classifier;
     let classifier: Box<dyn Classifier> = match backend {
-        "cli" => Box::new(tj_core::classifier::cli::ClaudeCliClassifier::default()),
+        "hybrid" | "" => {
+            Box::new(tj_core::classifier::hybrid::HybridClassifier::from_env())
+        }
         "api" => Box::new(tj_core::classifier::http::AnthropicClassifier::from_env()?),
-        other => anyhow::bail!("unknown backend: {other}"),
+        "heuristic" => {
+            use tj_core::classifier::heuristic::try_heuristic;
+            use tj_core::classifier::{ClassifyInput, ClassifyOutput};
+            struct HeuristicOnly;
+            impl Classifier for HeuristicOnly {
+                fn classify(
+                    &self,
+                    input: &ClassifyInput,
+                ) -> anyhow::Result<ClassifyOutput> {
+                    try_heuristic(input).ok_or_else(|| {
+                        anyhow::anyhow!(
+                            "heuristic uncertain (heuristic-only mode has no LLM fallback)"
+                        )
+                    })
+                }
+            }
+            Box::new(HeuristicOnly)
+        }
+        other => anyhow::bail!(
+            "unknown backend: {other} (expected `hybrid`, `api`, or `heuristic`)"
+        ),
     };
     let input = tj_core::classifier::ClassifyInput {
         text: text.clone(),