@jamesaphoenix/tx-core 0.5.8 → 0.5.10

package/migrations/001_initial.sql

@@ -0,0 +1,57 @@
+-- Version: 001
+-- Migration: initial
+
+-- Core tasks table
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    status TEXT NOT NULL DEFAULT 'backlog'
+        CHECK (status IN (
+            'backlog', 'ready', 'planning', 'active',
+            'blocked', 'review', 'human_needs_to_review', 'done'
+        )),
+    parent_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    score INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    completed_at TEXT,
+    metadata TEXT DEFAULT '{}'
+);
+
+-- Dependency relationships
+CREATE TABLE IF NOT EXISTS task_dependencies (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    blocker_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    blocked_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    created_at TEXT NOT NULL,
+    UNIQUE(blocker_id, blocked_id),
+    CHECK (blocker_id != blocked_id)
+);
+
+-- Compaction history
+CREATE TABLE IF NOT EXISTS compaction_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    compacted_at TEXT NOT NULL,
+    task_count INTEGER NOT NULL,
+    summary TEXT NOT NULL,
+    task_ids TEXT NOT NULL,
+    learnings_exported_to TEXT
+);
+
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_score ON tasks(score DESC);
+CREATE INDEX IF NOT EXISTS idx_tasks_created ON tasks(created_at);
+CREATE INDEX IF NOT EXISTS idx_deps_blocker ON task_dependencies(blocker_id);
+CREATE INDEX IF NOT EXISTS idx_deps_blocked ON task_dependencies(blocked_id);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (1, datetime('now'));

package/migrations/002_learnings.sql

