feat(classifier): TJ_CLASSIFIER_CLI env var for workspace wrappers (v0.2.4)

Users with aimux, nix run, direnv, or similar wrappers cant use the
bare 'claude' binary that the CLI classifier hardcodes — auth lives
in a profile-scoped credential store (~/.aimux/profiles/<name>/) that
plain 'claude -p' cannot see, producing 401 errors.

This commit adds TJ_CLASSIFIER_CLI: a whitespace-split command line
that lets the user wrap claude however their environment requires:

  export TJ_CLASSIFIER_CLI="aimux run dt claude"

The classifier splits this on spaces, takes the first token as the
program, and prepends the rest as base args before its own (-p, --model,
etc.). Default 'claude' behavior unchanged when env var is unset.

Real-world trigger: aimux user reported 700+ ghost session files in
~/.claude/projects/ from days of failed claude -p invocations. Each
invocation creates a session log on disk before failing, so silent
failures still pollute the filesystem.

Test: classifier_command_with_spaces_runs_wrapper_then_target — uses a
temp wrapper script that mimics aimuxs prefix-then-forward semantics.

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

Author: Shahinyanm

.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Task Journal — append-only reasoning chain memory for AI-coding tasks",
-    "version": "0.2.3"
+    "version": "0.2.4"
   },
   "plugins": [
     {
       "name": "task-journal",
       "source": "./plugin",
       "description": "Append-only journal of AI-coding task reasoning chains. Captures hypotheses, decisions, rejections, evidence — renders compact resume packs so an agent can pick up a 2-week-old task with full context.",
-      "version": "0.2.3",
+      "version": "0.2.4",
       "author": {
         "name": "Digital-Threads"
       },

CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-05-07
+
+Hotfix: support workspace-orchestrator wrappers (aimux, nix-shell, etc).
+
+### Added
+- `TJ_CLASSIFIER_CLI` env var. The CLI classifier (`--backend=cli`)
+  now splits this on whitespace and uses it as the program + base
+  arguments before appending the classifier-specific flags. Lets users
+  with `aimux`, `direnv`, `nix run` and similar wrappers pass through
+  to their actual `claude` binary without symlinks or PATH gymnastics:
+  ```bash
+  export TJ_CLASSIFIER_CLI="aimux run dt claude"
+  ```
+  When unset, defaults to the bare `claude` (previous behavior).
+
+### Fixed
+- Auto-capture hooks were silently failing for users on managed Claude
+  Code installations where the `claude` binary is not directly on PATH
+  but accessed via a wrapper. The `TJ_CLASSIFIER_CLI` override resolves
+  this without requiring binary changes to install-hooks.
+
 ## [0.2.3] - 2026-05-07
 
 Hotfix release. Re-release of the 0.2.2 fixes plus CI repair —

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 rust-version = "1.83"
 license = "MIT"

Cargo.toml

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

crates/tj-cli/Cargo.toml

@@ -35,10 +35,27 @@ pub struct ChatView {
 impl ChatView {
     pub fn from_session(session: &ParsedSession) -> Self {
         let mut messages = Vec::new();
+        // Collapse tool-only assistant messages. When the assistant
+        // emits N consecutive turns of pure tool_use without any
+        // commentary, we accumulate the tool names and attach them to
+        // the *next* assistant message that does have text (or, if the
+        // session ends mid-tool-storm, surface a single collapsed
+        // entry so the activity is not invisible).
+        let mut pending_tools: Vec<String> = Vec::new();
+        let mut last_tool_ts: Option<String> = None;
 
         for entry in &session.entries {
             match entry {
                 SessionEntry::User(u) => {
+                    if !pending_tools.is_empty() {
+                        let count = pending_tools.len();
+                        messages.push(ChatMessage {
+                            role: Role::Assistant,
+                            text: format!("({count} tool call(s) — no commentary)"),
+                            timestamp: last_tool_ts.take().unwrap_or_default(),
+                            tools: std::mem::take(&mut pending_tools),
+                        });
+                    }
                     if let Some(text) = extract_user_text(u) {
                         let clean = strip_xml_tags(&text);
                         if !clean.trim().is_empty() {
@@ -55,25 +72,43 @@ impl ChatView {
                     let texts = extract_assistant_texts(a);
                     let tools = extract_tool_uses(a);
                     let tool_names: Vec<String> = tools.iter().map(|(n, _)| n.clone()).collect();
-
                     let combined = texts.join("\n");
-                    if !combined.trim().is_empty() || !tool_names.is_empty() {
-                        let display_text = if combined.trim().is_empty() {
-                            format!("[{} tool call(s)]", tool_names.len())
-                        } else {
-                            combined
-                        };
+
+                    if combined.trim().is_empty() {
+                        // Tool-only turn: accumulate, do not render yet.
+                        if !tool_names.is_empty() {
+                            pending_tools.extend(tool_names);
+                            last_tool_ts = Some(format_ts(&a.timestamp));
+                        }
+                    } else {
+                        // Text turn: flush accumulated tools onto this
+                        // message together with its own.
+                        let mut all_tools = std::mem::take(&mut pending_tools);
+                        last_tool_ts = None;
+                        all_tools.extend(tool_names);
                         messages.push(ChatMessage {
                             role: Role::Assistant,
-                            text: display_text,
+                            text: combined,
                             timestamp: format_ts(&a.timestamp),
-                            tools: tool_names,
+                            tools: all_tools,
                         });
                     }
                 }
                 _ => {}
             }
         }
+        // Trailing tool-only burst: surface as one collapsed entry so
+        // it's visible the assistant did work, but without polluting
+        // the timeline with empty turns.
+        if !pending_tools.is_empty() {
+            let count = pending_tools.len();
+            messages.push(ChatMessage {
+                role: Role::Assistant,
+                text: format!("({count} tool call(s) — no commentary)"),
+                timestamp: last_tool_ts.unwrap_or_default(),
+                tools: pending_tools,
+            });
+        }
 
         let title = if let Some(first) = session.first_user_text() {
             let clean = strip_xml_tags(&first);

crates/tj-cli/src/tui/chat_view.rs

@@ -13,9 +13,12 @@ use serde::Deserialize;
 /// Backend that invokes `claude -p` via subprocess.
 ///
 /// Configuration:
-/// - `command`: program name (default `"claude"`); override for tests/dev.
-/// - `model`: model alias passed via `--model`. Overridable via the
-///   `TJ_CLASSIFIER_MODEL` env var; falls back to `DEFAULT_MODEL` (haiku —
+/// - `command`: full command line that produces `claude` invocation;
+///   default `"claude"`. May contain spaces to wrap the binary in a
+///   workspace orchestrator like `aimux run dt claude` or a Nix
+///   shell. Override via `TJ_CLASSIFIER_CLI` env var.
+/// - `model`: model alias passed via `--model`. Overridable via
+///   `TJ_CLASSIFIER_MODEL`; falls back to `DEFAULT_MODEL` (haiku —
 ///   cheaper than the user's session model).
 pub struct ClaudeCliClassifier {
     pub command: String,
@@ -28,7 +31,7 @@ pub const DEFAULT_MODEL: &str = "haiku";
 impl Default for ClaudeCliClassifier {
     fn default() -> Self {
         Self {
-            command: "claude".into(),
+            command: std::env::var("TJ_CLASSIFIER_CLI").unwrap_or_else(|_| "claude".into()),
             model: std::env::var("TJ_CLASSIFIER_MODEL").unwrap_or_else(|_| DEFAULT_MODEL.into()),
         }
     }
@@ -45,7 +48,17 @@ impl Classifier for ClaudeCliClassifier {
     fn classify(&self, input: &ClassifyInput) -> anyhow::Result<ClassifyOutput> {
         let prompt = crate::classifier::prompt::build(input);
 
-        let output = std::process::Command::new(&self.command)
+        // Split command on whitespace so users can wrap the binary
+        // in a workspace orchestrator: `aimux run dt claude`,
+        // `nix run nixpkgs#claude --`, etc.
+        let mut parts = self.command.split_whitespace();
+        let program = parts
+            .next()
+            .ok_or_else(|| anyhow!("TJ_CLASSIFIER_CLI is empty"))?;
+        let base_args: Vec<&str> = parts.collect();
+
+        let output = std::process::Command::new(program)
+            .args(&base_args)
             .args([
                 "-p",
                 "--model",
@@ -188,4 +201,64 @@ mod tests {
         assert!(err.contains("Not logged in"));
         assert!(err.contains("claude /login"));
     }
+
+    #[test]
+    fn classifier_command_with_spaces_runs_wrapper_then_target() {
+        // Simulates `aimux run dt claude` style wrappers: a launcher
+        // script that ignores its first argv, then forwards everything
+        // else to the real fake-claude. We verify TJ_CLASSIFIER_CLI
+        // splitting works end-to-end.
+        let dir = tempfile::TempDir::new().unwrap();
+
+        let inner = r#"{"event_type":"finding","task_id_guess":null,"confidence":0.9,"evidence_strength":null,"suggested_text":"x"}"#;
+        let envelope = serde_json::json!({
+            "type": "result",
+            "subtype": "success",
+            "is_error": false,
+            "result": inner,
+        });
+        let real_fake = fake_claude(dir.path(), &envelope.to_string());
+
+        // Wrapper script that takes a "profile" arg and delegates.
+        #[cfg(unix)]
+        let wrapper = {
+            use std::os::unix::fs::PermissionsExt;
+            let path = dir.path().join("fake-aimux.sh");
+            // shellcheck-clean: we intentionally drop $1 (profile name)
+            // and forward $2..$N to the real fake.
+            let script = format!(
+                "#!/bin/sh\nshift\nshift\nshift\nexec \"{}\" \"$@\"\n",
+                real_fake.to_string_lossy()
+            );
+            std::fs::write(&path, script).unwrap();
+            let mut perms = std::fs::metadata(&path).unwrap().permissions();
+            perms.set_mode(0o755);
+            std::fs::set_permissions(&path, perms).unwrap();
+            path
+        };
+        #[cfg(windows)]
+        let wrapper = {
+            let path = dir.path().join("fake-aimux.cmd");
+            // Drop %1 %2 %3 (run dt claude) and pass the rest.
+            let script = format!(
+                "@echo off\r\ncall \"{}\" %4 %5 %6 %7 %8 %9\r\n",
+                real_fake.to_string_lossy()
+            );
+            std::fs::write(&path, script).unwrap();
+            path
+        };
+
+        let c = ClaudeCliClassifier {
+            command: format!("{} run dt claude", wrapper.to_string_lossy()),
+            model: "haiku".into(),
+        };
+        let out = c
+            .classify(&ClassifyInput {
+                text: "x".into(),
+                author_hint: "user".into(),
+                recent_tasks: vec![],
+            })
+            .unwrap();
+        assert_eq!(out.event_type, EventType::Finding);
+    }
 }

crates/tj-core/src/classifier/cli.rs

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

crates/tj-mcp/Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "task-journal",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Append-only journal of AI-coding task reasoning chains: hypotheses, decisions, rejections, evidence. Renders compact resume packs so an agent can pick up a 2-week-old task with full context.",
   "author": {
     "name": "Mher Shahinyan"

plugin/.claude-plugin/plugin.json

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