feat(v0.6.0): MCP parity, score-based linking, hygiene CLIs

Closes the v0.5.0 backlog items 1-7 in one batch.

MCP parity:
- task_create accepts goal; task_close accepts outcome_tag with the
  same enum validation as the CLI. Agents can now drive the journal
  end-to-end without falling back to the CLI for new fields.

Smarter linking (Phase C+):
- db::find_related_tasks scores by linked_issue (1.0) +
  commit_hash (0.8) + file path (0.3). Replaces the linked-issue-only
  scan in auto-open. Picks up cross-task continuations even when the
  user prompt didn't include a ticket id.
- Pack splits `linked:tj-xxx` external entries into a dedicated
  **Linked**: block with the live status of each pointer.
- Artifact extractor now captures `.docs/specs/auth.md`,
  `.github/workflows/ci.yml` and other dot-prefixed dirs.

Hygiene CLI:
- `task-journal stale [--days 7]` lists open tasks idle past the
  threshold with a hint to close-with-abandoned.
- `task-journal pending-gc [--days 7]` deletes pending classifier
  payloads older than the threshold (post-outage cleanup).

Classifier protocol:
- ClassifyOutput.artifacts (Option, #[serde(default)]) — wire is
  ready for richer model output without breaking old payloads.

Tests: 53 tj-cli + 147 tj-core, clippy/fmt clean.

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.5.0"
+    "version": "0.6.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.5.0",
+      "version": "0.6.0",
       "author": {
         "name": "Digital-Threads"
       },

CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-05-08
+
+Backlog cleanup: MCP brought in line with CLI, score-based linking,
+TUI/pack split out a Linked block, hygiene commands for stale tasks
+and pending GC, and the classifier protocol got an artifacts field
+ready for richer model output.
+
+### Added — MCP parity
+- `task_create` MCP tool now accepts `goal: Option<String>` and
+  persists it via `set_task_goal` after writing the open event.
+- `task_close` MCP tool now accepts `outcome_tag: Option<String>`
+  validated against `done|abandoned|superseded`. Outcome + tag
+  both go into the tasks table and the close event meta.
+
+### Added — Hygiene CLI commands
+- `task-journal stale [--days 7]` lists open tasks whose last event
+  crossed the inactivity threshold. Sorted by idle time descending.
+  Hint at the bottom suggests close-with-abandoned for the obvious
+  cases.
+- `task-journal pending-gc [--days 7]` deletes pending classifier
+  payloads older than the threshold. Useful after a long classifier
+  outage when the queue stops being recoverable.
+
+### Added — Smarter linking
+- `db::find_related_tasks` scores tasks by overlap on
+  `linked_issue` (1.0), `commit_hash` (0.8), and `file path` (0.3).
+  Replaces the linked-issue-only scan inside auto-open.
+- Pack render splits `linked:tj-xxx` entries into a dedicated
+  `**Linked**:` block with the live status of each pointer (`open`
+  / `closed` / `unknown`). Other external references stay in
+  `**External**`.
+- Artifact extractor now captures dot-prefixed directories
+  (`.docs/specs/auth.md`, `.github/workflows/ci.yml`).
+
+### Added — Classifier protocol
+- `ClassifyOutput.artifacts: Option<Artifacts>` (with `#[serde(default)]`
+  for backwards compat). Field is ready for the next prompt
+  iteration that will instruct the model to return structured
+  artifacts; current behaviour unchanged (regex extraction still
+  the source of truth).
+
+### Tests
+- 1 new unit test for dot-prefixed directory extraction.
+- All previous tests updated for the new External/Linked split.
+
 ## [0.5.0] - 2026-05-08
 
 Auto-everything release. Phase B + C of the v0.5.0 plan land

Cargo.lock

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

crates/tj-cli/Cargo.toml

@@ -646,6 +646,23 @@ enum Commands {
         #[arg(long)]
         reason: Option<String>,
     },
+    /// List open tasks with no activity for N+ days. Use to clean up
+    /// tasks that auto-opened, got a few events, then went silent —
+    /// candidates for `task-journal close --outcome-tag abandoned`.
+    Stale {
+        /// Inactivity threshold in days. Default 7.
+        #[arg(long, default_value_t = 7)]
+        days: i64,
+    },
+    /// Garbage-collect the pending classifier queue. Removes entries
+    /// older than N days OR marked dead by retry exhaustion. Run after
+    /// classifier auth was broken for a while and the queue grew
+    /// stale.
+    PendingGc {
+        /// Age threshold in days. Default 7.
+        #[arg(long, default_value_t = 7)]
+        days: i64,
+    },
     /// Set or update the goal of an existing task.
     Goal {
         task_id: String,
@@ -1026,6 +1043,73 @@ fn main() -> Result<()> {
             writer.flush_durable()?;
             println!("{}", event.event_id);
         }
+        Commands::Stale { days } => {
+            let cwd = std::env::current_dir()?;
+            let project_hash = tj_core::project_hash::from_path(&cwd)?;
+            let events_path = tj_core::paths::events_dir()?.join(format!("{project_hash}.jsonl"));
+            let state_path = tj_core::paths::state_dir()?.join(format!("{project_hash}.sqlite"));
+            let conn = tj_core::db::open(&state_path)?;
+            if events_path.exists() {
+                tj_core::db::ingest_new_events(&conn, &events_path, &project_hash)?;
+            }
+            let stale = tj_core::db::stale_tasks(&conn, days)?;
+            if stale.is_empty() {
+                println!("(no stale tasks — all open tasks active within {days} days)");
+            } else {
+                println!("# Stale tasks (idle ≥ {days} days)\n");
+                for t in stale {
+                    println!(
+                        "{}  {} days idle  {}  {}",
+                        t.task_id, t.days_idle, t.last_event_at, t.title
+                    );
+                }
+                println!(
+                    "\nClose abandoned ones with: task-journal close <id> --outcome-tag abandoned --reason <why>"
+                );
+            }
+        }
+        Commands::PendingGc { days } => {
+            let pending_dir = tj_core::paths::events_dir()?
+                .parent()
+                .ok_or_else(|| anyhow::anyhow!("events_dir has no parent"))?
+                .join("pending");
+            if !pending_dir.exists() {
+                println!("(no pending dir — nothing to gc)");
+                return Ok(());
+            }
+            let cutoff = chrono::Utc::now() - chrono::Duration::days(days);
+            let mut removed = 0usize;
+            for entry in std::fs::read_dir(&pending_dir)? {
+                let entry = entry?;
+                let path = entry.path();
+                if path.extension().and_then(|s| s.to_str()) != Some("json") {
+                    continue;
+                }
+                // Prefer the file's mtime over JSON parsing — pending
+                // payloads include their own queued_at but are not
+                // guaranteed parseable when the classifier corrupted
+                // input mid-stream.
+                let mtime = entry
+                    .metadata()
+                    .and_then(|m| m.modified())
+                    .ok()
+                    .and_then(|t| {
+                        chrono::DateTime::<chrono::Utc>::from(t)
+                            .signed_duration_since(cutoff)
+                            .num_seconds()
+                            .into()
+                    });
+                if let Some(secs) = mtime {
+                    if secs < 0 && std::fs::remove_file(&path).is_ok() {
+                        removed += 1;
+                    }
+                }
+            }
+            println!(
+                "removed {} stale pending entries (older than {} days)",
+                removed, days
+            );
+        }
         Commands::Reopen { task_id, reason } => {
             // The Reopen event itself flips tasks.status back to open
             // when ingested (db::apply_lifecycle handles this). The CLI
@@ -2070,27 +2154,29 @@ fn auto_open_task_from_prompt(
         tj_core::db::set_task_goal(conn, &task_id, &goal)?;
     }
 
-    // v0.5.0 Phase C: if the prompt mentions any tracked issue
-    // identifiers (FIN-868, JIRA-123…), search the journal for prior
-    // tasks that referenced the same issue. Auto-link them via the
-    // External column and warn on stderr when the prior is closed —
-    // user can reopen it instead of starting fresh.
+    // v0.5.0 Phase C / v0.6.0: score-based linking. Pull artifacts
+    // from the prompt — ticket ids, commit hashes, file paths — then
+    // ask the journal which prior tasks share enough signal to be a
+    // probable continuation. Anything with score > 0 gets linked via
+    // External; the strongest closed match also triggers a stderr
+    // hint so the user can reopen instead of accumulating duplicates.
     let prompt_arts = tj_core::artifacts::extract(prompt);
-    if !prompt_arts.linked_issues.is_empty() {
-        let related = tj_core::db::find_tasks_by_linked_issues(conn, &prompt_arts.linked_issues)?;
-        for (other_id, status) in related {
-            if other_id == task_id {
+    if !prompt_arts.is_empty() {
+        let related = tj_core::db::find_related_tasks(conn, &prompt_arts)?;
+        let mut warned = false;
+        for r in related.iter().take(5) {
+            if r.task_id == task_id {
                 continue;
             }
-            let _ = tj_core::db::add_task_external(conn, &task_id, &format!("linked:{other_id}"));
-            if status == "closed" {
+            let _ =
+                tj_core::db::add_task_external(conn, &task_id, &format!("linked:{}", r.task_id));
+            if !warned && r.status == "closed" {
                 eprintln!(
-                    "task-journal: prompt references issue(s) {}, which appear in closed task {} — \
-                     run `task-journal reopen {}` if this is a continuation rather than new scope.",
-                    prompt_arts.linked_issues.join(","),
-                    other_id,
-                    other_id
+                    "task-journal: this prompt looks like a continuation of closed task {} \
+                     (score {:.1}) — run `task-journal reopen {}` if it is.",
+                    r.task_id, r.score, r.task_id
                 );
+                warned = true;
             }
         }
     }

crates/tj-cli/src/main.rs

@@ -2013,7 +2013,11 @@ fn auto_open_links_to_prior_task_referencing_same_issue() {
         .args(["pack", &new_id, "--mode", "full"])
         .assert()
         .success()
-        .stdout(contains(format!("linked:{}", prior)));
+        // v0.6.0: linked entries surface in their own **Linked** block
+        // instead of mashed into External, with the prior task's
+        // current status annotated next to the id.
+        .stdout(contains("**Linked**:"))
+        .stdout(contains(format!("- {} [closed]", prior)));
 }
 
 #[test]

crates/tj-cli/tests/cli.rs

@@ -95,11 +95,13 @@ pub fn extract(text: &str) -> Artifacts {
     );
 
     // File paths — heuristic: path-like tokens with at least one slash
-    // (and an extension) OR a leading ./ . Tight enough to skip prose,
-    // loose enough to catch the common cases (src/foo.rs, ./bar.ts,
+    // (and an extension) OR a leading ./ . Path segments allow a
+    // leading dot so `.docs/specs/auth.md`, `.github/workflows/ci.yml`
+    // etc are captured as artifacts. Tight enough to skip prose, loose
+    // enough to catch the common cases (src/foo.rs, ./bar.ts,
     // crates/tj-core/src/db.rs).
     static_re(
-        r"(?:\./|[A-Za-z0-9_\-]+/)+[A-Za-z0-9_.\-]+\.[A-Za-z0-9]{1,8}\b",
+        r"(?:\./|\.?[A-Za-z0-9_\-]+/)+[A-Za-z0-9_.\-]+\.[A-Za-z0-9]{1,8}\b",
         |m| a.files.push(m.to_string()),
         text,
     );
@@ -183,6 +185,16 @@ mod tests {
         assert!(a.files.contains(&"./README.md".to_string()));
     }
 
+    #[test]
+    fn extracts_dot_prefixed_dirs() {
+        // .docs/specs/*.md, .github/workflows/*.yml — leading-dot dirs
+        // are spec/config holders we want surfaced as artifacts so the
+        // pack ties decisions back to the document that justified them.
+        let a = extract("see .docs/specs/auth.md and .github/workflows/ci.yml");
+        assert!(a.files.contains(&".docs/specs/auth.md".to_string()));
+        assert!(a.files.contains(&".github/workflows/ci.yml".to_string()));
+    }
+
     #[test]
     fn extracts_branch_names() {
         let a = extract("git checkout -b FIN-868-fix-paygate-fee then switch -c hotfix/abc");

crates/tj-core/src/artifacts.rs

@@ -26,6 +26,7 @@ mod tests {
                 confidence: 0.95,
                 evidence_strength: None,
                 suggested_text: "...".into(),
+                artifacts: None,
             },
         };
         let out = m

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

@@ -25,6 +25,14 @@ pub struct ClassifyOutput {
     pub confidence: f64,
     pub evidence_strength: Option<EvidenceStrength>,
     pub suggested_text: String,
+    /// v0.6.0: optional structured artifacts the classifier extracted
+    /// directly. When absent (old protocol or model didn't bother),
+    /// the journal falls back to regex extraction in
+    /// `db::ingest_new_events`. When present, the two sets are merged
+    /// at ingest time so the model can surface artifacts the regex
+    /// would miss (e.g. ticket ids in non-ASCII brackets).
+    #[serde(default)]
+    pub artifacts: Option<crate::artifacts::Artifacts>,
 }
 
 pub trait Classifier: Send + Sync {