@@ -0,0 +1,64 @@
+-- Version: 002
+-- Migration: Learnings table with FTS5 for BM25 search
+
+-- Learnings table (append-only event log)
+CREATE TABLE IF NOT EXISTS learnings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    content TEXT NOT NULL,
+    source_type TEXT NOT NULL CHECK (source_type IN ('compaction', 'run', 'manual', 'claude_md')),
+    source_ref TEXT,
+    created_at TEXT NOT NULL,
+    keywords TEXT,
+    category TEXT,
+    usage_count INTEGER NOT NULL DEFAULT 0,
+    last_used_at TEXT,
+    outcome_score REAL,
+    embedding BLOB
+);
+
+-- FTS5 for BM25 keyword search
+CREATE VIRTUAL TABLE IF NOT EXISTS learnings_fts USING fts5(
+    content, keywords, category,
+    content='learnings', content_rowid='id',
+    tokenize='porter unicode61'
+);
+
+-- Triggers to sync FTS on insert
+CREATE TRIGGER IF NOT EXISTS learnings_ai AFTER INSERT ON learnings BEGIN
+    INSERT INTO learnings_fts(rowid, content, keywords, category)
+    VALUES (new.id, new.content, new.keywords, new.category);
+END;
+
+-- Triggers to sync FTS on delete
+CREATE TRIGGER IF NOT EXISTS learnings_ad AFTER DELETE ON learnings BEGIN
+    INSERT INTO learnings_fts(learnings_fts, rowid, content, keywords, category)
+    VALUES ('delete', old.id, old.content, old.keywords, old.category);
+END;
+
+-- Triggers to sync FTS on update
+CREATE TRIGGER IF NOT EXISTS learnings_au AFTER UPDATE ON learnings BEGIN
+    INSERT INTO learnings_fts(learnings_fts, rowid, content, keywords, category)
+    VALUES ('delete', old.id, old.content, old.keywords, old.category);
+    INSERT INTO learnings_fts(rowid, content, keywords, category)
+    VALUES (new.id, new.content, new.keywords, new.category);
+END;
+
+-- Config for retrieval weights
+CREATE TABLE IF NOT EXISTS learnings_config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+INSERT OR IGNORE INTO learnings_config (key, value) VALUES
+    ('bm25_weight', '0.4'),
+    ('vector_weight', '0.4'),
+    ('recency_weight', '0.2');
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_learnings_created ON learnings(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_learnings_source_type ON learnings(source_type);
+CREATE INDEX IF NOT EXISTS idx_learnings_usage ON learnings(usage_count DESC);
+CREATE INDEX IF NOT EXISTS idx_learnings_outcome ON learnings(outcome_score DESC);
+CREATE INDEX IF NOT EXISTS idx_learnings_category ON learnings(category);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (2, datetime('now'));

package/migrations/003_file_learnings.sql

@@ -0,0 +1,19 @@
+-- Version: 003
+-- Migration: File learnings table for path-based knowledge
+
+-- File learnings table (path-based knowledge storage)
+CREATE TABLE IF NOT EXISTS file_learnings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_pattern TEXT NOT NULL,
+    note TEXT NOT NULL,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    created_at TEXT NOT NULL
+);
+
+-- Index for file pattern lookups
+CREATE INDEX IF NOT EXISTS idx_file_learnings_pattern ON file_learnings(file_pattern);
+CREATE INDEX IF NOT EXISTS idx_file_learnings_created ON file_learnings(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_file_learnings_task ON file_learnings(task_id);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (3, datetime('now'));

package/migrations/004_attempts.sql

@@ -0,0 +1,18 @@
+-- Version: 004
+-- Migration: Attempts table for tracking task attempt outcomes
+
+-- Attempts table (track failed/succeeded approaches per task)
+CREATE TABLE IF NOT EXISTS attempts (
+    id INTEGER PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    approach TEXT NOT NULL,
+    outcome TEXT NOT NULL CHECK (outcome IN ('failed', 'succeeded')),
+    reason TEXT,
+    created_at TEXT NOT NULL
+);
+
+-- Index for task_id lookups
+CREATE INDEX IF NOT EXISTS idx_attempts_task_id ON attempts(task_id);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (4, datetime('now'));

package/migrations/005_runs.sql

@@ -0,0 +1,34 @@
+-- Version: 005
+-- Migration: Runs table for tracking Claude agent sessions
+
+-- Runs table (track each Claude agent session)
+CREATE TABLE IF NOT EXISTS runs (
+    id TEXT PRIMARY KEY,                -- run-<sha8>
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    agent TEXT NOT NULL,                -- tx-implementer, tx-decomposer, etc.
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    status TEXT NOT NULL DEFAULT 'running'
+        CHECK (status IN ('running', 'completed', 'failed', 'timeout', 'cancelled')),
+    exit_code INTEGER,
+    pid INTEGER,                        -- OS process ID
+    transcript_path TEXT,               -- Path to conversation .jsonl file
+    context_injected TEXT,              -- Path to context.md that was injected
+    summary TEXT,                       -- LLM-generated summary of what happened
+    error_message TEXT,                 -- If failed, why
+    metadata TEXT DEFAULT '{}'          -- JSON: git_sha, branch, iteration, etc.
+);
+
+-- Link learnings to runs (which run produced this learning?)
+-- Note: learnings table already exists, just adding the column
+ALTER TABLE learnings ADD COLUMN run_id TEXT REFERENCES runs(id) ON DELETE SET NULL;
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_runs_task ON runs(task_id);
+CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+CREATE INDEX IF NOT EXISTS idx_runs_started ON runs(started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_runs_agent ON runs(agent);
+CREATE INDEX IF NOT EXISTS idx_learnings_run ON learnings(run_id);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (5, datetime('now'));

package/migrations/006_events.sql

@@ -0,0 +1,33 @@
+-- Version: 006
+-- Migration: Events table for append-only activity tracking
+
+-- Events table (append-only log of all activity for replay/analysis)
+CREATE TABLE IF NOT EXISTS events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    event_type TEXT NOT NULL CHECK (event_type IN (
+        'run_started', 'run_completed', 'run_failed',
+        'task_created', 'task_updated', 'task_completed',
+        'tool_call', 'tool_result',
+        'user_message', 'assistant_message',
+        'error', 'learning_captured',
+        'commit', 'review'
+    )),
+    run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    agent TEXT,
+    tool_name TEXT,
+    content TEXT,
+    metadata TEXT DEFAULT '{}',
+    duration_ms INTEGER
+);
+
+-- Indexes for efficient querying
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+CREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id);
+CREATE INDEX IF NOT EXISTS idx_events_task ON events(task_id);
+CREATE INDEX IF NOT EXISTS idx_events_agent ON events(agent);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (6, datetime('now'));

