grov 0.2.3 → 0.5.3

package/dist/lib/store/convenience.d.ts

@@ -0,0 +1,40 @@
+import type { SessionMode } from './types.js';
+/**
+ * Update token count for a session
+ */
+export declare function updateTokenCount(sessionId: string, tokenCount: number): void;
+/**
+ * Update session mode
+ */
+export declare function updateSessionMode(sessionId: string, mode: SessionMode): void;
+/**
+ * Mark session as waiting for recovery
+ */
+export declare function markWaitingForRecovery(sessionId: string, waiting: boolean): void;
+/**
+ * Increment escalation count
+ */
+export declare function incrementEscalation(sessionId: string): void;
+/**
+ * Update last clear timestamp and reset token count
+ */
+export declare function markCleared(sessionId: string): void;
+/**
+ * Mark session as completed (instead of deleting)
+ * Session will be cleaned up after 1 hour
+ */
+export declare function markSessionCompleted(sessionId: string): void;
+/**
+ * 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 declare function cleanupOldCompletedSessions(maxAgeMs?: number): number;
+/**
+ * Cleanup stale active sessions (no activity for maxAgeMs)
+ * Marks them as 'abandoned' so they won't be picked up by getActiveSessionForUser
+ * This prevents old sessions from being reused in fresh Claude sessions
+ * Returns number of sessions marked as abandoned
+ */
+export declare function cleanupStaleActiveSessions(maxAgeMs?: number): number;

package/dist/lib/store/convenience.js

@@ -0,0 +1,104 @@
+// Convenience wrappers and cleanup functions
+import { getDb } from './database.js';
+import { getSessionState, updateSessionState } from './sessions.js';
+/**
+ * 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 = getDb();
+    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 = getDb();
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    // Get sessions to cleanup, excluding those with active children
+    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;
+}
+/**
+ * Cleanup stale active sessions (no activity for maxAgeMs)
+ * Marks them as 'abandoned' so they won't be picked up by getActiveSessionForUser
+ * This prevents old sessions from being reused in fresh Claude sessions
+ * Returns number of sessions marked as abandoned
+ */
+export function cleanupStaleActiveSessions(maxAgeMs = 3600000) {
+    const database = getDb();
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const now = new Date().toISOString();
+    const result = database.prepare(`
+    UPDATE session_states
+    SET status = 'abandoned', completed_at = ?
+    WHERE status = 'active' AND last_update < ?
+  `).run(now, cutoff);
+    return result.changes;
+}

package/dist/lib/store/database.d.ts

@@ -0,0 +1,22 @@
+import Database from 'better-sqlite3';
+/**
+ * Safely parse JSON with fallback to provided default.
+ */
+export declare function safeJsonParse<T>(value: unknown, fallback: T): T;
+/**
+ * Get the database path
+ */
+export declare function getDatabasePath(): string;
+/**
+ * Get initialized database connection.
+ * Internal helper for other store modules.
+ */
+export declare function getDb(): Database.Database;
+/**
+ * Initialize the database connection and create tables
+ */
+export declare function initDatabase(): Database.Database;
+/**
+ * Close the database connection
+ */
+export declare function closeDatabase(): void;

package/dist/lib/store/database.js

