feat(v0.5.0): artifacts auto-extract + linked_issue auto-link (Phase B+C)

Closes the auto-everything plan opened by Phase A (v0.4.1). The
journal now scrapes commit hashes / PR URLs / ticket IDs / files /
branches out of every event automatically, and prompts that
mention a known ticket auto-link back to the prior task that
handled it.

Phase B — artifacts:
- tj_core::artifacts module (regex extract + dedup + serde).
- events_index.artifacts populated on every ingest_new_events.
- db::task_artifacts aggregator.
- Pack renders **Artifacts**: commits/PRs/issues/files/branches.
- New `task-journal reclassify <id>` backfills v0.4.x events.

Phase C — linked_issue / reopen:
- db::find_tasks_by_linked_issues searches every task whose
  events reference a given ticket id.
- auto_open_task_from_prompt extracts artifacts from the prompt
  and adds `linked:tj-old-id` to External when a prior task is
  found. stderr hint suggests reopen when the prior is closed.
- New `task-journal reopen <id> [--reason ...]` flips a closed
  task back to open via [reopen] event.

Schema migration v004 wipes pack cache so Artifacts block
appears on next render for existing tasks.

13 new tests (9 unit + 4 integration). 53/53 tj-cli tests,
146/146 tj-core tests, 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.4.1"
+    "version": "0.5.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.4.1",
+      "version": "0.5.0",
       "author": {
         "name": "Digital-Threads"
       },

CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-05-08
+
+Auto-everything release. Phase B + C of the v0.5.0 plan land
+together: artifacts get scraped out of every event automatically,
+and prompts that mention a known ticket id auto-link back to the
+prior task that handled it.
+
+### Added — Phase B (artifacts auto-extract)
+- New `tj_core::artifacts` module with `Artifacts` struct +
+  regex-based `extract(text)`. Pulls commit hashes (7-40 hex), GitHub
+  / GitLab PR URLs, ticket IDs (FIN-868 etc), file paths, and branch
+  names from any free-form text.
+- `events_index.artifacts` (added in v0.4.0 schema v003) is now
+  populated on every `ingest_new_events` call. Per-event JSON keeps
+  reclassify cheap.
+- `db::task_artifacts(conn, task_id)` aggregates and dedupes across
+  every event of a task.
+- Pack output gets a new `**Artifacts**:` block listing commits, PRs,
+  issues, files, branches when any are present.
+- New CLI `task-journal reclassify <task_id>` walks existing events
+  and backfills `artifacts` for journals upgraded from v0.4.x.
+
+### Added — Phase C (linked_issue / reopen)
+- `db::find_tasks_by_linked_issues(conn, issues)` searches every
+  task whose events reference a given ticket id.
+- `auto_open_task_from_prompt` now extracts artifacts from the
+  prompt; if any ticket id matches a prior task, the new task gets
+  `linked:tj-old-id` appended to its External column. When the prior
+  task is closed, a hint goes to stderr suggesting
+  `task-journal reopen <id>` instead of fresh scope.
+- New CLI `task-journal reopen <task_id> [--reason "..."]` flips a
+  closed task back to open (writes a `[reopen]` event whose lifecycle
+  hook handles the status flip).
+
+### Schema
+- Migration v004 wipes the pack cache so existing tasks pick up the
+  new Artifacts block on next render. Events still need `reclassify`
+  to backfill the `artifacts` column for old data.
+
+### Tests
+- 9 new unit tests for `tj_core::artifacts` (commit / PR / issue /
+  file / branch extraction + dedup + JSON round-trip).
+- 4 new integration tests in tj-cli covering pack rendering with
+  artifacts, reclassify backfill, reopen lifecycle, and Phase C
+  auto-link to closed task.
+
 ## [0.4.1] - 2026-05-08
 
 v0.5.0 Phase A — auto-create tasks. Removes the manual

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 rust-version = "1.88"
 license = "MIT"