package/migrations/007_sync_config.sql

@@ -0,0 +1,18 @@
+-- Version: 007
+-- Migration: Sync config table for JSONL sync daemon settings
+
+-- Sync config table (key-value store for sync settings)
+CREATE TABLE IF NOT EXISTS sync_config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+-- Default values
+INSERT OR IGNORE INTO sync_config (key, value, updated_at) VALUES
+    ('auto_sync', 'false', datetime('now')),
+    ('last_export', '', datetime('now')),
+    ('last_import', '', datetime('now'));
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (7, datetime('now'));

package/migrations/008_learning_anchors.sql

@@ -0,0 +1,28 @@
+-- Version: 008
+-- Migration: Learning anchors table for file-code associations
+
+-- Learning anchors table (file/code associations for learnings)
+CREATE TABLE IF NOT EXISTS learning_anchors (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    learning_id INTEGER NOT NULL REFERENCES learnings(id) ON DELETE CASCADE,
+    anchor_type TEXT NOT NULL CHECK (anchor_type IN ('glob', 'hash', 'symbol', 'line_range')),
+    anchor_value TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    symbol_fqname TEXT,
+    line_start INTEGER,
+    line_end INTEGER,
+    content_hash TEXT,
+    status TEXT NOT NULL DEFAULT 'valid' CHECK (status IN ('valid', 'invalid', 'drifted')),
+    verified_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Indexes for graph traversal and common queries
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_learning_id ON learning_anchors(learning_id);
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_file_path ON learning_anchors(file_path);
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_status ON learning_anchors(status);
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_anchor_type ON learning_anchors(anchor_type);
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_symbol ON learning_anchors(symbol_fqname) WHERE symbol_fqname IS NOT NULL;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (8, datetime('now'));

package/migrations/009_learning_edges.sql

@@ -0,0 +1,43 @@
+-- Version: 009
+-- Migration: Learning edges table for graph relationships
+
+-- Learning edges table (graph relationships between nodes)
+-- Supports edge types: ANCHORED_TO, DERIVED_FROM, IMPORTS, CO_CHANGES_WITH, SIMILAR_TO, LINKS_TO, USED_IN_RUN, INVALIDATED_BY
+-- Node types: learning, file, task, run
+CREATE TABLE IF NOT EXISTS learning_edges (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    edge_type TEXT NOT NULL CHECK (edge_type IN (
+        'ANCHORED_TO',
+        'DERIVED_FROM',
+        'IMPORTS',
+        'CO_CHANGES_WITH',
+        'SIMILAR_TO',
+        'LINKS_TO',
+        'USED_IN_RUN',
+        'INVALIDATED_BY'
+    )),
+    source_type TEXT NOT NULL CHECK (source_type IN ('learning', 'file', 'task', 'run')),
+    source_id TEXT NOT NULL,
+    target_type TEXT NOT NULL CHECK (target_type IN ('learning', 'file', 'task', 'run')),
+    target_id TEXT NOT NULL,
+    weight REAL NOT NULL DEFAULT 1.0 CHECK (weight >= 0.0 AND weight <= 1.0),
+    metadata TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    invalidated_at TEXT
+);
+
+-- Indexes for graph traversal
+-- Source-based lookups (outgoing edges)
+CREATE INDEX IF NOT EXISTS idx_learning_edges_source ON learning_edges(source_type, source_id);
+-- Target-based lookups (incoming edges)
+CREATE INDEX IF NOT EXISTS idx_learning_edges_target ON learning_edges(target_type, target_id);
+-- Edge type filtering
+CREATE INDEX IF NOT EXISTS idx_learning_edges_type ON learning_edges(edge_type);
+-- Active edges only (not invalidated) - partial index for efficient traversal
+CREATE INDEX IF NOT EXISTS idx_learning_edges_active ON learning_edges(source_type, source_id) WHERE invalidated_at IS NULL;
+-- Composite index for bidirectional traversal with edge type filtering
+CREATE INDEX IF NOT EXISTS idx_learning_edges_source_type ON learning_edges(source_type, source_id, edge_type) WHERE invalidated_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_learning_edges_target_type ON learning_edges(target_type, target_id, edge_type) WHERE invalidated_at IS NULL;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (9, datetime('now'));

package/migrations/010_learning_candidates.sql

@@ -0,0 +1,30 @@
+-- Version: 010
+-- Migration: Learning candidates table for telemetry extraction pipeline
+
+-- Learning candidates awaiting promotion to learnings table
+-- See PRD-015: JSONL Telemetry Daemon and Knowledge Promotion Pipeline
+CREATE TABLE IF NOT EXISTS learning_candidates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    content TEXT NOT NULL,
+    confidence TEXT NOT NULL CHECK (confidence IN ('high', 'medium', 'low')),
+    category TEXT,
+    source_file TEXT NOT NULL,
+    source_run_id TEXT,
+    source_task_id TEXT,
+    extracted_at TEXT NOT NULL DEFAULT (datetime('now')),
+    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'promoted', 'rejected', 'merged')),
+    reviewed_at TEXT,
+    reviewed_by TEXT,  -- 'auto' or user identifier
+    promoted_learning_id INTEGER,
+    rejection_reason TEXT,
+    FOREIGN KEY (promoted_learning_id) REFERENCES learnings(id) ON DELETE SET NULL
+);
+
+-- Indexes for efficient queries
+CREATE INDEX IF NOT EXISTS idx_learning_candidates_status ON learning_candidates(status);
+CREATE INDEX IF NOT EXISTS idx_learning_candidates_confidence ON learning_candidates(confidence);
+CREATE INDEX IF NOT EXISTS idx_learning_candidates_source ON learning_candidates(source_file);
+CREATE INDEX IF NOT EXISTS idx_learning_candidates_extracted ON learning_candidates(extracted_at);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (10, datetime('now'));