@@ -0,0 +1,375 @@
+// Database connection, schema, and utilities
+import Database from 'better-sqlite3';
+import { existsSync, mkdirSync, chmodSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const GROV_DIR = join(homedir(), '.grov');
+const DB_PATH = join(GROV_DIR, 'memory.db');
+let db = null;
+/**
+ * Escape LIKE pattern special characters to prevent SQL injection.
+ * SECURITY: Prevents wildcard injection in LIKE queries.
+ */
+function escapeLikePattern(str) {
+    return str.replace(/[%_\\]/g, '\\$&');
+}
+/**
+ * Safely parse JSON with fallback to provided default.
+ */
+export function safeJsonParse(value, fallback) {
+    if (typeof value !== 'string' || !value) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Get the database path
+ */
+export function getDatabasePath() {
+    return DB_PATH;
+}
+/**
+ * Get initialized database connection.
+ * Internal helper for other store modules.
+ */
+export function getDb() {
+    return initDatabase();
+}
+/**
+ * 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 {
+        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);
+    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
+    const columns = db.pragma('table_info(session_states)');
+    const existingColumns = new Set(columns.map(c => c.name));
+    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`);
+    }
+    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 '[]'`);
+    }
+    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'`);
+    }
+    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;
+    }
+}

package/dist/lib/store/drift.d.ts

@@ -0,0 +1,9 @@
+import type { DriftLogEntry, CreateDriftLogInput, CorrectionLevel, RecoveryPlan } from './types.js';
+/**
+ * Update session drift metrics after a prompt check
+ */
+export declare function updateSessionDrift(sessionId: string, driftScore: number, correctionLevel: CorrectionLevel | null, promptSummary: string, recoveryPlan?: RecoveryPlan): void;
+/**
+ * Log a drift event (for rejected actions)
+ */
+export declare function logDriftEvent(input: CreateDriftLogInput): DriftLogEntry;

package/dist/lib/store/drift.js

@@ -0,0 +1,89 @@
+// Drift detection and drift log operations
+import { randomUUID } from 'crypto';
+import { getDb, safeJsonParse } from './database.js';
+import { getSessionState } from './sessions.js';
+/**
+ * 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
+    };
+}
+/**
+ * Update session drift metrics after a prompt check
+ */
+export function updateSessionDrift(sessionId, driftScore, correctionLevel, promptSummary, recoveryPlan) {
+    const database = getDb();
+    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);
+}
+/**
+ * Log a drift event (for rejected actions)
+ */
+export function logDriftEvent(input) {
+    const database = getDb();
+    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;
+}

package/dist/lib/store/index.d.ts

@@ -0,0 +1,7 @@
+export type { TaskStatus, TriggerReason, SessionStatus, SessionMode, TaskType, StepActionType, DriftType, CorrectionLevel, Task, CreateTaskInput, RecoveryPlan, DriftEvent, SessionState, CreateSessionStateInput, StepRecord, CreateStepInput, DriftLogEntry, CreateDriftLogInput, } from './types.js';
+export { initDatabase, closeDatabase, getDatabasePath } from './database.js';
+export { createTask, getTasksForProject, getTaskCount, getUnsyncedTasks, markTaskSynced, setTaskSyncError } from './tasks.js';
+export { createSessionState, getSessionState, updateSessionState, deleteSessionState, getActiveSessionForUser, getActiveSessionsForStatus, getCompletedSessionForProject } from './sessions.js';
+export { createStep, getStepsForSession, getRecentSteps, getValidatedSteps, getKeyDecisions, getEditedFiles, deleteStepsForSession, updateRecentStepsReasoning, updateLastChecked } from './steps.js';
+export { updateSessionDrift, logDriftEvent } from './drift.js';
+export { updateTokenCount, updateSessionMode, markWaitingForRecovery, incrementEscalation, markCleared, markSessionCompleted, cleanupOldCompletedSessions, cleanupStaleActiveSessions } from './convenience.js';

package/dist/lib/store/index.js

@@ -0,0 +1,13 @@
+// Store module - barrel exports for backward compatibility
+// Re-export database functions
+export { initDatabase, closeDatabase, getDatabasePath } from './database.js';
+// Re-export task functions
+export { createTask, getTasksForProject, getTaskCount, getUnsyncedTasks, markTaskSynced, setTaskSyncError } from './tasks.js';
+// Re-export session functions
+export { createSessionState, getSessionState, updateSessionState, deleteSessionState, getActiveSessionForUser, getActiveSessionsForStatus, getCompletedSessionForProject } from './sessions.js';
+// Re-export step functions
+export { createStep, getStepsForSession, getRecentSteps, getValidatedSteps, getKeyDecisions, getEditedFiles, deleteStepsForSession, updateRecentStepsReasoning, updateLastChecked } from './steps.js';
+// Re-export drift functions
+export { updateSessionDrift, logDriftEvent } from './drift.js';
+// Re-export convenience functions
+export { updateTokenCount, updateSessionMode, markWaitingForRecovery, incrementEscalation, markCleared, markSessionCompleted, cleanupOldCompletedSessions, cleanupStaleActiveSessions } from './convenience.js';