grov 0.1.2 → 0.2.2

package/dist/lib/store.js

@@ -61,7 +61,10 @@ export function initDatabase() {
       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,
@@ -74,6 +77,19 @@ export function initDatabase() {
     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 */ }
     // Create session_states table (temporary per-session tracking)
     db.exec(`
     CREATE TABLE IF NOT EXISTS session_states (
@@ -81,18 +97,85 @@ export function initDatabase() {
       user_id TEXT,
       project_path TEXT NOT NULL,
       original_goal TEXT,
-      actions_taken JSON DEFAULT '[]',
-      files_explored JSON DEFAULT '[]',
-      current_intent TEXT,
-      drift_warnings JSON DEFAULT '[]',
+      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'))
+      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')),
+      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 (
@@ -117,51 +200,139 @@ export function initDatabase() {
     // 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('success_criteria')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN success_criteria JSON DEFAULT '[]'`);
-    }
     if (!existingColumns.has('keywords')) {
         db.exec(`ALTER TABLE session_states ADD COLUMN keywords JSON DEFAULT '[]'`);
     }
-    if (!existingColumns.has('last_drift_score')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_drift_score INTEGER`);
-    }
     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 '[]'`);
     }
-    if (!existingColumns.has('last_checked_at')) {
-        db.exec(`ALTER TABLE session_states ADD COLUMN last_checked_at INTEGER DEFAULT 0`);
+    // 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 '[]'`);
     }
-    // Create steps table (Claude's actions for drift detection)
+    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 '[]'`);
+    }
+    // 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,
+      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,
-      is_key_decision BOOLEAN DEFAULT 0,
+      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;
 }
@@ -189,7 +360,10 @@ export function createTask(input) {
         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,
@@ -199,15 +373,17 @@ export function createTask(input) {
     const stmt = database.prepare(`
     INSERT INTO tasks (
       id, project_path, user, original_query, goal,
-      reasoning_trace, files_touched, status, linked_commit,
+      reasoning_trace, files_touched, decisions, constraints,
+      status, trigger_reason, linked_commit,
       parent_task_id, turn_number, tags, created_at
     ) 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), task.status, task.linked_commit || null, task.parent_task_id || null, task.turn_number || null, JSON.stringify(task.tags), task.created_at);
