feat(ingest): auto-open task on first prompt — v0.5.0 Phase A (v0.4.1)

UserPromptSubmit firing into an empty project no longer drops the
prompt silently. The journal synthesizes a task on the fly with
title=first line(80), goal=prompt(200), then continues the normal
classifier pipeline so the same prompt becomes the first event.

Removes the manual "task-journal create --goal" prerequisite that
was blocking real-world usage — users do not call create.

- auto_open_task_from_prompt() helper in tj-cli
- meta.auto_opened=true marker on synthesized open events
- TJ_AUTO_OPEN_TASKS=0 opt-out (default ON)
- Only fires for UserPromptSubmit; PostToolUse/Stop never conjure tasks
- 2 new integration tests cover both branches
- Phase B (artifacts) and Phase C (linked_issue/reopen) tracked in
  .docs/plans/2026-05-08-v0.5.0-auto-everything.md

49/49 tj-cli tests pass; 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.0"
+    "version": "0.4.1"
   },
   "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.0",
+      "version": "0.4.1",
       "author": {
         "name": "Digital-Threads"
       },

.docs/plans/2026-05-08-v0.5.0-auto-everything.md

@@ -0,0 +1,75 @@
+# v0.5.0 — auto-everything
+
+Epic: `tj-z1q3t489kt`
+
+Цель: убрать ручную дисциплину `create --goal` / `external --add` /
+поиск старой задачи. Claude через хуки делает сам.
+
+## Phase A — auto-create
+
+**Trigger:** UserPromptSubmit хук, нет открытой задачи в текущем
+project_hash, либо последняя активность >24h назад.
+
+**Логика:**
+1. Хук получает текст промпта
+2. Запрос FTS5 по closed-за-30-дней: совпадение по тикет-номерам
+   (FIN-XXX, JIRA-XXX, INC-XXX), commit hash, ключевые слова
+3. Если sim > 0.7 → emit "candidate_reopen" event в pending,
+   classifier предложит reopen старой
+4. Иначе → авто-create новой, goal = trim(первые 200 char промпта)
+5. Все последующие события сессии цепляются автоматом
+
+**Опт-аут:** `TJ_AUTO_OPEN_TASKS=0`. По умолчанию ON.
+
+## Phase B — artifacts auto-extract
+
+**Колонка** `events_index.artifacts` уже есть (schema v003).
+
+**Извлечение в classifier JSON:**
+- `commit_hash` — regex `[a-f0-9]{7,40}` в Bash output после
+  `git commit` / `git log`
+- `pr_url` — regex `https://github\.com/.+/pull/\d+` в `gh pr create`
+  output
+- `files` — все `tool_input.file_path` из Edit/Write tool calls
+- `linked_issue` — regex `[A-Z]+-\d+` в тексте промптов
+- `branch_name` — текущая ветка через `git symbolic-ref` при
+  SessionStart
+
+**Pack:** новый блок `**Artifacts**:` с группировкой commits / files
+/ PRs / issues.
+
+**Reclassify:** новая команда `task-journal reclassify <id>` —
+проходит по существующим событиям, вытаскивает артефакты regex'ами,
+заполняет `artifacts` колонку. Idempotent.
+
+## Phase C — linked_issue / reopen suggest
+
+**При новом событии classifier:**
+1. Смотрит open + closed-30d
+2. Считает score по: shared linked_issue (vec 1.0), commit hash overlap
+   (0.8), file overlap >50% (0.7), FTS5 sim (0-0.5)
+3. Score > 0.7 + open task → cепляет к ней
+4. Score > 0.7 + closed task → emit "linked_to_closed" warning
+   событие, в pack видно "🔗 linked to tj-xxx [closed]"
+5. Юзер решает: `task-journal reopen <id>` или
+   `task-journal external <new> --add tj-xxx`
+
+**Reopen:** новая команда `task-journal reopen <id>` —
+status=open, append `[reopen]` event с reason. Schema без
+изменений (статус уже строка).
+
+## Order of work
+
+1. Phase A (auto-create) — без неё B/C не используются
+2. Phase B (artifacts) — даёт сигнал для C
+3. Phase C (linked_issue) — последний
+
+## Acceptance
+
+После v0.5.0 юзер может **никогда** не вызывать `create` /
+`external` руками. Запускает Claude → работает → закрывает CLI →
+журнал имеет полную задачу с goal/events/artifacts.
+
+Закрытие пока остаётся ручным (`close --outcome --outcome-tag`) —
+это явный акт "я закончил, выводы такие". Авто-close будет в
+v0.6.0 (heuristic: 7 дней без активности → suggest close).

