grov 0.5.2 → 0.5.3

package/dist/lib/store.js

@@ -1,1478 +1,2 @@
-// SQLite store for task reasoning at ~/.grov/memory.db
-import Database from 'better-sqlite3';
-import { existsSync, mkdirSync, chmodSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-/**
- * Escape LIKE pattern special characters to prevent SQL injection.
- * SECURITY: Prevents wildcard injection in LIKE queries.
- */
-function escapeLikePattern(str) {
-    return str.replace(/[%_\\]/g, '\\$&');
-}
-const GROV_DIR = join(homedir(), '.grov');
-const DB_PATH = join(GROV_DIR, 'memory.db');
-let db = null;
-// PERFORMANCE: Statement cache to avoid re-preparing frequently used queries
-const statementCache = new Map();
-/**
- * Get a cached prepared statement or create a new one.
- * PERFORMANCE: Avoids overhead of re-preparing the same SQL.
- */
-function getCachedStatement(database, sql) {
-    let stmt = statementCache.get(sql);
-    if (!stmt) {
-        stmt = database.prepare(sql);
-        statementCache.set(sql, stmt);
-    }
-    return stmt;
-}
-/**
- * Initialize the database connection and create tables
- */
-export function initDatabase() {
-    if (db)
-        return db;
-    // Ensure .grov directory exists with secure permissions
-    if (!existsSync(GROV_DIR)) {
-        mkdirSync(GROV_DIR, { recursive: true, mode: 0o700 });
-    }
-    db = new Database(DB_PATH);
-    // Set secure file permissions on the database
-    try {
-        chmodSync(DB_PATH, 0o600);
-    }
-    catch {
-        // SECURITY: Warn user if permissions can't be set (e.g., on Windows)
-        // The database may be world-readable on some systems
-        console.warn('Warning: Could not set restrictive permissions on ~/.grov/memory.db');
-        console.warn('Please ensure the file has appropriate permissions for your system.');
-    }
-    // OPTIMIZATION: Enable WAL mode for better concurrent performance
-    db.pragma('journal_mode = WAL');
-    // Create all tables in a single transaction for efficiency
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS tasks (
-      id TEXT PRIMARY KEY,
-      project_path TEXT NOT NULL,
-      user TEXT,
-      original_query TEXT NOT NULL,
-      goal TEXT,
-      reasoning_trace JSON DEFAULT '[]',
-      files_touched JSON DEFAULT '[]',
-      decisions JSON DEFAULT '[]',
-      constraints JSON DEFAULT '[]',
-      status TEXT NOT NULL CHECK(status IN ('complete', 'question', 'partial', 'abandoned')),
-      trigger_reason TEXT CHECK(trigger_reason IN ('complete', 'threshold', 'abandoned')),
-      linked_commit TEXT,
-      parent_task_id TEXT,
-      turn_number INTEGER,
-      tags JSON DEFAULT '[]',
-      created_at TEXT NOT NULL,
-      synced_at TEXT,
-      sync_error TEXT,
-      FOREIGN KEY (parent_task_id) REFERENCES tasks(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_project ON tasks(project_path);
-    CREATE INDEX IF NOT EXISTS idx_status ON tasks(status);
-    CREATE INDEX IF NOT EXISTS idx_created ON tasks(created_at);
-  `);
-    // Migration: add new columns to existing tasks table
-    try {
-        db.exec(`ALTER TABLE tasks ADD COLUMN decisions JSON DEFAULT '[]'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE tasks ADD COLUMN constraints JSON DEFAULT '[]'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE tasks ADD COLUMN trigger_reason TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE tasks ADD COLUMN synced_at TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE tasks ADD COLUMN sync_error TEXT`);
-    }
-    catch { /* column exists */ }
-    // Create session_states table (temporary per-session tracking)
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS session_states (
-      session_id TEXT PRIMARY KEY,
-      user_id TEXT,
-      project_path TEXT NOT NULL,
-      original_goal TEXT,
-      expected_scope JSON DEFAULT '[]',
-      constraints JSON DEFAULT '[]',
-      keywords JSON DEFAULT '[]',
-      token_count INTEGER DEFAULT 0,
-      escalation_count INTEGER DEFAULT 0,
-      session_mode TEXT DEFAULT 'normal' CHECK(session_mode IN ('normal', 'drifted', 'forced')),
-      waiting_for_recovery INTEGER DEFAULT 0,
-      last_checked_at INTEGER DEFAULT 0,
-      last_clear_at INTEGER,
-      start_time TEXT NOT NULL,
-      last_update TEXT NOT NULL,
-      status TEXT DEFAULT 'active' CHECK(status IN ('active', 'completed', 'abandoned')),
-      completed_at TEXT,
-      parent_session_id TEXT,
-      task_type TEXT DEFAULT 'main' CHECK(task_type IN ('main', 'subtask', 'parallel')),
-      pending_correction TEXT,
-      FOREIGN KEY (parent_session_id) REFERENCES session_states(session_id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_session_project ON session_states(project_path);
-    CREATE INDEX IF NOT EXISTS idx_session_status ON session_states(status);
-    CREATE INDEX IF NOT EXISTS idx_session_parent ON session_states(parent_session_id);
-  `);
-    // Migration: add new columns to existing session_states table
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN expected_scope JSON DEFAULT '[]'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN constraints JSON DEFAULT '[]'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN keywords JSON DEFAULT '[]'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN token_count INTEGER DEFAULT 0`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN escalation_count INTEGER DEFAULT 0`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN session_mode TEXT DEFAULT 'normal'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN waiting_for_recovery INTEGER DEFAULT 0`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_checked_at INTEGER DEFAULT 0`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_clear_at INTEGER`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN parent_session_id TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN task_type TEXT DEFAULT 'main'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE session_states ADD COLUMN completed_at TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_parent ON session_states(parent_session_id)`);
-    }
-    catch { /* index exists */ }
-    try {
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_completed ON session_states(completed_at)`);
-    }
-    catch { /* index exists */ }
-    // Create file_reasoning table (file-level reasoning with anchoring)
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS file_reasoning (
-      id TEXT PRIMARY KEY,
-      task_id TEXT,
-      file_path TEXT NOT NULL,
-      anchor TEXT,
-      line_start INTEGER,
-      line_end INTEGER,
-      code_hash TEXT,
-      change_type TEXT CHECK(change_type IN ('read', 'write', 'edit', 'create', 'delete')),
-      reasoning TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      FOREIGN KEY (task_id) REFERENCES tasks(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_file_task ON file_reasoning(task_id);
-    CREATE INDEX IF NOT EXISTS idx_file_path ON file_reasoning(file_path);
-    -- PERFORMANCE: Composite index for common query pattern (file_path + ORDER BY created_at)
-    CREATE INDEX IF NOT EXISTS idx_file_path_created ON file_reasoning(file_path, created_at DESC);
-  `);
-    // Migration: Add drift detection columns to session_states (safe to run multiple times)
-    const columns = db.pragma('table_info(session_states)');
-    const existingColumns = new Set(columns.map(c => c.name));
-    // Shared columns
-    if (!existingColumns.has('expected_scope')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN expected_scope JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('constraints')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN constraints JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('keywords')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN keywords JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('escalation_count')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN escalation_count INTEGER DEFAULT 0`);
-    }
-    if (!existingColumns.has('last_checked_at')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_checked_at INTEGER DEFAULT 0`);
-    }
-    // Hook-specific columns
-    if (!existingColumns.has('success_criteria')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN success_criteria JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('last_drift_score')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_drift_score INTEGER`);
-    }
-    if (!existingColumns.has('pending_recovery_plan')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN pending_recovery_plan JSON`);
-    }
-    if (!existingColumns.has('drift_history')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN drift_history JSON DEFAULT '[]'`);
-    }
-    // Proxy-specific columns
-    if (!existingColumns.has('token_count')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN token_count INTEGER DEFAULT 0`);
-    }
-    if (!existingColumns.has('session_mode')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN session_mode TEXT DEFAULT 'normal'`);
-    }
-    if (!existingColumns.has('waiting_for_recovery')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN waiting_for_recovery INTEGER DEFAULT 0`);
-    }
-    if (!existingColumns.has('last_clear_at')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_clear_at INTEGER`);
-    }
-    if (!existingColumns.has('completed_at')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN completed_at TEXT`);
-    }
-    if (!existingColumns.has('parent_session_id')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN parent_session_id TEXT`);
-    }
-    if (!existingColumns.has('task_type')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN task_type TEXT DEFAULT 'main'`);
-    }
-    // Additional hook fields
-    if (!existingColumns.has('actions_taken')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN actions_taken JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('files_explored')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN files_explored JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('current_intent')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN current_intent TEXT`);
-    }
-    if (!existingColumns.has('drift_warnings')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN drift_warnings JSON DEFAULT '[]'`);
-    }
-    if (!existingColumns.has('pending_correction')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN pending_correction TEXT`);
-    }
-    if (!existingColumns.has('pending_clear_summary')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN pending_clear_summary TEXT`);
-    }
-    if (!existingColumns.has('pending_forced_recovery')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN pending_forced_recovery TEXT`);
-    }
-    if (!existingColumns.has('final_response')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN final_response TEXT`);
-    }
-    // Create steps table (action log for current session)
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS steps (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      action_type TEXT NOT NULL CHECK(action_type IN ('edit', 'write', 'bash', 'read', 'glob', 'grep', 'task', 'other')),
-      files JSON DEFAULT '[]',
-      folders JSON DEFAULT '[]',
-      command TEXT,
-      reasoning TEXT,
-      drift_score INTEGER,
-      drift_type TEXT CHECK(drift_type IN ('none', 'minor', 'major', 'critical')),
-      is_key_decision INTEGER DEFAULT 0,
-      is_validated INTEGER DEFAULT 1,
-      correction_given TEXT,
-      correction_level TEXT CHECK(correction_level IN ('nudge', 'correct', 'intervene', 'halt')),
-      keywords JSON DEFAULT '[]',
-      timestamp INTEGER NOT NULL,
-      FOREIGN KEY (session_id) REFERENCES session_states(session_id)
-    );
-    CREATE INDEX IF NOT EXISTS idx_steps_session ON steps(session_id);
-    CREATE INDEX IF NOT EXISTS idx_steps_timestamp ON steps(timestamp);
-  `);
-    // Migration: add new columns to existing steps table
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN drift_type TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN is_key_decision INTEGER DEFAULT 0`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN is_validated INTEGER DEFAULT 1`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN correction_given TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN correction_level TEXT`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN keywords JSON DEFAULT '[]'`);
-    }
-    catch { /* column exists */ }
-    try {
-        db.exec(`ALTER TABLE steps ADD COLUMN reasoning TEXT`);
-    }
-    catch { /* column exists */ }
-    // Create drift_log table (rejected actions for audit)
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS drift_log (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      timestamp INTEGER NOT NULL,
-      action_type TEXT,
-      files JSON DEFAULT '[]',
-      drift_score INTEGER NOT NULL,
-      drift_reason TEXT,
-      correction_given TEXT,
-      recovery_plan JSON,
-      FOREIGN KEY (session_id) REFERENCES session_states(session_id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_drift_log_session ON drift_log(session_id);
-    CREATE INDEX IF NOT EXISTS idx_drift_log_timestamp ON drift_log(timestamp);
-  `);
-    return db;
-}
-/**
- * Close the database connection
- */
-export function closeDatabase() {
-    if (db) {
-        db.close();
-        db = null;
-        // PERFORMANCE: Clear statement cache when database is closed
-        statementCache.clear();
-    }
-}
-/**
- * Create a new task
- */
-export function createTask(input) {
-    const database = initDatabase();
-    const task = {
-        id: randomUUID(),
-        project_path: input.project_path,
-        user: input.user,
-        original_query: input.original_query,
-        goal: input.goal,
-        reasoning_trace: input.reasoning_trace || [],
-        files_touched: input.files_touched || [],
-        decisions: input.decisions || [],
-        constraints: input.constraints || [],
-        status: input.status,
-        trigger_reason: input.trigger_reason,
-        linked_commit: input.linked_commit,
-        parent_task_id: input.parent_task_id,
-        turn_number: input.turn_number,
-        tags: input.tags || [],
-        created_at: new Date().toISOString(),
-        synced_at: null,
-        sync_error: null
-    };
-    const stmt = database.prepare(`
-    INSERT INTO tasks (
-      id, project_path, user, original_query, goal,
-      reasoning_trace, files_touched, decisions, constraints,
-      status, trigger_reason, linked_commit,
-      parent_task_id, turn_number, tags, created_at, synced_at, sync_error
-    ) VALUES (
-      ?, ?, ?, ?, ?,
-      ?, ?, ?, ?,
-      ?, ?, ?,
-      ?, ?, ?, ?, ?, ?
-    )
-  `);
-    stmt.run(task.id, task.project_path, task.user || null, task.original_query, task.goal || null, JSON.stringify(task.reasoning_trace), JSON.stringify(task.files_touched), JSON.stringify(task.decisions), JSON.stringify(task.constraints), task.status, task.trigger_reason || null, task.linked_commit || null, task.parent_task_id || null, task.turn_number || null, JSON.stringify(task.tags), task.created_at, task.synced_at, task.sync_error);
-    return task;
-}
-/**
- * Get tasks for a project
- */
-export function getTasksForProject(projectPath, options = {}) {
-    const database = initDatabase();
-    let sql = 'SELECT * FROM tasks WHERE project_path = ?';
-    const params = [projectPath];
-    if (options.status) {
-        sql += ' AND status = ?';
-        params.push(options.status);
-    }
-    sql += ' ORDER BY created_at DESC';
-    if (options.limit) {
-        sql += ' LIMIT ?';
-        params.push(options.limit);
-    }
-    const stmt = database.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map(rowToTask);
-}
-/**
- * Get tasks that touched specific files.
- * SECURITY: Uses json_each for proper array handling and escaped LIKE patterns.
- */
-// SECURITY: Maximum files per query to prevent SQL DoS
-const MAX_FILES_PER_QUERY = 100;
-export function getTasksByFiles(projectPath, files, options = {}) {
-    const database = initDatabase();
-    if (files.length === 0) {
-        return [];
-    }
-    // SECURITY: Limit file count to prevent SQL DoS via massive query generation
-    const limitedFiles = files.length > MAX_FILES_PER_QUERY
-        ? files.slice(0, MAX_FILES_PER_QUERY)
-        : files;
-    // Use json_each for proper array iteration with escaped LIKE patterns
-    const fileConditions = limitedFiles.map(() => "EXISTS (SELECT 1 FROM json_each(files_touched) WHERE value LIKE ? ESCAPE '\\')").join(' OR ');
-    let sql = `SELECT * FROM tasks WHERE project_path = ? AND (${fileConditions})`;
-    // Escape LIKE special characters to prevent injection
-    const params = [
-        projectPath,
-        ...limitedFiles.map(f => `%${escapeLikePattern(f)}%`)
-    ];
-    if (options.status) {
-        sql += ' AND status = ?';
-        params.push(options.status);
-    }
-    sql += ' ORDER BY created_at DESC';
-    if (options.limit) {
-        sql += ' LIMIT ?';
-        params.push(options.limit);
-    }
-    const stmt = database.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map(rowToTask);
-}
-/**
- * Get a task by ID
- */
-export function getTaskById(id) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM tasks WHERE id = ?');
-    const row = stmt.get(id);
-    return row ? rowToTask(row) : null;
-}
-/**
- * Update a task's status
- */
-export function updateTaskStatus(id, status) {
-    const database = initDatabase();
-    const stmt = database.prepare('UPDATE tasks SET status = ? WHERE id = ?');
-    stmt.run(status, id);
-}
-/**
- * Get task count for a project
- */
-export function getTaskCount(projectPath) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT COUNT(*) as count FROM tasks WHERE project_path = ?');
-    const row = stmt.get(projectPath);
-    return row?.count ?? 0;
-}
-/**
- * Get unsynced tasks for a project (synced_at is NULL)
- */
-export function getUnsyncedTasks(projectPath, limit) {
-    const database = initDatabase();
-    let sql = 'SELECT * FROM tasks WHERE project_path = ? AND synced_at IS NULL ORDER BY created_at DESC';
-    const params = [projectPath];
-    if (limit) {
-        sql += ' LIMIT ?';
-        params.push(limit);
-    }
-    const stmt = database.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map(rowToTask);
-}
-/**
- * Mark a task as synced and clear any previous sync error
- */
-export function markTaskSynced(id) {
-    const database = initDatabase();
-    const now = new Date().toISOString();
-    database.prepare('UPDATE tasks SET synced_at = ?, sync_error = NULL WHERE id = ?').run(now, id);
-}
-/**
- * Record a sync error for a task
- */
-export function setTaskSyncError(id, error) {
-    const database = initDatabase();
-    database.prepare('UPDATE tasks SET sync_error = ? WHERE id = ?').run(error, id);
-}
-/**
- * Safely parse JSON with fallback to empty array.
- */
-function safeJsonParse(value, fallback) {
-    if (typeof value !== 'string' || !value) {
-        return fallback;
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return fallback;
-    }
-}
-/**
- * Convert database row to Task object
- */
-function rowToTask(row) {
-    return {
-        id: row.id,
-        project_path: row.project_path,
-        user: row.user,
-        original_query: row.original_query,
-        goal: row.goal,
-        reasoning_trace: safeJsonParse(row.reasoning_trace, []),
-        files_touched: safeJsonParse(row.files_touched, []),
-        decisions: safeJsonParse(row.decisions, []),
-        constraints: safeJsonParse(row.constraints, []),
-        status: row.status,
-        trigger_reason: row.trigger_reason,
-        linked_commit: row.linked_commit,
-        parent_task_id: row.parent_task_id,
-        turn_number: row.turn_number,
-        tags: safeJsonParse(row.tags, []),
-        created_at: row.created_at,
-        synced_at: row.synced_at,
-        sync_error: row.sync_error
-    };
-}
-// ============================================
-// SESSION STATE CRUD OPERATIONS
-// ============================================
-/**
- * Create a new session state.
- * FIXED: Uses INSERT OR IGNORE to handle race conditions safely.
- */
-export function createSessionState(input) {
-    const database = initDatabase();
-    const now = new Date().toISOString();
-    const sessionState = {
-        // Base fields
-        session_id: input.session_id,
-        user_id: input.user_id,
-        project_path: input.project_path,
-        original_goal: input.original_goal,
-        expected_scope: input.expected_scope || [],
-        constraints: input.constraints || [],
-        keywords: input.keywords || [],
-        escalation_count: 0,
-        last_checked_at: 0,
-        start_time: now,
-        last_update: now,
-        status: 'active',
-        // Hook-specific fields
-        success_criteria: input.success_criteria || [],
-        last_drift_score: undefined,
-        pending_recovery_plan: undefined,
-        drift_history: [],
-        actions_taken: [],
-        files_explored: [],
-        current_intent: undefined,
-        drift_warnings: [],
-        // Proxy-specific fields
-        token_count: 0,
-        session_mode: 'normal',
-        waiting_for_recovery: false,
-        last_clear_at: undefined,
-        completed_at: undefined,
-        parent_session_id: input.parent_session_id,
-        task_type: input.task_type || 'main',
-    };
-    const stmt = database.prepare(`
-    INSERT OR IGNORE INTO session_states (
-      session_id, user_id, project_path, original_goal,
-      expected_scope, constraints, keywords,
-      token_count, escalation_count, session_mode,
-      waiting_for_recovery, last_checked_at, last_clear_at,
-      start_time, last_update, status,
-      parent_session_id, task_type,
-      success_criteria, last_drift_score, pending_recovery_plan, drift_history,
-      completed_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    stmt.run(sessionState.session_id, sessionState.user_id || null, sessionState.project_path, sessionState.original_goal || null, JSON.stringify(sessionState.expected_scope), JSON.stringify(sessionState.constraints), JSON.stringify(sessionState.keywords), sessionState.token_count, sessionState.escalation_count, sessionState.session_mode, sessionState.waiting_for_recovery ? 1 : 0, sessionState.last_checked_at, sessionState.last_clear_at || null, sessionState.start_time, sessionState.last_update, sessionState.status, sessionState.parent_session_id || null, sessionState.task_type, JSON.stringify(sessionState.success_criteria || []), sessionState.last_drift_score || null, sessionState.pending_recovery_plan ? JSON.stringify(sessionState.pending_recovery_plan) : null, JSON.stringify(sessionState.drift_history || []), sessionState.completed_at || null);
-    return sessionState;
-}
-/**
- * Get a session state by ID
- */
-export function getSessionState(sessionId) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM session_states WHERE session_id = ?');
-    const row = stmt.get(sessionId);
-    return row ? rowToSessionState(row) : null;
-}
-/**
- * Update a session state.
- * SECURITY: Uses transaction for atomic updates to prevent race conditions.
- */
-export function updateSessionState(sessionId, updates) {
-    const database = initDatabase();
-    const setClauses = [];
-    const params = [];
-    if (updates.user_id !== undefined) {
-        setClauses.push('user_id = ?');
-        params.push(updates.user_id || null);
-    }
-    if (updates.project_path !== undefined) {
-        setClauses.push('project_path = ?');
-        params.push(updates.project_path);
-    }
-    if (updates.original_goal !== undefined) {
-        setClauses.push('original_goal = ?');
-        params.push(updates.original_goal || null);
-    }
-    if (updates.expected_scope !== undefined) {
-        setClauses.push('expected_scope = ?');
-        params.push(JSON.stringify(updates.expected_scope));
-    }
-    if (updates.constraints !== undefined) {
-        setClauses.push('constraints = ?');
-        params.push(JSON.stringify(updates.constraints));
-    }
-    if (updates.keywords !== undefined) {
-        setClauses.push('keywords = ?');
-        params.push(JSON.stringify(updates.keywords));
-    }
-    if (updates.token_count !== undefined) {
-        setClauses.push('token_count = ?');
-        params.push(updates.token_count);
-    }
-    if (updates.escalation_count !== undefined) {
-        setClauses.push('escalation_count = ?');
-        params.push(updates.escalation_count);
-    }
-    if (updates.session_mode !== undefined) {
-        setClauses.push('session_mode = ?');
-        params.push(updates.session_mode);
-    }
-    if (updates.waiting_for_recovery !== undefined) {
-        setClauses.push('waiting_for_recovery = ?');
-        params.push(updates.waiting_for_recovery ? 1 : 0);
-    }
-    if (updates.last_checked_at !== undefined) {
-        setClauses.push('last_checked_at = ?');
-        params.push(updates.last_checked_at);
-    }
-    if (updates.last_clear_at !== undefined) {
-        setClauses.push('last_clear_at = ?');
-        params.push(updates.last_clear_at);
-    }
-    if (updates.status !== undefined) {
-        setClauses.push('status = ?');
-        params.push(updates.status);
-    }
-    if (updates.pending_correction !== undefined) {
-        setClauses.push('pending_correction = ?');
-        params.push(updates.pending_correction || null);
-    }
-    if (updates.pending_forced_recovery !== undefined) {
-        setClauses.push('pending_forced_recovery = ?');
-        params.push(updates.pending_forced_recovery || null);
-    }
-    if (updates.pending_clear_summary !== undefined) {
-        setClauses.push('pending_clear_summary = ?');
-        params.push(updates.pending_clear_summary || null);
-    }
-    if (updates.final_response !== undefined) {
-        setClauses.push('final_response = ?');
-        params.push(updates.final_response || null);
-    }
-    // Always update last_update
-    setClauses.push('last_update = ?');
-    params.push(new Date().toISOString());
-    if (setClauses.length === 0)
-        return;
-    params.push(sessionId);
-    const sql = `UPDATE session_states SET ${setClauses.join(', ')} WHERE session_id = ?`;
-    // SECURITY: Use transaction for atomic updates to prevent race conditions
-    const transaction = database.transaction(() => {
-        database.prepare(sql).run(...params);
-    });
-    transaction();
-}
-/**
- * Delete a session state
- */
-export function deleteSessionState(sessionId) {
-    const database = initDatabase();
-    database.prepare('DELETE FROM session_states WHERE session_id = ?').run(sessionId);
-}
-/**
- * Get active sessions for a project
- */
-export function getActiveSessionsForProject(projectPath) {
-    const database = initDatabase();
-    const stmt = database.prepare("SELECT * FROM session_states WHERE project_path = ? AND status = 'active' ORDER BY start_time DESC");
-    const rows = stmt.all(projectPath);
-    return rows.map(rowToSessionState);
-}
-/**
- * Get child sessions (subtasks and parallel tasks) for a parent session
- */
-export function getChildSessions(parentSessionId) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM session_states WHERE parent_session_id = ? ORDER BY start_time DESC');
-    const rows = stmt.all(parentSessionId);
-    return rows.map(rowToSessionState);
-}
-/**
- * Get active session for a specific user in a project
- */
-export function getActiveSessionForUser(projectPath, userId) {
-    const database = initDatabase();
-    if (userId) {
-        const stmt = database.prepare("SELECT * FROM session_states WHERE project_path = ? AND user_id = ? AND status = 'active' ORDER BY last_update DESC LIMIT 1");
-        const row = stmt.get(projectPath, userId);
-        return row ? rowToSessionState(row) : null;
-    }
-    else {
-        const stmt = database.prepare("SELECT * FROM session_states WHERE project_path = ? AND status = 'active' ORDER BY last_update DESC LIMIT 1");
-        const row = stmt.get(projectPath);
-        return row ? rowToSessionState(row) : null;
-    }
-}
-/**
- * Get all active sessions (for proxy-status command)
- */
-export function getActiveSessionsForStatus() {
-    const database = initDatabase();
-    const stmt = database.prepare("SELECT * FROM session_states WHERE status = 'active' ORDER BY last_update DESC LIMIT 20");
-    const rows = stmt.all();
-    return rows.map(rowToSessionState);
-}
-/**
- * Convert database row to SessionState object
- */
-function rowToSessionState(row) {
-    return {
-        // Base fields
-        session_id: row.session_id,
-        user_id: row.user_id,
-        project_path: row.project_path,
-        original_goal: row.original_goal,
-        expected_scope: safeJsonParse(row.expected_scope, []),
-        constraints: safeJsonParse(row.constraints, []),
-        keywords: safeJsonParse(row.keywords, []),
-        escalation_count: row.escalation_count || 0,
-        last_checked_at: row.last_checked_at || 0,
-        start_time: row.start_time,
-        last_update: row.last_update,
-        status: row.status,
-        // Hook-specific fields
-        success_criteria: safeJsonParse(row.success_criteria, []),
-        last_drift_score: row.last_drift_score,
-        pending_recovery_plan: safeJsonParse(row.pending_recovery_plan, undefined),
-        drift_history: safeJsonParse(row.drift_history, []),
-        actions_taken: safeJsonParse(row.actions_taken, []),
-        files_explored: safeJsonParse(row.files_explored, []),
-        current_intent: row.current_intent,
-        drift_warnings: safeJsonParse(row.drift_warnings, []),
-        // Proxy-specific fields
-        token_count: row.token_count || 0,
-        session_mode: row.session_mode || 'normal',
-        waiting_for_recovery: Boolean(row.waiting_for_recovery),
-        last_clear_at: row.last_clear_at,
-        completed_at: row.completed_at,
-        parent_session_id: row.parent_session_id,
-        task_type: row.task_type || 'main',
-        pending_correction: row.pending_correction,
-        pending_forced_recovery: row.pending_forced_recovery,
-        pending_clear_summary: row.pending_clear_summary,
-        final_response: row.final_response,
-    };
-}
-// ============================================
-// DRIFT DETECTION OPERATIONS (hook uses these)
-// ============================================
-/**
- * Update session drift metrics after a prompt check
- */
-export function updateSessionDrift(sessionId, driftScore, correctionLevel, promptSummary, recoveryPlan) {
-    const database = initDatabase();
-    const session = getSessionState(sessionId);
-    if (!session)
-        return;
-    const now = new Date().toISOString();
-    // Calculate new escalation count
-    let newEscalation = session.escalation_count;
-    if (driftScore >= 8) {
-        // Recovery - decrease escalation
-        newEscalation = Math.max(0, newEscalation - 1);
-    }
-    else if (correctionLevel && correctionLevel !== 'nudge') {
-        // Significant drift - increase escalation
-        newEscalation = Math.min(3, newEscalation + 1);
-    }
-    // Add to drift history
-    const driftEvent = {
-        timestamp: now,
-        score: driftScore,
-        level: correctionLevel || 'none',
-        prompt_summary: promptSummary.substring(0, 100)
-    };
-    const newHistory = [...(session.drift_history || []), driftEvent];
-    // Add to drift_warnings if correction was given
-    const currentWarnings = session.drift_warnings || [];
-    const newWarnings = correctionLevel
-        ? [...currentWarnings, `[${now}] ${correctionLevel}: score ${driftScore}`]
-        : currentWarnings;
-    const stmt = database.prepare(`
-    UPDATE session_states SET
-      last_drift_score = ?,
-      escalation_count = ?,
-      pending_recovery_plan = ?,
-      drift_history = ?,
-      drift_warnings = ?,
-      last_update = ?
-    WHERE session_id = ?
-  `);
-    stmt.run(driftScore, newEscalation, recoveryPlan ? JSON.stringify(recoveryPlan) : null, JSON.stringify(newHistory), JSON.stringify(newWarnings), now, sessionId);
-}
-/**
- * Check if a session should be flagged for review
- * Returns true if: status=drifted OR warnings>=3 OR avg_score<6
- */
-export function shouldFlagForReview(sessionId) {
-    const session = getSessionState(sessionId);
-    if (!session)
-        return false;
-    // Check number of warnings
-    const warnings = session.drift_warnings || [];
-    if (warnings.length >= 3) {
-        return true;
-    }
-    // Check drift history for average score
-    const history = session.drift_history || [];
-    if (history.length >= 2) {
-        const totalScore = history.reduce((sum, e) => sum + e.score, 0);
-        const avgScore = totalScore / history.length;
-        if (avgScore < 6) {
-            return true;
-        }
-    }
-    // Check if any HALT level drift occurred
-    if (history.some(e => e.level === 'halt')) {
-        return true;
-    }
-    // Check current escalation level
-    if (session.escalation_count >= 2) {
-        return true;
-    }
-    return false;
-}
-/**
- * Get drift summary for a session (used by capture)
- */
-export function getDriftSummary(sessionId) {
-    const session = getSessionState(sessionId);
-    const history = session?.drift_history || [];
-    if (!session || history.length === 0) {
-        return { totalEvents: 0, resolved: true, finalScore: null, hadHalt: false };
-    }
-    const lastEvent = history[history.length - 1];
-    return {
-        totalEvents: history.length,
-        resolved: lastEvent.score >= 8,
-        finalScore: lastEvent.score,
-        hadHalt: history.some(e => e.level === 'halt')
-    };
-}
-// ============================================
-// FILE REASONING CRUD OPERATIONS
-// ============================================
-/**
- * Create a new file reasoning entry
- */
-export function createFileReasoning(input) {
-    const database = initDatabase();
-    const fileReasoning = {
-        id: randomUUID(),
-        task_id: input.task_id,
-        file_path: input.file_path,
-        anchor: input.anchor,
-        line_start: input.line_start,
-        line_end: input.line_end,
-        code_hash: input.code_hash,
-        change_type: input.change_type,
-        reasoning: input.reasoning,
-        created_at: new Date().toISOString()
-    };
-    const stmt = database.prepare(`
-    INSERT INTO file_reasoning (
-      id, task_id, file_path, anchor, line_start, line_end,
-      code_hash, change_type, reasoning, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    stmt.run(fileReasoning.id, fileReasoning.task_id || null, fileReasoning.file_path, fileReasoning.anchor || null, fileReasoning.line_start || null, fileReasoning.line_end || null, fileReasoning.code_hash || null, fileReasoning.change_type || null, fileReasoning.reasoning, fileReasoning.created_at);
-    return fileReasoning;
-}
-/**
- * Get file reasoning entries for a task
- */
-export function getFileReasoningForTask(taskId) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM file_reasoning WHERE task_id = ? ORDER BY created_at DESC');
-    const rows = stmt.all(taskId);
-    return rows.map(rowToFileReasoning);
-}
-/**
- * Get file reasoning entries by file path
- */
-export function getFileReasoningByPath(filePath, limit = 10) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM file_reasoning WHERE file_path = ? ORDER BY created_at DESC LIMIT ?');
-    const rows = stmt.all(filePath, limit);
-    return rows.map(rowToFileReasoning);
-}
-/**
- * Get file reasoning entries matching a pattern (for files in a project).
- * SECURITY: Uses escaped LIKE patterns to prevent injection.
- */
-export function getFileReasoningByPathPattern(pathPattern, limit = 20) {
-    const database = initDatabase();
-    // Escape LIKE special characters to prevent injection
-    const escapedPattern = escapeLikePattern(pathPattern);
-    const stmt = database.prepare("SELECT * FROM file_reasoning WHERE file_path LIKE ? ESCAPE '\\' ORDER BY created_at DESC LIMIT ?");
-    const rows = stmt.all(`%${escapedPattern}%`, limit);
-    return rows.map(rowToFileReasoning);
-}
-/**
- * Convert database row to FileReasoning object
- */
-function rowToFileReasoning(row) {
-    return {
-        id: row.id,
-        task_id: row.task_id,
-        file_path: row.file_path,
-        anchor: row.anchor,
-        line_start: row.line_start,
-        line_end: row.line_end,
-        code_hash: row.code_hash,
-        change_type: row.change_type,
-        reasoning: row.reasoning,
-        created_at: row.created_at
-    };
-}
-/**
- * Get the database path
- */
-export function getDatabasePath() {
-    return DB_PATH;
-}
-// ============================================
-// STEPS CRUD OPERATIONS (Proxy uses these)
-// ============================================
-/**
- * Create a new step record (proxy version)
- */
-export function createStep(input) {
-    const database = initDatabase();
-    const step = {
-        id: randomUUID(),
-        session_id: input.session_id,
-        action_type: input.action_type,
-        files: input.files || [],
-        folders: input.folders || [],
-        command: input.command,
-        reasoning: input.reasoning,
-        drift_score: input.drift_score,
-        drift_type: input.drift_type,
-        is_key_decision: input.is_key_decision || false,
-        is_validated: input.is_validated !== false,
-        correction_given: input.correction_given,
-        correction_level: input.correction_level,
-        keywords: input.keywords || [],
-        timestamp: Date.now()
-    };
-    const stmt = database.prepare(`
-    INSERT INTO steps (
-      id, session_id, action_type, files, folders, command, reasoning,
-      drift_score, drift_type, is_key_decision, is_validated,
-      correction_given, correction_level, keywords, timestamp
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    stmt.run(step.id, step.session_id, step.action_type, JSON.stringify(step.files), JSON.stringify(step.folders), step.command || null, step.reasoning || null, step.drift_score || null, step.drift_type || null, step.is_key_decision ? 1 : 0, step.is_validated ? 1 : 0, step.correction_given || null, step.correction_level || null, JSON.stringify(step.keywords), step.timestamp);
-    return step;
-}
-/**
- * Get steps for a session
- */
-export function getStepsForSession(sessionId, limit) {
-    const database = initDatabase();
-    let sql = 'SELECT * FROM steps WHERE session_id = ? ORDER BY timestamp DESC';
-    const params = [sessionId];
-    if (limit) {
-        sql += ' LIMIT ?';
-        params.push(limit);
-    }
-    const stmt = database.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map(rowToStep);
-}
-/**
- * Get recent steps for a session (most recent N)
- */
-export function getRecentSteps(sessionId, count = 10) {
-    return getStepsForSession(sessionId, count);
-}
-/**
- * Get validated steps only (for summary generation)
- */
-export function getValidatedSteps(sessionId) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM steps WHERE session_id = ? AND is_validated = 1 ORDER BY timestamp ASC');
-    const rows = stmt.all(sessionId);
-    return rows.map(rowToStep);
-}
-/**
- * Get key decision steps for a session (is_key_decision = 1)
- * Used for user message injection - important decisions with reasoning
- */
-export function getKeyDecisions(sessionId, limit = 5) {
-    const database = initDatabase();
-    const stmt = database.prepare(`SELECT * FROM steps
-     WHERE session_id = ? AND is_key_decision = 1 AND reasoning IS NOT NULL
-     ORDER BY timestamp DESC
-     LIMIT ?`);
-    const rows = stmt.all(sessionId, limit);
-    return rows.map(rowToStep);
-}
-/**
- * Get edited files for a session (action_type IN ('edit', 'write'))
- * Used for user message injection - prevent re-work
- */
-export function getEditedFiles(sessionId) {
-    const database = initDatabase();
-    const stmt = database.prepare(`SELECT DISTINCT files FROM steps
-     WHERE session_id = ? AND action_type IN ('edit', 'write')
-     ORDER BY timestamp DESC`);
-    const rows = stmt.all(sessionId);
-    const allFiles = [];
-    for (const row of rows) {
-        try {
-            const files = JSON.parse(row.files || '[]');
-            if (Array.isArray(files)) {
-                allFiles.push(...files);
-            }
-        }
-        catch {
-            // Skip invalid JSON
-        }
-    }
-    return [...new Set(allFiles)];
-}
-/**
- * Delete steps for a session
- */
-export function deleteStepsForSession(sessionId) {
-    const database = initDatabase();
-    database.prepare('DELETE FROM steps WHERE session_id = ?').run(sessionId);
-}
-/**
- * Update reasoning for recent steps that don't have reasoning yet
- * Called at end_turn to backfill reasoning from Claude's text response
- */
-export function updateRecentStepsReasoning(sessionId, reasoning, limit = 10) {
-    const database = initDatabase();
-    const stmt = database.prepare(`
-    UPDATE steps
-    SET reasoning = ?
-    WHERE session_id = ?
-    AND (reasoning IS NULL OR reasoning = '')
-    AND id IN (
-      SELECT id FROM steps
-      WHERE session_id = ?
-      ORDER BY timestamp DESC
-      LIMIT ?
-    )
-  `);
-    const result = stmt.run(reasoning, sessionId, sessionId, limit);
-    return result.changes;
-}
-/**
- * Get relevant steps (key decisions and write/edit actions) - proxy version
- * Reference: plan_proxy_local.md Section 2.2
- */
-export function getRelevantStepsSimple(sessionId, limit = 20) {
-    const database = initDatabase();
-    const stmt = database.prepare(`
-    SELECT * FROM steps
-    WHERE session_id = ?
-    AND (is_key_decision = 1 OR action_type IN ('edit', 'write', 'bash'))
-    AND is_validated = 1
-    ORDER BY timestamp DESC
-    LIMIT ?
-  `);
-    const rows = stmt.all(sessionId, limit);
-    return rows.map(rowToStep);
-}
-/**
- * Convert database row to StepRecord object (proxy version - all fields)
- */
-function rowToStep(row) {
-    return {
-        id: row.id,
-        session_id: row.session_id,
-        action_type: row.action_type,
-        files: safeJsonParse(row.files, []),
-        folders: safeJsonParse(row.folders, []),
-        command: row.command,
-        reasoning: row.reasoning,
-        drift_score: row.drift_score,
-        drift_type: row.drift_type,
-        is_key_decision: Boolean(row.is_key_decision),
-        is_validated: Boolean(row.is_validated),
-        correction_given: row.correction_given,
-        correction_level: row.correction_level,
-        keywords: safeJsonParse(row.keywords, []),
-        timestamp: row.timestamp
-    };
-}
-// ============================================
-// STEPS CRUD (Hook uses these)
-// ============================================
-/**
- * Save a Claude action as a step (hook version - uses ClaudeAction)
- */
-export function saveStep(sessionId, action, driftScore, isKeyDecision = false, keywords = []) {
-    const database = initDatabase();
-    // Extract folders from files
-    const folders = [...new Set(action.files
-            .map(f => f.split('/').slice(0, -1).join('/'))
-            .filter(f => f.length > 0))];
-    database.prepare(`
-    INSERT INTO steps (id, session_id, action_type, files, folders, command, drift_score, is_key_decision, keywords, timestamp)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(randomUUID(), sessionId, action.type, JSON.stringify(action.files), JSON.stringify(folders), action.command || null, driftScore, isKeyDecision ? 1 : 0, JSON.stringify(keywords), action.timestamp);
-}
-/**
- * Update last_checked_at timestamp for a session
- */
-export function updateLastChecked(sessionId, timestamp) {
-    const database = initDatabase();
-    database.prepare(`
-    UPDATE session_states SET last_checked_at = ? WHERE session_id = ?
-  `).run(timestamp, sessionId);
-}
-// ============================================
-// 4-QUERY RETRIEVAL (Hook uses these - from deep_dive.md)
-// ============================================
-/**
- * Get steps that touched specific files
- */
-export function getStepsByFiles(sessionId, files, limit = 5) {
-    if (files.length === 0)
-        return [];
-    const database = initDatabase();
-    const placeholders = files.map(() => `files LIKE ?`).join(' OR ');
-    const patterns = files.map(f => `%"${escapeLikePattern(f)}"%`);
-    const rows = database.prepare(`
-    SELECT * FROM steps
-    WHERE session_id = ? AND drift_score >= 5 AND (${placeholders})
-    ORDER BY timestamp DESC LIMIT ?
-  `).all(sessionId, ...patterns, limit);
-    return rows.map(rowToStepRecord);
-}
-/**
- * Get steps that touched specific folders
- */
-export function getStepsByFolders(sessionId, folders, limit = 5) {
-    if (folders.length === 0)
-        return [];
-    const database = initDatabase();
-    const placeholders = folders.map(() => `folders LIKE ?`).join(' OR ');
-    const patterns = folders.map(f => `%"${escapeLikePattern(f)}"%`);
-    const rows = database.prepare(`
-    SELECT * FROM steps
-    WHERE session_id = ? AND drift_score >= 5 AND (${placeholders})
-    ORDER BY timestamp DESC LIMIT ?
-  `).all(sessionId, ...patterns, limit);
-    return rows.map(rowToStepRecord);
-}
-/**
- * Get steps matching keywords
- */
-export function getStepsByKeywords(sessionId, keywords, limit = 5) {
-    if (keywords.length === 0)
-        return [];
-    const database = initDatabase();
-    const conditions = keywords.map(() => `keywords LIKE ?`).join(' OR ');
-    const patterns = keywords.map(k => `%"${escapeLikePattern(k)}"%`);
-    const rows = database.prepare(`
-    SELECT * FROM steps
-    WHERE session_id = ? AND drift_score >= 5 AND (${conditions})
-    ORDER BY timestamp DESC LIMIT ?
-  `).all(sessionId, ...patterns, limit);
-    return rows.map(rowToStepRecord);
-}
-/**
- * Get key decision steps
- */
-export function getKeyDecisionSteps(sessionId, limit = 5) {
-    const database = initDatabase();
-    const rows = database.prepare(`
-    SELECT * FROM steps
-    WHERE session_id = ? AND is_key_decision = 1
-    ORDER BY timestamp DESC LIMIT ?
-  `).all(sessionId, limit);
-    return rows.map(rowToStepRecord);
-}
-/**
- * Get steps reasoning by file path (for proxy team memory injection)
- * Searches across sessions, returns file-level reasoning from steps table
- * @param excludeSessionId - Optional session ID to exclude (for filtering current session)
- */
-export function getStepsReasoningByPath(filePath, limit = 5, excludeSessionId) {
-    const database = initDatabase();
-    // Search steps where files JSON contains this path and reasoning exists
-    const pattern = `%"${escapeLikePattern(filePath)}"%`;
-    let sql = `
-    SELECT files, reasoning
-    FROM steps
-    WHERE files LIKE ? AND reasoning IS NOT NULL AND reasoning != ''
-  `;
-    const params = [pattern];
-    // Exclude current session if specified (for team memory from PAST sessions only)
-    if (excludeSessionId) {
-        sql += ` AND session_id != ?`;
-        params.push(excludeSessionId);
-    }
-    sql += ` ORDER BY timestamp DESC LIMIT ?`;
-    params.push(limit);
-    const rows = database.prepare(sql).all(...params);
-    return rows.map(row => {
-        const files = safeJsonParse(row.files, []);
-        // Find the matching file path from the files array
-        const matchedFile = files.find(f => f.includes(filePath)) || filePath;
-        return {
-            file_path: matchedFile,
-            reasoning: row.reasoning,
-        };
-    });
-}
-/**
- * Combined retrieval: runs all 4 queries and deduplicates (hook version)
- * Priority: key decisions > files > folders > keywords
- */
-export function getRelevantSteps(sessionId, currentFiles, currentFolders, keywords, limit = 10) {
-    const byFiles = getStepsByFiles(sessionId, currentFiles, 5);
-    const byFolders = getStepsByFolders(sessionId, currentFolders, 5);
-    const byKeywords = getStepsByKeywords(sessionId, keywords, 5);
-    const keyDecisions = getKeyDecisionSteps(sessionId, 5);
-    const seen = new Set();
-    const results = [];
-    // Priority order: key decisions > files > folders > keywords
-    for (const step of [...keyDecisions, ...byFiles, ...byFolders, ...byKeywords]) {
-        if (!seen.has(step.id)) {
-            seen.add(step.id);
-            results.push(step);
-            if (results.length >= limit)
-                break;
-        }
-    }
-    return results;
-}
-/**
- * Convert database row to StepRecord (hook version - basic fields)
- */
-function rowToStepRecord(row) {
-    return {
-        id: row.id,
-        session_id: row.session_id,
-        action_type: row.action_type,
-        files: safeJsonParse(row.files, []),
-        folders: safeJsonParse(row.folders, []),
-        command: row.command,
-        reasoning: row.reasoning,
-        drift_score: row.drift_score || 0,
-        drift_type: row.drift_type,
-        is_key_decision: Boolean(row.is_key_decision),
-        is_validated: Boolean(row.is_validated),
-        correction_given: row.correction_given,
-        correction_level: row.correction_level,
-        keywords: safeJsonParse(row.keywords, []),
-        timestamp: row.timestamp
-    };
-}
-// ============================================
-// DRIFT LOG CRUD OPERATIONS (Proxy uses these)
-// ============================================
-/**
- * Log a drift event (for rejected actions)
- */
-export function logDriftEvent(input) {
-    const database = initDatabase();
-    const entry = {
-        id: randomUUID(),
-        session_id: input.session_id,
-        timestamp: Date.now(),
-        action_type: input.action_type,
-        files: input.files || [],
-        drift_score: input.drift_score,
-        drift_reason: input.drift_reason,
-        correction_given: input.correction_given,
-        recovery_plan: input.recovery_plan
-    };
-    const stmt = database.prepare(`
-    INSERT INTO drift_log (
-      id, session_id, timestamp, action_type, files,
-      drift_score, drift_reason, correction_given, recovery_plan
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    stmt.run(entry.id, entry.session_id, entry.timestamp, entry.action_type || null, JSON.stringify(entry.files), entry.drift_score, entry.drift_reason || null, entry.correction_given || null, entry.recovery_plan ? JSON.stringify(entry.recovery_plan) : null);
-    return entry;
-}
-/**
- * Get drift log for a session
- */
-export function getDriftLog(sessionId, limit = 50) {
-    const database = initDatabase();
-    const stmt = database.prepare('SELECT * FROM drift_log WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?');
-    const rows = stmt.all(sessionId, limit);
-    return rows.map(rowToDriftLogEntry);
-}
-/**
- * Convert database row to DriftLogEntry object
- */
-function rowToDriftLogEntry(row) {
-    return {
-        id: row.id,
-        session_id: row.session_id,
-        timestamp: row.timestamp,
-        action_type: row.action_type,
-        files: safeJsonParse(row.files, []),
-        drift_score: row.drift_score,
-        drift_reason: row.drift_reason,
-        correction_given: row.correction_given,
-        recovery_plan: row.recovery_plan ? safeJsonParse(row.recovery_plan, {}) : undefined
-    };
-}
-// ============================================
-// CONVENIENCE FUNCTIONS FOR PROXY
-// ============================================
-/**
- * Update token count for a session
- */
-export function updateTokenCount(sessionId, tokenCount) {
-    updateSessionState(sessionId, { token_count: tokenCount });
-}
-/**
- * Update session mode
- */
-export function updateSessionMode(sessionId, mode) {
-    updateSessionState(sessionId, { session_mode: mode });
-}
-/**
- * Mark session as waiting for recovery
- */
-export function markWaitingForRecovery(sessionId, waiting) {
-    updateSessionState(sessionId, { waiting_for_recovery: waiting });
-}
-/**
- * Increment escalation count
- */
-export function incrementEscalation(sessionId) {
-    const session = getSessionState(sessionId);
-    if (session) {
-        updateSessionState(sessionId, { escalation_count: session.escalation_count + 1 });
-    }
-}
-/**
- * Update last clear timestamp and reset token count
- */
-export function markCleared(sessionId) {
-    updateSessionState(sessionId, {
-        last_clear_at: Date.now(),
-        token_count: 0
-    });
-}
-/**
- * Mark session as completed (instead of deleting)
- * Session will be cleaned up after 1 hour
- */
-export function markSessionCompleted(sessionId) {
-    const database = initDatabase();
-    const now = new Date().toISOString();
-    database.prepare(`
-    UPDATE session_states
-    SET status = 'completed', completed_at = ?, last_update = ?
-    WHERE session_id = ?
-  `).run(now, now, sessionId);
-}
-/**
- * Cleanup sessions completed more than 24 hours ago
- * Also deletes associated steps and drift_log entries
- * Skips sessions that have active children (RESTRICT approach)
- * Returns number of sessions cleaned up
- */
-export function cleanupOldCompletedSessions(maxAgeMs = 86400000) {
-    const database = initDatabase();
-    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
-    // Get sessions to cleanup, excluding those with active children
-    // RESTRICT approach: don't delete parent if children still active
-    const oldSessions = database.prepare(`
-    SELECT session_id FROM session_states
-    WHERE status = 'completed'
-      AND completed_at < ?
-      AND session_id NOT IN (
-        SELECT DISTINCT parent_session_id
-        FROM session_states
-        WHERE parent_session_id IS NOT NULL
-          AND status != 'completed'
-      )
-  `).all(cutoff);
-    if (oldSessions.length === 0) {
-        return 0;
-    }
-    // Delete in correct order to respect FK constraints
-    for (const session of oldSessions) {
-        // 1. Delete from drift_log (FK to session_states)
-        database.prepare('DELETE FROM drift_log WHERE session_id = ?').run(session.session_id);
-        // 2. Delete from steps (FK to session_states)
-        database.prepare('DELETE FROM steps WHERE session_id = ?').run(session.session_id);
-        // 3. Now safe to delete session_states
-        database.prepare('DELETE FROM session_states WHERE session_id = ?').run(session.session_id);
-    }
-    return oldSessions.length;
-}
-/**
- * Get completed session for project (for new_task detection)
- * Returns most recent completed session if exists
- */
-export function getCompletedSessionForProject(projectPath) {
-    const database = initDatabase();
-    const row = database.prepare(`
-    SELECT * FROM session_states
-    WHERE project_path = ? AND status = 'completed'
-    ORDER BY completed_at DESC
-    LIMIT 1
-  `).get(projectPath);
-    return row ? rowToSessionState(row) : null;
-}
+// Re-export from modular store for backward compatibility
+export * from './store/index.js';