feat: v0.1.3 — export, TUI search, 71 new tests, README

Major additions:
- task-journal export --format md|json — pipe tasks to stdout
- TUI: / search filter, session duration, project path in header
- 71 new tests across parser, discovery, extractor, chat_view (170 total)
- Comprehensive README with installation, commands, architecture docs

Version bump: 0.1.2 → 0.1.3

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

Author: Shahinyanm

Cargo.lock

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

Cargo.toml

@@ -1,91 +1,119 @@
 # Task Journal
 
+[![Crates.io](https://img.shields.io/crates/v/task-journal-cli.svg)](https://crates.io/crates/task-journal-cli)
 [![CI](https://github.com/Digital-Threads/Task-Journal/workflows/CI/badge.svg)](https://github.com/Digital-Threads/Task-Journal/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-Append-only journal for AI-coding tasks. Captures the *reasoning chain* — goals, hypotheses, decisions, rejections, evidence — and renders a compact resume pack on demand so an agent can pick up a 2-week-old task with full context.
+Reasoning chain memory for AI coding sessions.
 
-**Why:** existing memory tools store sessions, issues, or do flat semantic search. None store the *logical chain* of a single task. After two weeks, the code remains but the *why* is gone. Task Journal fixes that.
+Task Journal captures the *logical chain* of a coding task -- goals, hypotheses, decisions, rejections, evidence, corrections -- as an append-only event log. When you come back to a two-week-old task, the code is still there but the *why* is gone. Task Journal preserves it.
 
-> Task Journal is the first plugin in the `claude-memory` marketplace.
+Unlike session-based memory tools that store raw chat history or flat semantic search, Task Journal records structured reasoning events tied to individual tasks, and renders compact resume packs so an agent (or you) can pick up exactly where work left off.
 
-## Install
+## Installation
 
-**Option 1 — from crates.io (recommended)**
+**From crates.io (recommended)**
 
 ```bash
 cargo install task-journal-cli task-journal-mcp
 ```
 
-**Option 2 — pre-built binary**
+**As a Claude Code plugin**
 
-Download the right archive for your OS/arch from [GitHub Releases](https://github.com/Digital-Threads/Task-Journal/releases), unpack, put `task-journal` and `task-journal-mcp` somewhere in your `$PATH`.
+```bash
+claude plugin install github:Digital-Threads/Task-Journal
+```
+
+**Pre-built binary**
 
-**Option 3 — build from source**
+Download the right archive for your OS/arch from [GitHub Releases](https://github.com/Digital-Threads/Task-Journal/releases), unpack, and place `task-journal` and `task-journal-mcp` somewhere in your `$PATH`.
+
+**From source**
 
 ```bash
 git clone https://github.com/Digital-Threads/Task-Journal
 cd Task-Journal
 cargo install --path crates/tj-cli --path crates/tj-mcp
 ```
 
-## Quick start
+## Quick Start
 
 ```bash
-# Open a task
+# 1. Create a task
 task-journal create "Add OAuth login"
-# → tj-x9rz1f
+# => tj-x9rz1f
 
-# Record decisions / findings as you work
+# 2. Record reasoning events as you work
 task-journal event tj-x9rz1f --type hypothesis --text "PKCE vs implicit grant"
-task-journal event tj-x9rz1f --type decision --text "Adopt PKCE flow"
-task-journal event tj-x9rz1f --type rejection --text "Implicit grant: deprecated"
+task-journal event tj-x9rz1f --type decision   --text "Adopt PKCE flow"
+task-journal event tj-x9rz1f --type rejection   --text "Implicit grant: deprecated by RFC"
 
-# Get a resume pack (Markdown)
+# 3. Resume later with a context pack
 task-journal pack tj-x9rz1f --mode full
 ```
 
-Sample output:
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `create <title>` | Create a new task (writes an `open` event) |
+| `event <id> --type X --text Y` | Append a typed event to a task |
+| `close <id> [--reason "..."]` | Close a task |
+| `event-correct --corrects <eid> --task <id> --text "..."` | Append a correction referencing an earlier event |
+| `events list [--limit N]` | List events for the current project (most recent first) |
+| `search <query> [--all-projects]` | Full-text search across events (FTS5) |
+| `pack <id> --mode compact\|full` | Render a resume pack for a task |
+| `rebuild-state` | Rebuild SQLite derived state from the JSONL log |
+| `stats` | Show classifier accuracy and event counts |
+| `export [--format md\|json] [--task <id>]` | Export tasks to stdout as Markdown or JSON |
+| `backfill [--dry-run] [--limit N]` | Import events from existing Claude Code session history |
+| `ui` / `tui` | Interactive terminal UI for browsing sessions |
+| `install-hooks [--scope user\|project]` | Install Claude Code auto-capture hooks |
+| `ingest-hook` | Hook entry point (called by Claude Code hooks) |
+
+### Export
+
+The `export` command writes task data to stdout so you can pipe it to a file or another tool:
+
+```bash
+# Export all tasks as Markdown
+task-journal export > report.md
 
-```markdown
-# Add OAuth login  [status: open]
+# Export a specific task as JSON
+task-journal export --format json --task tj-x9rz1f > task.json
 
-## Lifecycle
-- 2026-04-30T... opened
+# Export from a different project directory
+task-journal export --project /path/to/project
+```
 
-## Active decisions
-- Adopt PKCE flow
+## TUI
 
-## Rejected
-- Implicit grant: deprecated
+The interactive terminal UI (`task-journal ui` or `task-journal tui`) lets you browse Claude Code sessions and read conversation history for the current project. Navigate sessions with arrow keys and inspect individual chat messages.
 
-## Recent events (last 10)
-- 2026-04-30T... [rejection] Implicit grant: deprecated
-- 2026-04-30T... [decision] Adopt PKCE flow
-- 2026-04-30T... [hypothesis] PKCE vs implicit grant
-- 2026-04-30T... [open] Add OAuth login
+```bash
+task-journal ui
+task-journal ui --project /path/to/project
 ```
 
-## Claude Code integration (two paths)
+## MCP Integration
 
-### Path A — Plugin (recommended)
+Task Journal ships an MCP server (`task-journal-mcp`) that exposes five tools to Claude Code and other MCP-compatible agents:
 
-Adds slash-commands like `/task-journal:create` and `/task-journal:pack`, plus the MCP server, all in one install.
+| MCP Tool | Description |
+|----------|-------------|
+| `task_create` | Create a new task |
+| `event_add` | Append a reasoning event |
+| `task_pack` | Render a resume pack for context restoration |
+| `task_search` | Full-text search across events |
+| `task_close` | Close a task with a reason |
 
-From your shell:
+**Plugin install (recommended)** -- the plugin registers the MCP server automatically:
 
 ```bash
-claude plugin marketplace add https://github.com/Digital-Threads/Task-Journal
-claude plugin install task-journal@claude-memory
+claude plugin install github:Digital-Threads/Task-Journal
 ```
 
-(Or for a local checkout: `claude plugin marketplace add /path/to/Task-Journal`.)
-
-Restart Claude Code. Six slash-commands become available: `/task-journal:create`, `:event`, `:pack`, `:search`, `:close`, `:stats`.
-
-### Path B — Plain MCP (no plugin)
-
-If you don't want slash-commands or auto-capture hooks, just register the MCP server in `~/.claude/settings.json`:
+**Manual MCP registration** -- add to `~/.claude/settings.json`:
 
 ```json
 {
@@ -95,86 +123,85 @@ If you don't want slash-commands or auto-capture hooks, just register the MCP se
 }
 ```
 
-Five tools become available: `task_pack`, `task_search`, `task_create`, `event_add`, `task_close`.
+The MCP server includes built-in instructions that guide Claude Code through the recommended workflow: search for open tasks at session start, record findings/decisions/rejections during work, and close tasks when done.
+
+## Auto-Capture via Hooks
 
-## Auto-capture via Claude Code hooks
+Claude Code hooks can automatically classify chat chunks and record events without manual `event` commands:
 
 ```bash
-export ANTHROPIC_API_KEY=sk-ant-...
 task-journal install-hooks --scope user
 ```
 
-Hooks send chat chunks to Claude Haiku for classification:
-
-- Confidence ≥ 0.85 → confirmed event
-- Confidence < 0.85 → suggested event (rendered with `[?]` marker; you decide)
+The classifier (powered by `claude -p` with your Pro/Max subscription, or the Anthropic API with `--backend=api`) analyzes each chat turn and appends events to the active task:
 
-Hook commands are wrapped with `|| true` so a classifier failure (network down, rate limit, missing key) **never** breaks Claude Code.
+- Confidence >= 0.85 -- confirmed event (auto-recorded)
+- Confidence < 0.85 -- suggested event (marked with `[?]`)
 
-See [INSTALL.md](./INSTALL.md) for the full hook walkthrough.
+Hook commands are wrapped with `|| true` so classifier failures (network down, rate limit) never break Claude Code. Failed classifications are queued in `pending/` and retried on the next ingest.
 
-## CLI commands
+## Event Types
 
-| Command | Purpose |
-|---------|---------|
-| `task-journal create <title>` | Open a task |
-| `task-journal event <id> --type X --text Y` | Append a typed event |
-| `task-journal close <id> --reason "..."` | Close a task |
-| `task-journal event-correct --corrects <event_id> --task <id> --text "..."` | Correction event |
-| `task-journal pack <id> --mode compact\|full` | Render resume pack |
-| `task-journal search <query>` | FTS5 search in current project |
-| `task-journal search <query> --all-projects` | Search across all projects |
-| `task-journal events list` | List events for current project |
-| `task-journal rebuild-state` | Rebuild SQLite from JSONL |
-| `task-journal stats` | Classifier accuracy + counts |
-| `task-journal install-hooks [--scope user\|project]` | Install Claude Code hooks |
+| Type | Meaning |
+|------|---------|
+| `open` | Task created with a title and optional context |
+| `hypothesis` | Unverified theory ("I think X might cause Y") |
+| `finding` | Verified observation from reading code, logs, or docs |
+| `evidence` | Result of a test or experiment that proves something |
+| `decision` | Committed choice with rationale ("Use X because Y") |
+| `rejection` | Explicitly rejected approach with reason |
+| `constraint` | External limitation discovered (rate limits, API restrictions) |
+| `correction` | Corrects an earlier event (references `corrects` event ID) |
+| `reopen` | Reopens a previously closed task |
+| `supersede` | Replaces an earlier event (references `supersedes` event ID) |
+| `close` | Task completed with outcome summary |
+| `redirect` | Task redirected to a different task or approach |
 
 ## Architecture
 
-`task-journal` is a Rust workspace with three crates:
+Task Journal is a Rust workspace with three crates:
 
-- **`tj-core`** — event schema (JSONL, append-only), SQLite derived state, pack assembler, classifier client (Anthropic API)
-- **`tj-cli`** — `task-journal` binary
-- **`tj-mcp`** — `task-journal-mcp` binary (MCP server using `rmcp`)
+| Crate | Package | Description |
+|-------|---------|-------------|
+| `tj-core` | `task-journal-core` | Event schema, JSONL storage, SQLite derived state, pack assembler, classifier client |
+| `tj-cli` | `task-journal-cli` | `task-journal` CLI binary |
+| `tj-mcp` | `task-journal-mcp` | `task-journal-mcp` MCP server binary (uses `rmcp`) |
 
-**Source of truth = JSONL event log.** SQLite is rebuildable from it via `rebuild-state`. Pack output is Markdown wrapped in JSON metadata.
+**Source of truth = JSONL event log.** SQLite state is derived and fully rebuildable via `rebuild-state`. Pack output is Markdown wrapped in JSON metadata.
 
-Where data lives:
+### Data Location
 
 | OS | Path |
 |----|------|
-| Linux/WSL | `$XDG_DATA_HOME/task-journal` (default `~/.local/share/task-journal`) |
+| Linux / WSL | `$XDG_DATA_HOME/task-journal` (default `~/.local/share/task-journal`) |
 | macOS | `~/Library/Application Support/task-journal` |
 | Windows | `%LOCALAPPDATA%\task-journal` |
 
-Layout:
-
 ```
 task-journal/
-├── events/<project_hash>.jsonl    # source of truth (append-only)
-├── state/<project_hash>.sqlite    # derived state (rebuildable)
-├── metrics/<project_hash>.jsonl   # classifier telemetry
-└── pending/<id>.json              # failed classifications awaiting retry
+  events/<project_hash>.jsonl    # source of truth (append-only)
+  state/<project_hash>.sqlite    # derived state (rebuildable)
+  metrics/<project_hash>.jsonl   # classifier telemetry
+  pending/<id>.json              # failed classifications awaiting retry
 ```
 
-## Design docs
-
-- [`.docs/plans/2026-04-29-tz-task-journal-v2.md`](.docs/plans/2026-04-29-tz-task-journal-v2.md) — original spec
-- [`.docs/plans/2026-04-29-task-journal-v1-design.md`](.docs/plans/2026-04-29-task-journal-v1-design.md) — design doc (9 architectural decisions)
-- [`.docs/plans/2026-04-29-task-journal-v1-p1-skeleton.md`](.docs/plans/2026-04-29-task-journal-v1-p1-skeleton.md) — P1 plan
-- [`.docs/plans/2026-04-30-task-journal-v1-p2-task-pack-core.md`](.docs/plans/2026-04-30-task-journal-v1-p2-task-pack-core.md) — P2 plan
-- [`.docs/plans/2026-04-30-task-journal-v1-p3-hooks-classifier.md`](.docs/plans/2026-04-30-task-journal-v1-p3-hooks-classifier.md) — P3 plan
-- [`.docs/plans/2026-04-30-task-journal-v1-p4-polish-dogfood.md`](.docs/plans/2026-04-30-task-journal-v1-p4-polish-dogfood.md) — P4 plan
+Each project is identified by a hash of its canonical path, so multiple projects share the same data directory without collision.
 
 ## Development
 
 ```bash
-cargo test --workspace                 # all unit + integration tests
-.beads/hooks/p1-demo.sh                # P1 skeleton smoke
-.beads/hooks/p2-demo.sh                # P2 task_pack smoke
-.beads/hooks/p3-mock-demo.sh           # P3 hooks/classifier mock smoke
-.beads/hooks/p4-demo.sh                # P4 polish smoke
-.beads/hooks/p3-demo.sh                # Real Anthropic API (requires ANTHROPIC_API_KEY)
+cargo test --workspace
 ```
 
-License: MIT.
+Smoke test scripts are available in `.beads/hooks/`:
+
+```bash
+.beads/hooks/p1-demo.sh          # P1 skeleton smoke
+.beads/hooks/p2-demo.sh          # P2 task_pack smoke
+.beads/hooks/p3-mock-demo.sh     # P3 hooks/classifier mock smoke
+.beads/hooks/p4-demo.sh          # P4 polish smoke
+```
+
+## License
+
+MIT

README.md

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