CHANGELOG.md

@@ -7,6 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-05-08
+
+v0.5.0 Phase A — auto-create tasks. Removes the manual
+`task-journal create --goal "..."` step. The journal now opens a
+task on demand the first time a UserPromptSubmit fires into an
+empty project, taking the prompt itself as the goal. No prompt is
+ever lost again.
+
+### Added
+- `auto_open_task_from_prompt()` helper in `tj-cli`. Synthesizes a
+  task with `title = first line trimmed to 80 chars`,
+  `goal = prompt trimmed to 200 chars`, then continues the normal
+  classifier pipeline so the same prompt becomes the first event on
+  the task it just opened.
+- `meta.auto_opened: true` flag on synthesized open events so
+  reclassify / analytics can distinguish auto-opened tasks from
+  user-created ones.
+
+### Changed
+- `ingest-hook` previously dropped UserPromptSubmit events when no
+  open task existed. Now it auto-opens unless the assistant tool
+  call is the trigger (PostToolUse / Stop never conjure tasks).
+
+### Configuration
+- `TJ_AUTO_OPEN_TASKS=0` (or `false`) restores the v0.4.0 silent-
+  drop behaviour. Default is ON.
+
+### Phase B/C still pending
+- B (artifacts auto-extract: commit_hash, pr_url, files, linked_issue)
+- C (linked_issue / reopen suggestion when prompt matches a recently
+  closed task)
+
 ## [0.4.0] - 2026-05-08
 
 Task model redesign — Phase 1. A task is now an explicit

Cargo.lock

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

crates/tj-cli/Cargo.toml

