@clauderecallhq/cli 0.12.5 → 0.61.3

package/dist/db/schema.js

@@ -1,496 +0,0 @@
-/**
- * Every write feature in Recall is backed by SQLite (with a history column
- * wherever a row can change) AND a plain-text mirror on disk so users can
- * grep, edit, or restore their data without opening the database.
- *
- * The plain-text mirrors and companion preference files live under
- * `$RECALL_HOME` (default `~/.recall/`):
- *
- *   aliases.json           — session alias current state + previous_aliases[] history
- *   tags.json              — current tag state + append-only event log
- *   notes/<session-id>.md  — one markdown file per session note (history inside SQLite)
- *   collections.json       — collection tree snapshot + full collection_events log
- *   config.json            — auto-tag config (may contain an Anthropic API key; 0600)
- *   onboarding.json        — v0.14a first-run tour state (no secrets, default perms).
- *                            Shape:
- *                              {
- *                                "version": 1,
- *                                "completed": boolean,
- *                                "skipped":   boolean,
- *                                "finishedAt": ISO-8601 | null,
- *                                "completedSteps": string[]
- *                              }
- *                            Parsed/validated in src/daemon/onboarding-state.ts.
- *   daemon.pid / daemon.port / daemon.log — lifecycle metadata.
- *
- * Schema invariants (enforced here):
- *   1. `IF NOT EXISTS` on every DDL — migrations stay backwards compatible.
- *   2. Session UUIDs are immutable primary keys; aliases/notes/tags layer on top.
- *   3. History columns (`previous_*`) are append-only JSON arrays — never pruned.
- *   4. Source JSONLs at `~/.claude/projects/` are read-only to Recall.
- */
-export const SCHEMA_SQL = `
-PRAGMA journal_mode = WAL;
-PRAGMA synchronous = NORMAL;
-PRAGMA foreign_keys = ON;
-
-CREATE TABLE IF NOT EXISTS projects (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  encoded_path TEXT UNIQUE NOT NULL,
-  decoded_path TEXT NOT NULL,
-  name TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS sessions (
-  id TEXT PRIMARY KEY,
-  project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  file_path TEXT NOT NULL,
-  file_mtime REAL NOT NULL,
-  started_at TEXT,
-  ended_at TEXT,
-  message_count INTEGER NOT NULL DEFAULT 0,
-  user_message_count INTEGER NOT NULL DEFAULT 0,
-  assistant_message_count INTEGER NOT NULL DEFAULT 0,
-  first_user_message TEXT,
-  cwd TEXT,
-  git_branch TEXT,
-  version TEXT,
-  indexed_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
-CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at DESC);
-
-CREATE TABLE IF NOT EXISTS messages (
-  rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-  uuid TEXT UNIQUE NOT NULL,
-  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  parent_uuid TEXT,
-  type TEXT NOT NULL,
-  role TEXT,
-  timestamp TEXT,
-  is_sidechain INTEGER NOT NULL DEFAULT 0,
-  content_text TEXT,
-  tool_names TEXT,
-  raw_json TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, timestamp);
-
-CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
-  content_text,
-  tool_names,
-  content='messages',
-  content_rowid='rowid',
-  tokenize = 'porter unicode61'
-);
-
-CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
-  INSERT INTO messages_fts(rowid, content_text, tool_names)
-  VALUES (new.rowid, new.content_text, new.tool_names);
-END;
-
-CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
-  INSERT INTO messages_fts(messages_fts, rowid, content_text, tool_names)
-  VALUES ('delete', old.rowid, old.content_text, old.tool_names);
-END;
-
-CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN
-  INSERT INTO messages_fts(messages_fts, rowid, content_text, tool_names)
-  VALUES ('delete', old.rowid, old.content_text, old.tool_names);
-  INSERT INTO messages_fts(rowid, content_text, tool_names)
-  VALUES (new.rowid, new.content_text, new.tool_names);
-END;
-
--- v0.4.1 — session aliases. The UUID stays the primary key forever; aliases
--- are a display layer on top. Every edit archives the prior value into
--- previous_aliases (JSON array) — we never destroy history.
-CREATE TABLE IF NOT EXISTS session_aliases (
-  session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
-  alias TEXT NOT NULL,
-  updated_at TEXT NOT NULL,
-  previous_aliases TEXT NOT NULL DEFAULT '[]'
-);
-
--- v0.4.2 — per-session markdown notes.
--- Every save archives the prior content into previous_versions and also mirrors
--- the full note out to ~/.recall/notes/<session_id>.md on disk. Nothing is ever
--- destroyed: an empty string means "cleared" with full history preserved.
-CREATE TABLE IF NOT EXISTS session_notes (
-  session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
-  content TEXT NOT NULL DEFAULT '',
-  updated_at TEXT NOT NULL,
-  previous_versions TEXT NOT NULL DEFAULT '[]'
-);
-
--- v0.4.3 — session tags. Many-to-many. Never destructively delete:
--- tag_events is an append-only log of every add and remove across all time,
--- so the full history of what was tagged when and why is always recoverable.
-CREATE TABLE IF NOT EXISTS session_tags (
-  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  tag TEXT NOT NULL,
-  created_at TEXT NOT NULL,
-  PRIMARY KEY (session_id, tag)
-);
-CREATE INDEX IF NOT EXISTS idx_session_tags_tag ON session_tags(tag);
-
-CREATE TABLE IF NOT EXISTS tag_events (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  session_id TEXT NOT NULL,
-  tag TEXT NOT NULL,
-  action TEXT NOT NULL,  -- 'add' | 'remove'
-  at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_tag_events_session ON tag_events(session_id, at DESC);
-CREATE INDEX IF NOT EXISTS idx_tag_events_tag ON tag_events(tag, at DESC);
-
--- v0.4.5 — opt-in clipboard archive. This is the ONE table where a user can
--- truly purge a row on demand (not soft-delete), because it may contain
--- accidentally-archived secrets. This carve-out is documented as a deliberate
--- exception to the "never delete" rule specifically for this data class.
-CREATE TABLE IF NOT EXISTS paste_archives (
-  id TEXT PRIMARY KEY,
-  created_at TEXT NOT NULL,
-  content TEXT NOT NULL,
-  size_bytes INTEGER NOT NULL,
-  source TEXT NOT NULL DEFAULT 'cli',  -- 'cli' | 'cli-piped' | 'ui' | …
-  label TEXT  -- optional user-supplied short description
-);
-CREATE INDEX IF NOT EXISTS idx_paste_archives_created ON paste_archives(created_at DESC);
-
--- v0.8 — collections. User-curated hand-picked groupings of sessions that
--- cut across the coarse-grained cwd-based "projects". A collection can nest
--- as a tree (parent_id → null means root). Soft-deletion only: archived_at
--- hides rows from default views, the row itself stays forever.
---
--- Durability: SQLite (this table + collection_events append-only log) plus a
--- plain-text mirror at ~/.recall/collections.json rewritten on every mutation.
-CREATE TABLE IF NOT EXISTS collections (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL,
-  description TEXT,
-  icon TEXT,
-  color TEXT,
-  parent_id TEXT REFERENCES collections(id) ON DELETE SET NULL,
-  sort_key TEXT NOT NULL DEFAULT '',
-  created_at TEXT NOT NULL,
-  updated_at TEXT NOT NULL,
-  archived_at TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_collections_parent ON collections(parent_id);
-CREATE INDEX IF NOT EXISTS idx_collections_archived ON collections(archived_at);
-
-CREATE TABLE IF NOT EXISTS collection_sessions (
-  collection_id TEXT NOT NULL REFERENCES collections(id) ON DELETE CASCADE,
-  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  added_at TEXT NOT NULL,
-  note TEXT,
-  PRIMARY KEY (collection_id, session_id)
-);
-CREATE INDEX IF NOT EXISTS idx_collection_sessions_session ON collection_sessions(session_id);
-
-CREATE TABLE IF NOT EXISTS collection_events (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  collection_id TEXT NOT NULL,
-  session_id TEXT,
-  action TEXT NOT NULL,  -- 'create' | 'rename' | 'describe' | 'recolor' | 'add' | 'remove' | 'archive' | 'restore' | 'move' | 'reorder'
-  payload TEXT,          -- JSON context (old_name, new_parent, etc.)
-  at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_collection_events_at ON collection_events(at DESC);
-CREATE INDEX IF NOT EXISTS idx_collection_events_collection ON collection_events(collection_id, at DESC);
-
--- v0.11 — semantic search (Tier 0: shells out to the user's local claude CLI to
--- summarize each session into 3-sentence prose + a keyword set). Both columns
--- are TEXT and feed sessions_fts so a conceptual query can hit this index in
--- addition to the per-message FTS5 index. Pipeline is OFF by default; users opt
--- in via "recall semantic on". Plain-text mirror at ~/.recall/semantic/<id>.json.
-CREATE TABLE IF NOT EXISTS session_semantic (
-  session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
-  summary TEXT NOT NULL DEFAULT '',
-  keywords TEXT NOT NULL DEFAULT '',  -- comma-separated
-  model TEXT,
-  source_message_count INTEGER NOT NULL DEFAULT 0,
-  generated_at TEXT NOT NULL
-);
-
-CREATE VIRTUAL TABLE IF NOT EXISTS sessions_fts USING fts5(
-  summary,
-  keywords,
-  content='session_semantic',
-  content_rowid='rowid',
-  tokenize = 'porter unicode61'
-);
-
-CREATE TRIGGER IF NOT EXISTS session_semantic_ai AFTER INSERT ON session_semantic BEGIN
-  INSERT INTO sessions_fts(rowid, summary, keywords)
-  VALUES (new.rowid, new.summary, new.keywords);
-END;
-
-CREATE TRIGGER IF NOT EXISTS session_semantic_ad AFTER DELETE ON session_semantic BEGIN
-  INSERT INTO sessions_fts(sessions_fts, rowid, summary, keywords)
-  VALUES ('delete', old.rowid, old.summary, old.keywords);
-END;
-
-CREATE TRIGGER IF NOT EXISTS session_semantic_au AFTER UPDATE ON session_semantic BEGIN
-  INSERT INTO sessions_fts(sessions_fts, rowid, summary, keywords)
-  VALUES ('delete', old.rowid, old.summary, old.keywords);
-  INSERT INTO sessions_fts(rowid, summary, keywords)
-  VALUES (new.rowid, new.summary, new.keywords);
-END;
-
--- v0.7 — vector search tier (Pro-only). Chunks are per-conversational-turn
--- segments of messages, embedded via local bge-base-en-v1.5 (768d). The vector
--- data is a derived cache; if lost, it is recomputable from messages.
--- Tables stay empty on Free tier (no model downloaded, no worker started).
-
-CREATE VIRTUAL TABLE IF NOT EXISTS vec_chunks USING vec0(
-  embedding float[768] distance_metric=cosine
-);
-
-CREATE TABLE IF NOT EXISTS chunk_meta (
-  rowid INTEGER PRIMARY KEY,
-  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  message_uuids TEXT NOT NULL DEFAULT '[]',
-  text TEXT NOT NULL DEFAULT '',
-  embedding_model_id TEXT NOT NULL DEFAULT 'bge-base-en-v1.5',
-  embedding_dim INTEGER NOT NULL DEFAULT 768,
-  stale INTEGER NOT NULL DEFAULT 0,
-  generated_at TEXT NOT NULL DEFAULT ''
-);
-CREATE INDEX IF NOT EXISTS idx_chunk_meta_session ON chunk_meta(session_id);
-CREATE INDEX IF NOT EXISTS idx_chunk_meta_stale ON chunk_meta(stale) WHERE stale = 1;
-
-CREATE TABLE IF NOT EXISTS chunk_queue (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  session_id TEXT NOT NULL,
-  message_uuid TEXT,
-  action TEXT NOT NULL CHECK (action IN ('embed', 'reembed', 'delete')),
-  enqueued_at TEXT NOT NULL DEFAULT (datetime('now'))
-);
-CREATE INDEX IF NOT EXISTS idx_chunk_queue_session ON chunk_queue(session_id);
-
-CREATE TRIGGER IF NOT EXISTS messages_vec_ai AFTER INSERT ON messages
-WHEN new.is_sidechain = 0 AND new.content_text IS NOT NULL
-BEGIN
-  INSERT INTO chunk_queue(session_id, message_uuid, action, enqueued_at)
-  VALUES (new.session_id, new.uuid, 'embed', datetime('now'));
-END;
-
-CREATE TRIGGER IF NOT EXISTS messages_vec_ad AFTER DELETE ON messages BEGIN
-  INSERT INTO chunk_queue(session_id, message_uuid, action, enqueued_at)
-  VALUES (old.session_id, old.uuid, 'delete', datetime('now'));
-END;
-
-CREATE TRIGGER IF NOT EXISTS messages_vec_au AFTER UPDATE OF content_text ON messages
-WHEN new.is_sidechain = 0
-BEGIN
-  INSERT INTO chunk_queue(session_id, message_uuid, action, enqueued_at)
-  VALUES (new.session_id, new.uuid, 'reembed', datetime('now'));
-END;
-
--- v0.10a — cost / token analytics. Claude Code already writes per-assistant-
--- message usage + model into the source JSONLs; we persist the raw counts
--- here and derive dollar amounts at render time (pricing changes; token
--- counts don't). message_usage is 1:1 with messages (keyed by message_uuid)
--- so a reindex rebuilds it cleanly; rollup columns on sessions are a
--- cache for fast list rendering.
-CREATE TABLE IF NOT EXISTS message_usage (
-  message_uuid TEXT PRIMARY KEY REFERENCES messages(uuid) ON DELETE CASCADE,
-  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  model TEXT,
-  input_tokens INTEGER NOT NULL DEFAULT 0,
-  output_tokens INTEGER NOT NULL DEFAULT 0,
-  cache_create_tokens INTEGER NOT NULL DEFAULT 0,
-  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
-  timestamp TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_message_usage_session ON message_usage(session_id);
-CREATE INDEX IF NOT EXISTS idx_message_usage_model ON message_usage(model);
-
--- v0.10b — git correlation. For any session whose cwd is a git worktree we
--- run a read-only \`git log\` scoped to that cwd for the [started_at, ended_at]
--- window and record every resulting commit. Composite PK (session_id,
--- commit_sha) lets a single commit belong to multiple sessions (rare, but
--- happens when a long session ends right as another starts). The reverse
--- index on commit_sha powers \`recall blame <sha>\`.
---
--- correlated_at lets the correlator skip sessions it has already processed
--- recently; cwd_snapshot captures the directory we ran git in so stale rows
--- can be identified if the user later points the session elsewhere.
-CREATE TABLE IF NOT EXISTS session_commits (
-  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-  commit_sha TEXT NOT NULL,
-  committed_at TEXT,
-  subject TEXT,
-  cwd_snapshot TEXT,
-  correlated_at TEXT NOT NULL,
-  PRIMARY KEY (session_id, commit_sha)
-);
-CREATE INDEX IF NOT EXISTS idx_session_commits_sha ON session_commits(commit_sha);
-CREATE INDEX IF NOT EXISTS idx_session_commits_session ON session_commits(session_id);
--- v0.13 — MCP write audit log. Every write tool invocation appends one row,
--- regardless of outcome (ok / error / rate_limited). Tags and collections
--- already have their own append-only event tables (tag_events,
--- collection_events) — this table covers note/alias writes and provides a
--- single chronological feed across all MCP write activity for review.
-CREATE TABLE IF NOT EXISTS mcp_audit_events (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  tool TEXT NOT NULL,
-  args_json TEXT NOT NULL,
-  result TEXT NOT NULL,        -- 'ok' | 'error' | 'rate_limited'
-  error_message TEXT,
-  caller TEXT,
-  at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_mcp_audit_events_at ON mcp_audit_events(at DESC);
-CREATE INDEX IF NOT EXISTS idx_mcp_audit_events_tool ON mcp_audit_events(tool, at DESC);
-
--- v0.15 T6 — auto-collections. Rules match sessions by cwd prefix, project
--- id, tag, plan-file reference, or git branch prefix, and insert auto
--- memberships into collection_sessions (tagged with source='auto' + the
--- originating rule_id). Manual memberships (source='manual') are never
--- touched by the rule engine — so a user's hand-curated pick always wins.
---
--- Suggestions are the discovery half: the daemon periodically surveys the
--- corpus, detects clusters that *would* make good auto-collections, and
--- stashes them here for the user to accept or dismiss. UNIQUE(type,pattern)
--- means the same cluster won't be re-suggested every scan.
---
--- Durability mirror: ~/.recall/auto-rules/{rules.json,suggestions.json}
--- rewritten on every mutation. Deleting a rule removes ONLY its auto
--- memberships (matched via rule_id); the target collection stays so the
--- user can keep whatever they manually added into it.
-CREATE TABLE IF NOT EXISTS auto_collection_rules (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL,
-  type TEXT NOT NULL CHECK (type IN ('cwd-prefix','project-id','tag','plan-file','git-branch-prefix')),
-  pattern TEXT NOT NULL,
-  collection_id TEXT NOT NULL REFERENCES collections(id) ON DELETE CASCADE,
-  priority INTEGER NOT NULL DEFAULT 100,
-  enabled INTEGER NOT NULL DEFAULT 1,
-  created_at TEXT NOT NULL,
-  created_by TEXT NOT NULL DEFAULT 'user'  -- 'user' | 'suggestion-accepted' | 'seed'
-);
-CREATE INDEX IF NOT EXISTS idx_auto_rules_type_enabled ON auto_collection_rules(type, enabled);
-CREATE INDEX IF NOT EXISTS idx_auto_rules_collection ON auto_collection_rules(collection_id);
-
-CREATE TABLE IF NOT EXISTS auto_collection_suggestions (
-  id TEXT PRIMARY KEY,
-  type TEXT NOT NULL,
-  pattern TEXT NOT NULL,
-  suggested_name TEXT NOT NULL,
-  suggested_parent_collection_id TEXT,
-  session_count INTEGER NOT NULL,
-  detected_at TEXT NOT NULL,
-  dismissed INTEGER NOT NULL DEFAULT 0,
-  UNIQUE(type, pattern)
-);
-CREATE INDEX IF NOT EXISTS idx_auto_suggestions_detected ON auto_collection_suggestions(detected_at DESC);
-
--- v0.15 Threads. The headline intent-grouping primitive: a DAG of sessions
--- connected by shared purpose (one or more origin sessions plus their
--- children). Additive to Projects and Collections; neither is refactored.
--- thread_edges is many-to-many so a session can belong to multiple threads
--- (planning session that seeds two features). parent_session_id is
--- nullable; when null, the row is an origin. confidence = 1.0 for manual
--- edges; < 1.0 for auto-detected edges (v0.15b). source tracks provenance
--- for the audit/undo paths.
-CREATE TABLE IF NOT EXISTS threads (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL,
-  summary TEXT,
-  created_at TEXT NOT NULL,
-  closed_at TEXT,
-  archived INTEGER NOT NULL DEFAULT 0
-);
-
-CREATE TABLE IF NOT EXISTS thread_edges (
-  thread_id TEXT NOT NULL,
-  session_id TEXT NOT NULL,
-  parent_session_id TEXT,
-  role TEXT NOT NULL CHECK(role IN ('origin','child')),
-  confidence REAL NOT NULL DEFAULT 1.0 CHECK(confidence >= 0 AND confidence <= 1),
-  source TEXT NOT NULL DEFAULT 'manual',
-  added_at TEXT NOT NULL,
-  PRIMARY KEY (thread_id, session_id),
-  FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_thread_edges_session ON thread_edges(session_id);
-CREATE INDEX IF NOT EXISTS idx_thread_edges_parent ON thread_edges(parent_session_id);
-CREATE INDEX IF NOT EXISTS idx_thread_edges_thread_role ON thread_edges(thread_id, role);
-`;
-export function runMigrations(db) {
-    const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
-    const have = new Set(cols.map((c) => c.name));
-    const adds = [
-        // v0.10a — per-session token rollups + dominant model. Nullable; filled
-        // on index/reindex and by the lazy backfill pass. Dollar amounts are
-        // NEVER persisted — prices change; raw token counts don't.
-        ['total_input_tokens', 'INTEGER'],
-        ['total_output_tokens', 'INTEGER'],
-        ['total_cache_create_tokens', 'INTEGER'],
-        ['total_cache_read_tokens', 'INTEGER'],
-        ['primary_model', 'TEXT'],
-        // v0.14b (T5) — derived session titles. Two tiers:
-        //   heuristic — scrubbed first_user_message, computed synchronously at
-        //               index time, always on.
-        //   agent     — 'claude -p' summary, opt-in via ✨ Generate title button.
-        // Fallback chain at display: alias → auto_title → first_user_message →
-        // id.slice(0,8). Manual alias always wins.
-        ['auto_title', 'TEXT'],
-        ['auto_title_source', 'TEXT'],
-        ['auto_title_generated_at', 'INTEGER'],
-        // JSON array of { title, source, replaced_at } — append-only history so
-        // a ✨ regenerate never loses the prior title (three-layer durability rule).
-        ['auto_title_history', 'TEXT'],
-        // v0.16 — Verification badges (opt-in preview). Computed on demand; cached
-        // in the sessions row with a 24h TTL.
-        ['verification_status', 'TEXT'],
-        ['verification_computed_at', 'INTEGER'],
-    ];
-    for (const [name, type] of adds) {
-        if (!have.has(name)) {
-            db.exec(`ALTER TABLE sessions ADD COLUMN ${name} ${type}`);
-        }
-    }
-    // v0.15 T6 — auto-collections. `source` distinguishes manual vs auto
-    // memberships so the rule engine can safely re-run without ever
-    // stomping a user's hand-picked choice. `rule_id` is the FK back to the
-    // rule that added the auto row — deleting a rule removes ONLY rows it
-    // authored. Both columns are additive and default to the pre-T6
-    // behaviour ('manual', no rule) so existing rows stay valid.
-    const csCols = db
-        .prepare(`PRAGMA table_info(collection_sessions)`)
-        .all();
-    const csHave = new Set(csCols.map((c) => c.name));
-    const csAdds = [
-        ['source', "TEXT NOT NULL DEFAULT 'manual'"],
-        ['rule_id', 'TEXT'],
-    ];
-    for (const [name, type] of csAdds) {
-        if (!csHave.has(name)) {
-            db.exec(`ALTER TABLE collection_sessions ADD COLUMN ${name} ${type}`);
-        }
-    }
-    // ✨ Generate Note — agent-generated synopsis stored ALONGSIDE the
-    // user-typed note. Never overwrites `content`. Hand-written notes and
-    // auto-synopses can coexist; the UI shows the synopsis beneath the
-    // manual note. Three nullable columns track value + source + timestamp,
-    // matching the auto_title pattern.
-    const snCols = db
-        .prepare(`PRAGMA table_info(session_notes)`)
-        .all();
-    const snHave = new Set(snCols.map((c) => c.name));
-    const snAdds = [
-        ['auto_synopsis', 'TEXT'],
-        ['auto_synopsis_generated_at', 'INTEGER'],
-        // JSON array of { synopsis, replaced_at } — append-only history so
-        // regenerating never loses the prior synopsis.
-        ['auto_synopsis_history', 'TEXT'],
-    ];
-    for (const [name, type] of snAdds) {
-        if (!snHave.has(name)) {
-            db.exec(`ALTER TABLE session_notes ADD COLUMN ${name} ${type}`);
-        }
-    }
-}
-//# sourceMappingURL=schema.js.map

