feat(v0.8.0): hybrid classifier (heuristic + API), drop cli backend

BREAKING: --backend=cli is deprecated. Default is now --backend=hybrid.

Background: Anthropic changed `claude -p` to bill against a separate
token budget instead of riding the Pro/Max subscription, so v0.7.x's
`cli` backend silently charged users who had explicitly opted into a
"free fallback". This release replaces it with a heuristic-first hybrid
that runs zero-network pattern matching on common phrasing cues, and
falls back to the Anthropic API only when the heuristic is uncertain.

New backends:
  - hybrid (default): heuristic → API fallback if ANTHROPIC_API_KEY set
  - heuristic: pattern-only, no LLM, zero cost / offline
  - api: always call the Anthropic API (best quality, paid)

The cli backend value remains accepted as a legacy alias; it routes to
hybrid and prints a one-line stderr deprecation warning. Will be
removed in v0.9.0.

Plugin hooks.json and install-hooks settings.json template both drop
the explicit --backend=cli flag; the binary's `hybrid` default wins.

Pattern coverage (EN+RU): Decision, Rejection, Evidence, Finding,
Constraint, Hypothesis, Correction. Heuristic catches the obvious
cases — file:line references, "we decided to", "won't work",
"test passed", "rate limit", etc.

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

Author: Shahinyanm

CHANGELOG.md

@@ -7,6 +7,57 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-05-17
+
+**Breaking — classifier backend reshaped.** Anthropic changed `claude -p`
+to bill against a separate token budget instead of riding the Pro/Max
+subscription, so the v0.7.x `--backend=cli` path silently charged users
+who had explicitly opted into "free background". v0.8.0 removes it from
+the default path and replaces it with a heuristic-first hybrid.
+
+### Added
+- New `--backend=hybrid` (now the default). Keyword heuristic runs
+  first — handles obvious decisions, rejections, evidence, findings,
+  constraints, hypotheses, corrections in EN+RU at zero cost. If the
+  heuristic is uncertain (or no rule fires), falls back to the
+  Anthropic API backend when `ANTHROPIC_API_KEY` is set; otherwise
+  the chunk stays in `pending/` for later retry. No `claude -p`
+  subprocess.
+- New `--backend=heuristic` — heuristic only, no LLM. For users who
+  want strict zero-cost / offline operation and accept lower coverage.
+- `tj_core::classifier::heuristic::try_heuristic` — public helper for
+  pattern-matched classification, returning `Option<ClassifyOutput>`.
+- `tj_core::classifier::hybrid::HybridClassifier` — production
+  default. Exposes `from_env()` (picks up `ANTHROPIC_API_KEY`) and
+  `has_llm_fallback()` for callers that want to surface state to the
+  user.
+
+### Changed
+- Default backend in `task-journal ingest-hook` and
+  `task-journal classify-worker` changed from `cli` to `hybrid`.
+- `install-hooks` settings.json template no longer pins
+  `--backend=cli`; the binary default wins.
+- Plugin `hooks.json` (PostToolUse / PreCompact / Stop) no longer
+  passes `--backend=cli`. Same default-wins reasoning.
+
+### Deprecated
+- `--backend=cli` now routes to `hybrid` and prints a one-line
+  deprecation warning on stderr. The `ClaudeCliClassifier` struct
+  stays in `tj_core::classifier::cli` for the v0.7.x eval harness
+  but is no longer reachable from production code. Will be removed
+  in v0.9.0.
+
+### Migration
+- **Users with Pro/Max only and no API key** — keep working: the
+  heuristic catches the most common cases; chunks it can't classify
+  land in `pending/` and you can drain them later when you set an
+  API key (or just leave them — they don't block anything).
+- **Users with `ANTHROPIC_API_KEY` set** — best experience. Heuristic
+  saves API calls on obvious cases; the API handles the rest.
+- **No action required.** Old `~/.claude/settings.json` with
+  `--backend=cli` still works (alias). Re-run `install-hooks` to
+  remove the deprecation warning.
+
 ## [0.7.1] - 2026-05-17
 
 PreCompact closes the gap before compaction — the synchronous hook only

Cargo.lock

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

Cargo.toml

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

crates/tj-cli/Cargo.toml

@@ -813,10 +813,15 @@ enum Commands {
         /// tool_name+input+response for PostToolUse, etc.).
         #[arg(long)]
         text: Option<String>,
-        /// Classifier backend: "cli" uses `claude -p` (free with your Pro/Max
-        /// subscription) or "api" uses Anthropic API (requires `ANTHROPIC_API_KEY`).
-        /// Default: cli.
-        #[arg(long, default_value = "cli")]
+        /// Classifier backend:
+        ///   - "hybrid" (default) — keyword heuristic first (free, offline);
+        ///     Anthropic API fallback when uncertain (needs ANTHROPIC_API_KEY).
+        ///   - "api" — always call the Anthropic API. Best quality, paid.
+        ///   - "heuristic" — heuristic only, no LLM. Fastest, lowest coverage.
+        ///   - "cli" — deprecated alias for hybrid. The old `claude -p` path
+        ///     was removed in v0.8.0 because Anthropic now bills it
+        ///     separately from Pro/Max.
+        #[arg(long, default_value = "hybrid")]
         backend: String,
         /// Test/dev override: bypass classifier and force this event type. Hidden from --help.
         #[arg(long, hide = true)]
@@ -835,8 +840,8 @@ enum Commands {
     /// at a time. Hidden from --help; not a public API.
     #[command(hide = true)]
     ClassifyWorker {
-        /// Classifier backend: "cli" or "api". Defaults to cli.
-        #[arg(long, default_value = "cli")]
+        /// Classifier backend: "hybrid", "api", or "heuristic". Defaults to hybrid.
+        #[arg(long, default_value = "hybrid")]
         backend: String,
     },
     /// One-line status snapshot for the Claude Code statusline. Prints
@@ -1363,7 +1368,11 @@ fn main() -> Result<()> {
                 // at env vars Claude Code never sets and therefore always
                 // fed the classifier empty text. Stdin-only is the correct
                 // wiring (see claude-memory-rsw).
-                let cmd = "task-journal ingest-hook --backend=cli || true";
+                // No --backend flag: the binary's default (hybrid) wins.
+                // Hybrid = free heuristic first, Anthropic API fallback when
+                // uncertain. Users wanting always-api can edit settings.json
+                // and add `--backend=api`.
+                let cmd = "task-journal ingest-hook || true";
                 let entries = serde_json::json!({
                     "UserPromptSubmit": [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
                     "PostToolUse":     [{ "matcher": "", "hooks": [{ "type": "command", "command": cmd }] }],
@@ -1789,13 +1798,52 @@ fn main() -> Result<()> {
 
                     use tj_core::classifier::Classifier;
                     let classifier: Box<dyn Classifier> = match backend.as_str() {
-                        "cli" => Box::new(tj_core::classifier::cli::ClaudeCliClassifier::default()),
+                        // v0.8.0: hybrid is the new default. Heuristic
+                        // pattern-matching first (free), Anthropic API
+                        // fallback when uncertain (requires ANTHROPIC_API_KEY).
+                        // No background spawn of `claude -p` — that subprocess
+                        // now bills tokens separately from Pro/Max.
+                        "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()?)
                         }
-                        other => {
-                            anyhow::bail!("unknown backend: {other} (expected `cli` or `api`)")
+                        "heuristic" => {
+                            // Heuristic-only: no LLM at all. Trades coverage
+                            // for absolute zero-cost / offline operation.
+                            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(),