package/migrations/011_processed_hashes.sql

@@ -0,0 +1,35 @@
+-- Version: 011
+-- Migration: Processed hashes table for JSONL line deduplication
+
+-- Track processed JSONL line hashes for deduplication
+-- Each unique line (by content hash) is recorded once to avoid re-processing
+CREATE TABLE IF NOT EXISTS processed_hashes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    content_hash TEXT NOT NULL UNIQUE,      -- SHA256 of the JSONL line content
+    source_file TEXT NOT NULL,              -- First file where this line was seen
+    source_line INTEGER NOT NULL,           -- Line number in source file (1-indexed)
+    processed_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Index for fast hash lookups (most common operation)
+CREATE INDEX IF NOT EXISTS idx_processed_hashes_hash ON processed_hashes(content_hash);
+-- Index for querying by source file
+CREATE INDEX IF NOT EXISTS idx_processed_hashes_file ON processed_hashes(source_file);
+
+-- Track file processing progress for incremental processing
+-- Allows resuming from last position when a file changes
+CREATE TABLE IF NOT EXISTS file_progress (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_path TEXT NOT NULL UNIQUE,         -- Absolute path to the JSONL file
+    last_line_processed INTEGER DEFAULT 0,  -- Last line number processed (1-indexed)
+    last_byte_offset INTEGER DEFAULT 0,     -- Byte offset for streaming resume
+    file_size INTEGER,                      -- Size at last processing time
+    file_checksum TEXT,                     -- SHA256 of file content at last processing
+    last_processed_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Index for file path lookups
+CREATE INDEX IF NOT EXISTS idx_file_progress_path ON file_progress(file_path);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (11, datetime('now'));

package/migrations/012_invalidation.sql

@@ -0,0 +1,32 @@
+-- Version: 012
+-- Migration: Invalidation tracking and pinned anchors for PRD-017
+
+-- Add pinned column to learning_anchors
+ALTER TABLE learning_anchors ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0;
+
+-- Invalidation audit log
+CREATE TABLE IF NOT EXISTS invalidation_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    anchor_id INTEGER NOT NULL,
+    old_status TEXT NOT NULL,
+    new_status TEXT NOT NULL,
+    reason TEXT NOT NULL,
+    detected_by TEXT NOT NULL CHECK (detected_by IN ('periodic', 'lazy', 'manual', 'agent', 'git_hook')),
+    old_content_hash TEXT,
+    new_content_hash TEXT,
+    similarity_score REAL,
+    invalidated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    FOREIGN KEY (anchor_id) REFERENCES learning_anchors(id) ON DELETE CASCADE
+);
+
+-- Indexes for invalidation_log
+CREATE INDEX IF NOT EXISTS idx_invalidation_anchor ON invalidation_log(anchor_id);
+CREATE INDEX IF NOT EXISTS idx_invalidation_time ON invalidation_log(invalidated_at);
+CREATE INDEX IF NOT EXISTS idx_invalidation_status ON invalidation_log(new_status);
+CREATE INDEX IF NOT EXISTS idx_invalidation_detected_by ON invalidation_log(detected_by);
+
+-- Index for pinned anchors
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_pinned ON learning_anchors(pinned) WHERE pinned = 1;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (12, datetime('now'));