package/dist/db/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":"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"}

package/dist/license/api-base.js

@@ -1,13 +0,0 @@
-/**
- * Where the CLI talks to the activation/validation API.
- *
- * Override with RECALL_API_BASE when developing against a local Next dev server,
- * e.g. `RECALL_API_BASE=http://127.0.0.1:3010 recall activate ...`.
- */
-export function apiBase() {
-    const fromEnv = process.env.RECALL_API_BASE;
-    if (fromEnv && fromEnv.length > 0)
-        return fromEnv.replace(/\/$/, '');
-    return 'https://clauderecall.com';
-}
-//# sourceMappingURL=api-base.js.map

package/dist/license/api-base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-base.js","sourceRoot":"","sources":["../../src/license/api-base.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,OAAO;IACrB,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC;IAC5C,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACrE,OAAO,0BAA0B,CAAC;AACpC,CAAC"}

package/dist/license/manager.js

@@ -1,43 +0,0 @@
-import { readStoredLicense } from './storage.js';
-import { verifyLicenseJwt } from './verify.js';
-export async function getLicenseStatus() {
-    const stored = readStoredLicense();
-    if (!stored)
-        return { tier: 'free' };
-    const verified = await verifyLicenseJwt(stored.license_jwt);
-    if (!verified.valid || !verified.claims) {
-        return { tier: 'free', invalid_reason: verified.reason };
-    }
-    return claimsToStatus(stored, verified.claims);
-}
-function claimsToStatus(stored, claims) {
-    return {
-        tier: 'pro',
-        key_short: stored.key_short,
-        customer_email: stored.customer_email,
-        activated_at: stored.activated_at,
-        test_mode: stored.test_mode,
-        expires_at: typeof claims.exp === 'number' ? new Date(claims.exp * 1000).toISOString() : null,
-    };
-}
-export async function isPro() {
-    const status = await getLicenseStatus();
-    return status.tier === 'pro';
-}
-/**
- * CLI gate. Prints a friendly message and exits 1 when the caller is not Pro.
- * Synchronous-style sugar for use at the top of a runX() command.
- */
-export async function requireProOrExit(featureName) {
-    const status = await getLicenseStatus();
-    if (status.tier === 'pro')
-        return;
-    process.stderr.write(`\n${featureName} is a Pro feature.\n\n` +
-        `Buy a license at https://clauderecall.com/pricing ($29.69 one-time, lifetime updates).\n` +
-        `Then run:  recall activate <license-key>\n\n`);
-    if (status.invalid_reason) {
-        process.stderr.write(`(stored license is invalid: ${status.invalid_reason})\n\n`);
-    }
-    process.exit(1);
-}
-//# sourceMappingURL=manager.js.map