+    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);
     return task;
 }
 /**
@@ -318,7 +494,10 @@ function rowToTask(row) {
         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,
@@ -337,43 +516,50 @@ 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,
-        actions_taken: [],
-        files_explored: [],
-        current_intent: undefined,
-        drift_warnings: [],
+        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',
-        // Drift detection fields
-        expected_scope: input.expected_scope || [],
-        constraints: input.constraints || [],
+        // Hook-specific fields
         success_criteria: input.success_criteria || [],
-        keywords: input.keywords || [],
-        // Drift tracking fields
         last_drift_score: undefined,
-        escalation_count: 0,
         pending_recovery_plan: undefined,
         drift_history: [],
-        // Action tracking
-        last_checked_at: 0
+        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',
     };
-    // Use INSERT OR IGNORE to safely handle race conditions where
-    // multiple processes might try to create the same session
     const stmt = database.prepare(`
     INSERT OR IGNORE INTO session_states (
       session_id, user_id, project_path, original_goal,
-      actions_taken, files_explored, current_intent, drift_warnings,
+      expected_scope, constraints, keywords,
+      token_count, escalation_count, session_mode,
+      waiting_for_recovery, last_checked_at, last_clear_at,
       start_time, last_update, status,
-      expected_scope, constraints, success_criteria, keywords,
-      last_drift_score, escalation_count, pending_recovery_plan, drift_history,
-      last_checked_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      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.actions_taken), JSON.stringify(sessionState.files_explored), sessionState.current_intent || null, JSON.stringify(sessionState.drift_warnings), sessionState.start_time, sessionState.last_update, sessionState.status, JSON.stringify(sessionState.expected_scope), JSON.stringify(sessionState.constraints), JSON.stringify(sessionState.success_criteria), JSON.stringify(sessionState.keywords), sessionState.last_drift_score || null, sessionState.escalation_count, sessionState.pending_recovery_plan ? JSON.stringify(sessionState.pending_recovery_plan) : null, JSON.stringify(sessionState.drift_history), sessionState.last_checked_at);
+    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;
 }
 /**
@@ -405,21 +591,41 @@ export function updateSessionState(sessionId, updates) {
         setClauses.push('original_goal = ?');
         params.push(updates.original_goal || null);
     }
-    if (updates.actions_taken !== undefined) {
-        setClauses.push('actions_taken = ?');
-        params.push(JSON.stringify(updates.actions_taken));
+    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.files_explored !== undefined) {
-        setClauses.push('files_explored = ?');
-        params.push(JSON.stringify(updates.files_explored));
+    if (updates.keywords !== undefined) {
+        setClauses.push('keywords = ?');
+        params.push(JSON.stringify(updates.keywords));
     }
-    if (updates.current_intent !== undefined) {
-        setClauses.push('current_intent = ?');
-        params.push(updates.current_intent || null);
+    if (updates.token_count !== undefined) {
+        setClauses.push('token_count = ?');
+        params.push(updates.token_count);
     }
-    if (updates.drift_warnings !== undefined) {
-        setClauses.push('drift_warnings = ?');
-        params.push(JSON.stringify(updates.drift_warnings));
+    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 = ?');
@@ -454,36 +660,80 @@ export function getActiveSessionsForProject(projectPath) {
     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,
-        actions_taken: safeJsonParse(row.actions_taken, []),
-        files_explored: safeJsonParse(row.files_explored, []),
-        current_intent: row.current_intent,
-        drift_warnings: safeJsonParse(row.drift_warnings, []),
+        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,
-        // Drift detection fields
-        expected_scope: safeJsonParse(row.expected_scope, []),
-        constraints: safeJsonParse(row.constraints, []),
+        // Hook-specific fields
         success_criteria: safeJsonParse(row.success_criteria, []),
-        keywords: safeJsonParse(row.keywords, []),
-        // Drift tracking fields
         last_drift_score: row.last_drift_score,
-        escalation_count: row.escalation_count || 0,
         pending_recovery_plan: safeJsonParse(row.pending_recovery_plan, undefined),
         drift_history: safeJsonParse(row.drift_history, []),
-        // Action tracking
-        last_checked_at: row.last_checked_at || 0
+        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',
     };
 }
+// ============================================
+// DRIFT DETECTION OPERATIONS (hook uses these)
+// ============================================
 /**
  * Update session drift metrics after a prompt check
  */
@@ -510,11 +760,12 @@ export function updateSessionDrift(sessionId, driftScore, correctionLevel, promp
         level: correctionLevel || 'none',
         prompt_summary: promptSummary.substring(0, 100)
     };
-    const newHistory = [...session.drift_history, driftEvent];
+    const newHistory = [...(session.drift_history || []), driftEvent];
     // Add to drift_warnings if correction was given
+    const currentWarnings = session.drift_warnings || [];
     const newWarnings = correctionLevel