package/migrations/013_content_preview.sql

@@ -0,0 +1,13 @@
+-- Version: 013
+-- Migration: Add content_preview for self-healing comparison (PRD-017)
+
+-- Add content_preview column to store original content snippet for Jaccard similarity
+-- Used by self-healing to compare old vs new content when anchors drift
+ALTER TABLE learning_anchors ADD COLUMN content_preview TEXT;
+
+-- Index for faster lookups when content_preview is present
+CREATE INDEX IF NOT EXISTS idx_learning_anchors_has_preview
+    ON learning_anchors(content_hash) WHERE content_preview IS NOT NULL;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (13, datetime('now'));

package/migrations/014_daemon_tracked_projects.sql

@@ -0,0 +1,20 @@
+-- Version: 014
+-- Migration: Daemon tracked projects for opt-in project monitoring (PRD-015)
+
+-- Tracked projects for the daemon to watch for JSONL transcript processing
+-- Users explicitly opt-in projects via `tx daemon track <path>`
+CREATE TABLE IF NOT EXISTS daemon_tracked_projects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_path TEXT NOT NULL UNIQUE,
+    project_id TEXT,
+    source_type TEXT DEFAULT 'claude' CHECK (source_type IN ('claude', 'cursor', 'windsurf', 'other')),
+    added_at TEXT NOT NULL DEFAULT (datetime('now')),
+    enabled INTEGER NOT NULL DEFAULT 1 CHECK (enabled IN (0, 1))
+);
+
+-- Index for efficient enabled project queries
+CREATE INDEX IF NOT EXISTS idx_daemon_tracked_projects_enabled
+    ON daemon_tracked_projects(enabled) WHERE enabled = 1;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (14, datetime('now'));

package/migrations/015_worker_orchestration.sql