@@ -1396,10 +1396,27 @@ fn main() -> Result<()> {
                     if events_path.exists() {
                         tj_core::db::ingest_new_events(&conn, &events_path, &project_hash)?;
                     }
-                    let recent = recent_task_contexts(&conn, 5)?;
+                    let mut recent = recent_task_contexts(&conn, 5)?;
                     if recent.is_empty() {
-                        // No active tasks — nothing to classify against. Skip silently.
-                        return Ok(());
+                        // No open tasks. v0.5.0 Phase A: auto-open a new
+                        // task from the user's prompt so subsequent
+                        // events have somewhere to land. Without this
+                        // every fresh session was a black hole — events
+                        // dropped silently because there was nothing to
+                        // classify against. Opt-out via
+                        // TJ_AUTO_OPEN_TASKS=0; only fires for
+                        // UserPromptSubmit (assistant tool calls
+                        // shouldn't conjure tasks).
+                        let auto_open_disabled = std::env::var("TJ_AUTO_OPEN_TASKS")
+                            .ok()
+                            .map(|v| v == "0" || v.eq_ignore_ascii_case("false"))
+                            .unwrap_or(false);
+                        if auto_open_disabled || !kind.contains("UserPrompt") {
+                            return Ok(());
+                        }
+                        let new_task =
+                            auto_open_task_from_prompt(&events_path, &project_hash, &conn, &text)?;
+                        recent.push(new_task);
                     }
 
                     use tj_core::classifier::Classifier;
@@ -1943,6 +1960,55 @@ fn recent_task_contexts(
     Ok(out)
 }
 
+/// v0.5.0 Phase A: when ingest-hook fires UserPromptSubmit and there
+/// are no open tasks, synthesize one from the prompt itself. Title is
+/// the first line trimmed to 80 chars; goal is the prompt trimmed to
+/// 200 chars. Returns a TaskContext so the classifier has somewhere
+/// to attach the same prompt as the first real event.
+fn auto_open_task_from_prompt(
+    events_path: &std::path::Path,
+    project_hash: &str,
+    conn: &rusqlite::Connection,
+    prompt: &str,
+) -> anyhow::Result<tj_core::classifier::TaskContext> {
+    let cleaned = prompt.trim();
+    // Title: first non-empty line, ≤80 chars. Falls back to "(empty
+    // prompt)" so we never write a NULL title — the classifier and
+    // the TUI both display titles directly.
+    let title: String = cleaned
+        .lines()
+        .map(|l| l.trim())
+        .find(|l| !l.is_empty())
+        .map(|l| l.chars().take(80).collect())
+        .unwrap_or_else(|| "(auto-opened: empty prompt)".to_string());
+    let goal: String = cleaned.chars().take(200).collect();
+
+    let task_id = tj_core::new_task_id();
+    let mut event = tj_core::event::Event::new(
+        task_id.clone(),
+        tj_core::event::EventType::Open,
+        tj_core::event::Author::User,
+        tj_core::event::Source::Cli,
+        title.clone(),
+    );
+    event.meta = serde_json::json!({ "title": title, "auto_opened": true });
+
+    let mut writer = tj_core::storage::JsonlWriter::open(events_path)?;
+    writer.append(&event)?;
+    writer.flush_durable()?;
+
+    tj_core::db::ingest_new_events(conn, events_path, project_hash)?;
+    if !goal.is_empty() {
+        tj_core::db::set_task_goal(conn, &task_id, &goal)?;
+    }
+
+    Ok(tj_core::classifier::TaskContext {
+        task_id,
+        title,
+        last_events: vec![],
+    })
+}
+
 fn persist_pending(events_path: &std::path::Path, text: &str, err: &str) -> anyhow::Result<()> {
     let pending_dir = events_path
         .parent()

crates/tj-cli/src/main.rs

@@ -1815,3 +1815,103 @@ fn help_lists_subcommands() {
         .stdout(contains("events"))
         .stdout(contains("rebuild-state"));
 }
+
+#[test]
+fn ingest_hook_auto_opens_task_when_no_open_tasks() {
+    // v0.5.0 Phase A: a UserPromptSubmit hook firing into an empty
+    // project must synthesize a task on the fly, otherwise the prompt
+    // (and every event after it) is dropped silently.
+    let dir = assert_fs::TempDir::new().unwrap();
+
+    // Force the classifier to fail so the rest of the pipeline doesn't
+    // try to spawn `claude -p`. Auto-open happens BEFORE the classifier
+    // call, so the task should still be created.
+    let payload = serde_json::json!({
+        "hook_event_name": "UserPromptSubmit",
+        "session_id": "s-auto",
+        "transcript_path": "/tmp/x",
+        "cwd": "/tmp",
+        "prompt": "implement FIN-868 paygate fee dedup"
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .env("TJ_CLASSIFIER_CLI", "/bin/false")
+        .args(["ingest-hook", "--backend", "cli"])
+        .write_stdin(payload)
+        .assert()
+        .success();
+
+    // Auto-opened task is now searchable. Pack it and check that the
+    // goal field equals the prompt text — that's the contract.
+    let search_out = Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["search", "paygate"])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let body = String::from_utf8(search_out).unwrap();
+    // Search output is task-id-per-line. A non-empty body proves the
+    // auto-opened task was indexed by FTS5 against the prompt text.
+    let task_id = body
+        .lines()
+        .next()
+        .map(|s| s.trim().to_string())
+        .filter(|s| s.starts_with("tj-"))
+        .unwrap_or_else(|| {
+            panic!("search must surface the auto-opened task by prompt text, got: {body:?}")
+        });
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["pack", &task_id, "--mode", "full"])
+        .assert()
+        .success()
+        .stdout(contains("**Goal**: implement FIN-868 paygate fee dedup"));
+}
+
+#[test]
+fn ingest_hook_auto_open_disabled_via_env() {
+    // Opt-out path: TJ_AUTO_OPEN_TASKS=0 must restore the v0.4.0
+    // behaviour (drop the prompt silently when no open task exists).
+    let dir = assert_fs::TempDir::new().unwrap();
+    let payload = serde_json::json!({
+        "hook_event_name": "UserPromptSubmit",
+        "session_id": "s-noop",
+        "transcript_path": "/tmp/x",
+        "cwd": "/tmp",
+        "prompt": "marker_noautoopen_xyz must not appear"
+    })
+    .to_string();
+
+    Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .env("TJ_CLASSIFIER_CLI", "/bin/false")
+        .env("TJ_AUTO_OPEN_TASKS", "0")
+        .args(["ingest-hook", "--backend", "cli"])
+        .write_stdin(payload)
+        .assert()
+        .success();
+
+    let search_out = Command::cargo_bin("task-journal")
+        .unwrap()
+        .env("XDG_DATA_HOME", dir.path())
+        .args(["search", "marker_noautoopen_xyz"])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let body = String::from_utf8(search_out).unwrap();
+    assert!(
+        !body.contains("marker_noautoopen_xyz"),
+        "auto-open must be skipped when TJ_AUTO_OPEN_TASKS=0, got: {body:?}"
+    );
+}

crates/tj-cli/tests/cli.rs

@@ -16,7 +16,7 @@ name = "task-journal-mcp"
 path = "src/main.rs"
 
 [dependencies]
-tj-core = { package = "task-journal-core", version = "0.4.0", path = "../tj-core" }
+tj-core = { package = "task-journal-core", version = "0.4.1", 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.4.0",
+  "version": "0.4.1",
   "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"