-        ? [...session.drift_warnings, `[${now}] ${correctionLevel}: score ${driftScore}`]
-        : session.drift_warnings;
+        ? [...currentWarnings, `[${now}] ${correctionLevel}: score ${driftScore}`]
+        : currentWarnings;
     const stmt = database.prepare(`
     UPDATE session_states SET
       last_drift_score = ?,
@@ -536,19 +787,21 @@ export function shouldFlagForReview(sessionId) {
     if (!session)
         return false;
     // Check number of warnings
-    if (session.drift_warnings.length >= 3) {
+    const warnings = session.drift_warnings || [];
+    if (warnings.length >= 3) {
         return true;
     }
     // Check drift history for average score
-    if (session.drift_history.length >= 2) {
-        const totalScore = session.drift_history.reduce((sum, e) => sum + e.score, 0);
-        const avgScore = totalScore / session.drift_history.length;
+    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 (session.drift_history.some(e => e.level === 'halt')) {
+    if (history.some(e => e.level === 'halt')) {
         return true;
     }
     // Check current escalation level
@@ -562,15 +815,16 @@ export function shouldFlagForReview(sessionId) {
  */
 export function getDriftSummary(sessionId) {
     const session = getSessionState(sessionId);
-    if (!session || session.drift_history.length === 0) {
+    const history = session?.drift_history || [];
+    if (!session || history.length === 0) {
         return { totalEvents: 0, resolved: true, finalScore: null, hadHalt: false };
     }
-    const lastEvent = session.drift_history[session.drift_history.length - 1];
+    const lastEvent = history[history.length - 1];
     return {
-        totalEvents: session.drift_history.length,
+        totalEvents: history.length,
         resolved: lastEvent.score >= 8,
         finalScore: lastEvent.score,
-        hadHalt: session.drift_history.some(e => e.level === 'halt')
+        hadHalt: history.some(e => e.level === 'halt')
     };
 }
 // ============================================
@@ -655,8 +909,143 @@ function rowToFileReasoning(row) {
 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);
+}
+/**
+ * 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
+ * Save a Claude action as a step (hook version - uses ClaudeAction)
  */
 export function saveStep(sessionId, action, driftScore, isKeyDecision = false, keywords = []) {
     const database = initDatabase();
@@ -669,16 +1058,6 @@ export function saveStep(sessionId, action, driftScore, isKeyDecision = false, k
     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);
 }
-/**
- * Get recent steps for a session (most recent first)
- */
-export function getRecentSteps(sessionId, limit = 10) {
-    const database = initDatabase();
-    const rows = database.prepare(`
-    SELECT * FROM steps WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?
-  `).all(sessionId, limit);
-    return rows.map(rowToStepRecord);
-}
 /**
  * Update last_checked_at timestamp for a session
  */
@@ -689,7 +1068,7 @@ export function updateLastChecked(sessionId, timestamp) {
   `).run(timestamp, sessionId);
 }
 // ============================================
-// 4-QUERY RETRIEVAL (from deep_dive.md)
+// 4-QUERY RETRIEVAL (Hook uses these - from deep_dive.md)
 // ============================================
 /**
  * Get steps that touched specific files
@@ -752,7 +1131,32 @@ export function getKeyDecisionSteps(sessionId, limit = 5) {
     return rows.map(rowToStepRecord);
 }
 /**
- * Combined retrieval: runs all 4 queries and deduplicates
+ * Get steps reasoning by file path (for proxy team memory injection)
+ * Searches across ALL sessions, returns file-level reasoning from steps table
+ */
+export function getStepsReasoningByPath(filePath, limit = 5) {
+    const database = initDatabase();
+    // Search steps where files JSON contains this path and reasoning exists
+    const pattern = `%"${escapeLikePattern(filePath)}"%`;
+    const rows = database.prepare(`
+    SELECT files, reasoning
+    FROM steps
+    WHERE files LIKE ? AND reasoning IS NOT NULL AND reasoning != ''
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `).all(pattern, limit);
+    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) {
@@ -774,7 +1178,7 @@ export function getRelevantSteps(sessionId, currentFiles, currentFolders, keywor
     return results;
 }
 /**
- * Convert database row to StepRecord
+ * Convert database row to StepRecord (hook version - basic fields)
  */
 function rowToStepRecord(row) {
     return {
@@ -785,9 +1189,168 @@ function rowToStepRecord(row) {
         folders: safeJsonParse(row.folders, []),
         command: row.command,
         reasoning: row.reasoning,
-        drift_score: row.drift_score,
-        is_key_decision: row.is_key_decision === 1,
+        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;
+}