@@ -0,0 +1,64 @@
+-- Version: 015
+-- Migration: Worker orchestration system (PRD-018)
+-- Implements k8s-style worker orchestration with heartbeats, leases, and reconciliation
+
+-- Workers table: registered worker processes
+CREATE TABLE IF NOT EXISTS workers (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    hostname TEXT NOT NULL,
+    pid INTEGER NOT NULL,
+    status TEXT NOT NULL DEFAULT 'starting'
+        CHECK (status IN ('starting', 'idle', 'busy', 'stopping', 'dead')),
+    registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_heartbeat_at TEXT NOT NULL DEFAULT (datetime('now')),
+    current_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    capabilities TEXT NOT NULL DEFAULT '[]',
+    metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+-- Task claims table: lease-based task ownership
+CREATE TABLE IF NOT EXISTS task_claims (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    worker_id TEXT NOT NULL REFERENCES workers(id) ON DELETE CASCADE,
+    claimed_at TEXT NOT NULL DEFAULT (datetime('now')),
+    lease_expires_at TEXT NOT NULL,
+    renewed_count INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'active'
+        CHECK (status IN ('active', 'released', 'expired', 'completed'))
+);
+
+-- Orchestrator state table: singleton state for the orchestrator
+-- Uses CHECK constraint to enforce singleton (only id=1 allowed)
+CREATE TABLE IF NOT EXISTS orchestrator_state (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    status TEXT NOT NULL DEFAULT 'stopped'
+        CHECK (status IN ('stopped', 'starting', 'running', 'stopping')),
+    pid INTEGER,
+    started_at TEXT,
+    last_reconcile_at TEXT,
+    worker_pool_size INTEGER NOT NULL DEFAULT 1,
+    reconcile_interval_seconds INTEGER NOT NULL DEFAULT 60,
+    heartbeat_interval_seconds INTEGER NOT NULL DEFAULT 30,
+    lease_duration_minutes INTEGER NOT NULL DEFAULT 30,
+    metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+-- Indexes for workers
+CREATE INDEX IF NOT EXISTS idx_workers_status ON workers(status);
+CREATE INDEX IF NOT EXISTS idx_workers_last_heartbeat ON workers(last_heartbeat_at);
+CREATE INDEX IF NOT EXISTS idx_workers_current_task ON workers(current_task_id) WHERE current_task_id IS NOT NULL;
+
+-- Indexes for task_claims
+CREATE INDEX IF NOT EXISTS idx_claims_task_id ON task_claims(task_id);
+CREATE INDEX IF NOT EXISTS idx_claims_worker_id ON task_claims(worker_id);
+CREATE INDEX IF NOT EXISTS idx_claims_status ON task_claims(status);
+CREATE INDEX IF NOT EXISTS idx_claims_expires ON task_claims(lease_expires_at) WHERE status = 'active';
+CREATE INDEX IF NOT EXISTS idx_claims_active_task ON task_claims(task_id, status) WHERE status = 'active';
+
+-- Insert initial orchestrator state (singleton row)
+INSERT OR IGNORE INTO orchestrator_state (id, status) VALUES (1, 'stopped');
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (15, datetime('now'));

package/migrations/016_tracing_io_paths.sql

@@ -0,0 +1,13 @@
+-- Version: 016
+-- Migration: Add stderr_path and stdout_path to runs table for PRD-019 execution tracing
+
+-- Add stderr capture path (optional, orchestrator decides whether to capture)
+ALTER TABLE runs ADD COLUMN stderr_path TEXT;
+
+-- Add stdout capture path (optional, orchestrator decides whether to capture)
+ALTER TABLE runs ADD COLUMN stdout_path TEXT;
+
+-- Note: transcript_path already exists from migration 005
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (16, datetime('now'));

package/migrations/017_span_metric_events.sql

@@ -0,0 +1,47 @@
+-- Version: 017
+-- Migration: Add 'span' and 'metric' event types for PRD-019 execution tracing
+
+-- SQLite doesn't support ALTER CHECK, so we need to recreate the table
+-- with the updated constraint that includes 'span' and 'metric' event types
+
+-- Step 1: Create new events table with updated CHECK constraint
+CREATE TABLE events_new (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    event_type TEXT NOT NULL CHECK (event_type IN (
+        'run_started', 'run_completed', 'run_failed',
+        'task_created', 'task_updated', 'task_completed',
+        'tool_call', 'tool_result',
+        'user_message', 'assistant_message',
+        'error', 'learning_captured',
+        'commit', 'review',
+        'span', 'metric'
+    )),
+    run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    agent TEXT,
+    tool_name TEXT,
+    content TEXT,
+    metadata TEXT DEFAULT '{}',
+    duration_ms INTEGER
+);
+
+-- Step 2: Copy existing data
+INSERT INTO events_new (id, timestamp, event_type, run_id, task_id, agent, tool_name, content, metadata, duration_ms)
+SELECT id, timestamp, event_type, run_id, task_id, agent, tool_name, content, metadata, duration_ms FROM events;
+
+-- Step 3: Drop old table
+DROP TABLE events;
+
+-- Step 4: Rename new table
+ALTER TABLE events_new RENAME TO events;
+
+-- Step 5: Recreate indexes (dropped with old table)
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+CREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id);
+CREATE INDEX IF NOT EXISTS idx_events_task ON events(task_id);
+CREATE INDEX IF NOT EXISTS idx_events_agent ON events(agent);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (17, datetime('now'));

package/migrations/018_compaction_learnings.sql

@@ -0,0 +1,15 @@
+-- Version: 018
+-- Migration: Add learnings column to compaction_log for data loss prevention
+--
+-- Fixes CRITICAL bug: learnings were only exported to file, not stored in DB.
+-- If file export failed (disk full, permissions, etc.), learnings were lost
+-- forever because the original tasks were already deleted.
+--
+-- Now learnings are stored in the database as the primary source of truth,
+-- ensuring they're never lost even if file export fails.
+
+-- Add learnings column to store actual learning content
+ALTER TABLE compaction_log ADD COLUMN learnings TEXT;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (18, datetime('now'));

package/migrations/019_tasks_updated_at_index.sql

@@ -0,0 +1,11 @@
+-- Version: 019
+-- Migration: Add index on tasks.updated_at for sync dirty detection
+--
+-- The sync status dirty check scans all tasks to find any updated after
+-- the last export. Without an index on updated_at, this is O(n).
+-- With the index, a SQL query can find changed tasks in O(log n).
+
+CREATE INDEX IF NOT EXISTS idx_tasks_updated ON tasks(updated_at DESC);
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (19, datetime('now'));

package/migrations/020_task_id_check.sql

@@ -0,0 +1,32 @@
+-- Version: 020
+-- Migration: Add database-level task ID format validation
+--
+-- Problem: tasks.id has no format constraint. ID validation (tx-[a-z0-9]{6,})
+-- only exists in the app layer. JSONL import and direct SQL can insert malformed IDs.
+--
+-- Approach: Use BEFORE INSERT/UPDATE triggers instead of CHECK constraint because
+-- SQLite does not support ALTER TABLE ADD CONSTRAINT, and recreating the tasks table
+-- would cascade-delete all data in referencing tables (task_dependencies, attempts,
+-- runs, events, task_claims, workers, file_learnings) when foreign_keys is ON.
+-- Triggers provide identical database-level enforcement without table recreation.
+
+-- Validate task ID format on INSERT
+CREATE TRIGGER IF NOT EXISTS validate_task_id_insert
+BEFORE INSERT ON tasks
+FOR EACH ROW
+WHEN NEW.id NOT GLOB 'tx-[a-z0-9][a-z0-9][a-z0-9][a-z0-9][a-z0-9][a-z0-9]*'
+BEGIN
+  SELECT RAISE(ABORT, 'Task ID must match format: tx-[a-z0-9]{6,}');
+END;
+
+-- Validate task ID format on UPDATE (prevents changing id to malformed value)
+CREATE TRIGGER IF NOT EXISTS validate_task_id_update
+BEFORE UPDATE OF id ON tasks
+FOR EACH ROW
+WHEN NEW.id NOT GLOB 'tx-[a-z0-9][a-z0-9][a-z0-9][a-z0-9][a-z0-9][a-z0-9]*'
+BEGIN
+  SELECT RAISE(ABORT, 'Task ID must match format: tx-[a-z0-9]{6,}');
+END;
+
+-- Record this migration
+INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (20, datetime('now'));