package/dist/license/manager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../src/license/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAsB,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAsB,MAAM,aAAa,CAAC;AAgBnE,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACnC,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IACrC,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC5D,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;QACxC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC;IAC3D,CAAC;IACD,OAAO,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;AACjD,CAAC;AAED,SAAS,cAAc,CAAC,MAAqB,EAAE,MAAqB;IAClE,OAAO;QACL,IAAI,EAAE,KAAK;QACX,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,cAAc,EAAE,MAAM,CAAC,cAAc;QACrC,YAAY,EAAE,MAAM,CAAC,YAAY;QACjC,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,UAAU,EAAE,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI;KAC9F,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,KAAK;IACzB,MAAM,MAAM,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACxC,OAAO,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC;AAC/B,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,WAAmB;IACxD,MAAM,MAAM,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACxC,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK;QAAE,OAAO;IAClC,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,KAAK,WAAW,wBAAwB;QACtC,0FAA0F;QAC1F,8CAA8C,CACjD,CAAC;IACF,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;QAC1B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,+BAA+B,MAAM,CAAC,cAAc,OAAO,CAAC,CAAC;IACpF,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC"}

package/dist/license/public-key.js

@@ -1,19 +0,0 @@
-/**
- * ES256 (P-256) public key used to verify license JWTs offline.
- *
- * IMPORTANT: This PEM must match the one at site/lib/license-public-key.ts byte-for-byte.
- * Both copies were generated together on 2026-04-25. Rotating one without the other
- * would invalidate every previously-issued license JWT — that would break the
- * dead-man clause for all existing customers.
- *
- * The matching private key lives only in the site's LICENSE_JWT_PRIVATE_KEY env var.
- */
-export const LICENSE_JWT_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZysO2FffTLdyxQnTmnt78/ayvqz9
-kEgDDGWLdQN7jrx/W+Nxz9yOJbwTPDI4jv24IztWSEtJuqH+0KvrDbdfFA==
------END PUBLIC KEY-----
-`;
-export const LICENSE_JWT_ALG = 'ES256';
-export const LICENSE_JWT_ISSUER = 'clauderecall.com';
-export const LICENSE_JWT_AUDIENCE = 'clauderecall-cli';
-//# sourceMappingURL=public-key.js.map

package/dist/license/public-key.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"public-key.js","sourceRoot":"","sources":["../../src/license/public-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;CAIzC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,OAAgB,CAAC;AAChD,MAAM,CAAC,MAAM,kBAAkB,GAAG,kBAA2B,CAAC;AAC9D,MAAM,CAAC,MAAM,oBAAoB,GAAG,kBAA2B,CAAC"}

package/dist/license/storage.js

@@ -1,27 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { RECALL_HOME, ensureRecallHome } from '../utils/paths.js';
-export const LICENSE_FILE = join(RECALL_HOME, 'license.json');
-export function readStoredLicense() {
-    if (!existsSync(LICENSE_FILE))
-        return null;
-    try {
-        const raw = readFileSync(LICENSE_FILE, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.license_jwt !== 'string' || parsed.license_jwt.length === 0)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-export function writeStoredLicense(license) {
-    ensureRecallHome();
-    writeFileSync(LICENSE_FILE, JSON.stringify(license, null, 2) + '\n', { mode: 0o600 });
-}
-export function clearStoredLicense() {
-    if (existsSync(LICENSE_FILE))
-        unlinkSync(LICENSE_FILE);
-}
-//# sourceMappingURL=storage.js.map

package/dist/license/storage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/license/storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAElE,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;AAmB9D,MAAM,UAAU,iBAAiB;IAC/B,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3C,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAkB,CAAC;QAChD,IAAI,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,IAAI,MAAM,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC3F,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAAsB;IACvD,gBAAgB,EAAE,CAAC;IACnB,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;AACxF,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,IAAI,UAAU,CAAC,YAAY,CAAC;QAAE,UAAU,CAAC,YAAY,CAAC,CAAC;AACzD,CAAC"}

package/dist/license/verify.js

@@ -1,23 +0,0 @@
-import { jwtVerify, importSPKI } from 'jose';
-import { LICENSE_JWT_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, LICENSE_JWT_ISSUER, LICENSE_JWT_AUDIENCE, } from './public-key.js';
-let cachedKey = null;
-async function loadKey() {
-    if (cachedKey)
-        return cachedKey;
-    cachedKey = await importSPKI(LICENSE_JWT_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
-    return cachedKey;
-}
-export async function verifyLicenseJwt(token) {
-    try {
-        const key = await loadKey();
-        const { payload } = await jwtVerify(token, key, {
-            issuer: LICENSE_JWT_ISSUER,
-            audience: LICENSE_JWT_AUDIENCE,
-        });
-        return { valid: true, claims: payload };
-    }
-    catch (err) {
-        return { valid: false, reason: err instanceof Error ? err.message : 'verification failed' };
-    }
-}
-//# sourceMappingURL=verify.js.map

package/dist/license/verify.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify.js","sourceRoot":"","sources":["../../src/license/verify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAmB,MAAM,MAAM,CAAC;AAC9D,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAgBzB,IAAI,SAAS,GAAkD,IAAI,CAAC;AAEpE,KAAK,UAAU,OAAO;IACpB,IAAI,SAAS;QAAE,OAAO,SAAS,CAAC;IAChC,SAAS,GAAG,MAAM,UAAU,CAAC,0BAA0B,EAAE,eAAe,CAAC,CAAC;IAC1E,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,KAAa;IAClD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,OAAO,EAAE,CAAC;QAC5B,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE;YAC9C,MAAM,EAAE,kBAAkB;YAC1B,QAAQ,EAAE,oBAAoB;SAC/B,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAwB,EAAE,CAAC;IAC3D,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACtB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,qBAAqB,EAAE,CAAC;IAC9F,CAAC;AACH,CAAC"}