@@ -39,6 +39,7 @@ ureq = { version = "2", features = ["json"] }
 ratatui = "0.29"
 crossterm = "0.28"
 fd-lock = "4"
+regex = "1"
 
 # Test deps
 assert_fs = "1"

Cargo.toml

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

crates/tj-cli/Cargo.toml

@@ -636,6 +636,16 @@ enum Commands {
         #[arg(long)]
         outcome_tag: Option<String>,
     },
+    /// Reopen a previously closed task (writes a `reopen` event and
+    /// flips status back to `open`). Use when the same scope comes
+    /// back, e.g. a regression on a shipped fix or a follow-up bug
+    /// that belongs in the original chain rather than a new task.
+    Reopen {
+        task_id: String,
+        /// One-line reason for reopening (regression, follow-up, etc).
+        #[arg(long)]
+        reason: Option<String>,
+    },
     /// Set or update the goal of an existing task.
     Goal {
         task_id: String,
@@ -653,6 +663,11 @@ enum Commands {
         #[arg(long = "add")]
         add: String,
     },
+    /// Re-run artifact extraction over every event of a task and
+    /// refresh the pack cache. Use after upgrading from v0.4.x — older
+    /// events were ingested before the artifact column was populated,
+    /// so they have empty `artifacts` JSON until reclassify backfills.
+    Reclassify { task_id: String },
     /// Full-text search across events (FTS5).
     Search {
         /// Query string.
@@ -1011,6 +1026,38 @@ fn main() -> Result<()> {
             writer.flush_durable()?;
             println!("{}", event.event_id);
         }
+        Commands::Reopen { task_id, reason } => {
+            // The Reopen event itself flips tasks.status back to open
+            // when ingested (db::apply_lifecycle handles this). The CLI
+            // job is just to assert the task exists and write the event.
+            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)?;
+            }
+            if !tj_core::db::task_exists(&conn, &task_id)? {
+                anyhow::bail!("task not found: {task_id}");
+            }
+            drop(conn);
+
+            let mut event = tj_core::event::Event::new(
+                &task_id,
+                tj_core::event::EventType::Reopen,
+                tj_core::event::Author::User,
+                tj_core::event::Source::Cli,
+                reason.clone().unwrap_or_else(|| "(reopened)".into()),
+            );
+            if let Some(r) = reason {
+                event.meta = serde_json::json!({"reason": r});
+            }
+            let mut writer = tj_core::storage::JsonlWriter::open(&events_path)?;
+            writer.append(&event)?;
+            writer.flush_durable()?;
+            println!("{}", event.event_id);
+        }
         Commands::Goal { task_id, text } => {
             let cwd = std::env::current_dir()?;
             let project_hash = tj_core::project_hash::from_path(&cwd)?;
@@ -1043,6 +1090,27 @@ fn main() -> Result<()> {
             tj_core::db::add_task_external(&conn, &task_id, &add)?;
             println!("ok");
         }
+        Commands::Reclassify { task_id } => {
+            // Walk events_index for this task, re-run artifact extraction
+            // over each event's text (looked up via search_fts), and
+            // overwrite the artifacts column. Pack cache is wiped after
+            // so the next render picks up the new artifacts block. Used
+            // primarily to backfill v0.4.x events that were ingested
+            // before extraction existed.
+            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)?;
+            }
+            if !tj_core::db::task_exists(&conn, &task_id)? {
+                anyhow::bail!("task not found: {task_id}");
+            }
+            let count = tj_core::db::reclassify_task_artifacts(&conn, &task_id)?;
+            println!("reclassified {} events", count);
+        }
         Commands::EventCorrect {
             corrects,
             task,
@@ -2002,6 +2070,31 @@ 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.
+    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 {
+                continue;
+            }
+            let _ = tj_core::db::add_task_external(conn, &task_id, &format!("linked:{other_id}"));
+            if 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
+                );
+            }
+        }
+    }
+
     Ok(tj_core::classifier::TaskContext {
         task_id,
         title,