attocode 0.2.3 → 0.2.5

package/dist/src/integrations/persistence/sqlite-store.js

@@ -0,0 +1,676 @@
+/**
+ * SQLite Session Store
+ *
+ * Alternative backend for session persistence using SQLite.
+ * Provides better query performance and ACID guarantees.
+ *
+ * Implementation is split across repository modules:
+ * - session-repository.ts: Session CRUD, checkpoints, costs, hierarchy, plans, permissions, manifest
+ * - goal-repository.ts: Goals + junctures
+ * - worker-repository.ts: Worker results + artifacts
+ *
+ * @example
+ * ```typescript
+ * const store = await createSQLiteStore({ dbPath: '.agent/sessions.db' });
+ * await store.createSession('My Session');
+ * await store.appendMessage({ role: 'user', content: 'Hello' });
+ * ```
+ */
+import Database from 'better-sqlite3';
+import { join, dirname } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { existsSync, mkdirSync } from 'node:fs';
+import { applyMigrations, getMigrationStatus, detectFeatures, } from '../../persistence/schema.js';
+// Repository modules (extracted implementation)
+import * as sessionRepo from './session-repository.js';
+import * as goalRepo from './goal-repository.js';
+import * as workerRepo from './worker-repository.js';
+import * as codebaseRepo from './codebase-repository.js';
+// =============================================================================
+// SQLITE STORE
+// =============================================================================
+/**
+ * SQLite-backed session store.
+ */
+export class SQLiteStore {
+    db;
+    config;
+    currentSessionId = null;
+    listeners = [];
+    /** Available schema features (detected after migration) */
+    features = {
+        core: false,
+        costs: false,
+        hierarchy: false,
+        compaction: false,
+        fileChanges: false,
+        goals: false,
+        workerResults: false,
+        pendingPlans: false,
+        deadLetterQueue: false,
+        rememberedPermissions: false,
+        codebaseAnalysis: false,
+    };
+    // Prepared statements for performance
+    stmts;
+    constructor(config = {}) {
+        this.config = {
+            baseDir: config.baseDir || '.agent/sessions',
+            dbPath: config.dbPath || join(config.baseDir || '.agent/sessions', 'sessions.db'),
+            autoSave: config.autoSave ?? true,
+            maxSessions: config.maxSessions || 50,
+            walMode: config.walMode ?? true,
+        };
+        // Ensure directory exists BEFORE opening database
+        // (better-sqlite3 requires the parent directory to exist)
+        const dbDir = dirname(this.config.dbPath);
+        if (!existsSync(dbDir)) {
+            mkdirSync(dbDir, { recursive: true });
+        }
+        // Initialize database
+        this.db = new Database(this.config.dbPath);
+        // Enable WAL mode for better concurrent access
+        if (this.config.walMode) {
+            this.db.pragma('journal_mode = WAL');
+        }
+        // Enable foreign keys
+        this.db.pragma('foreign_keys = ON');
+    }
+    /**
+     * Get the deps object for repository modules.
+     */
+    get deps() {
+        return {
+            db: this.db,
+            stmts: this.stmts,
+            features: this.features,
+            config: this.config,
+            getCurrentSessionId: () => this.currentSessionId,
+            setCurrentSessionId: (id) => { this.currentSessionId = id; },
+            emit: (event) => this.emit(event),
+            ensureSession: () => { this.createSession(); },
+        };
+    }
+    /**
+     * Initialize the store (create tables, prepare statements).
+     */
+    async initialize() {
+        // Ensure directory exists
+        const dbDir = dirname(this.config.dbPath);
+        if (!existsSync(dbDir)) {
+            await mkdir(dbDir, { recursive: true });
+        }
+        // Apply embedded migrations (no file I/O needed)
+        const isDebug = process.env.DEBUG || process.argv.includes('--debug');
+        if (isDebug) {
+            const status = getMigrationStatus(this.db);
+            process.stderr.write(`[DEBUG] [SQLite] DB version: ${status.currentVersion}, latest: ${status.latestVersion}, pending: ${status.pendingCount}\n`);
+        }
+        const result = applyMigrations(this.db);
+        if (isDebug && result.applied > 0) {
+            process.stderr.write(`[DEBUG] [SQLite] Applied ${result.applied} migrations: ${result.appliedMigrations.join(', ')}\n`);
+        }
+        // Detect available features after migrations
+        this.features = detectFeatures(this.db);
+        if (isDebug) {
+            const enabled = Object.entries(this.features)
+                .filter(([, v]) => v)
+                .map(([k]) => k);
+            process.stderr.write(`[DEBUG] [SQLite] Features: ${enabled.join(', ')}\n`);
+        }
+        // Prepare statements for available features
+        this.prepareStatements();
+    }
+    /**
+     * Prepare SQL statements for reuse.
+     */
+    prepareStatements() {
+        this.stmts = {
+            insertSession: this.db.prepare(`
+        INSERT INTO sessions (id, name, workspace_path, workspace_fingerprint, created_at, last_active_at, message_count, token_count)
+        VALUES (@id, @name, @workspacePath, @workspaceFingerprint, @createdAt, @lastActiveAt, @messageCount, @tokenCount)
+      `),
+            updateSession: this.db.prepare(`
+        UPDATE sessions SET
+          name = COALESCE(@name, name),
+          last_active_at = COALESCE(@lastActiveAt, last_active_at),
+          message_count = COALESCE(@messageCount, message_count),
+          token_count = COALESCE(@tokenCount, token_count),
+          summary = COALESCE(@summary, summary)
+        WHERE id = @id
+      `),
+            deleteSession: this.db.prepare(`DELETE FROM sessions WHERE id = ?`),
+            getSession: this.db.prepare(`
+        SELECT id, name, created_at as createdAt,
+               workspace_path as workspacePath, workspace_fingerprint as workspaceFingerprint,
+               COALESCE(last_active_at, created_at) as lastActiveAt,
+               message_count as messageCount, token_count as tokenCount, summary,
+               parent_session_id as parentSessionId, session_type as sessionType,
+               prompt_tokens as promptTokens, completion_tokens as completionTokens,
+               cost_usd as costUsd
+        FROM sessions WHERE id = ?
+      `),
+            listSessions: this.db.prepare(`
+        SELECT id, name, created_at as createdAt,
+               workspace_path as workspacePath, workspace_fingerprint as workspaceFingerprint,
+               COALESCE(last_active_at, created_at) as lastActiveAt,
+               message_count as messageCount, token_count as tokenCount, summary,
+               parent_session_id as parentSessionId, session_type as sessionType,
+               prompt_tokens as promptTokens, completion_tokens as completionTokens,
+               cost_usd as costUsd
+        FROM sessions ORDER BY COALESCE(last_active_at, created_at) DESC
+      `),
+            insertEntry: this.db.prepare(`
+        INSERT INTO entries (session_id, timestamp, type, data)
+        VALUES (@sessionId, @timestamp, @type, @data)
+      `),
+            getEntries: this.db.prepare(`
+        SELECT timestamp, type, data FROM entries
+        WHERE session_id = ? ORDER BY id ASC
+      `),
+            insertToolCall: this.db.prepare(`
+        INSERT INTO tool_calls (id, session_id, name, arguments, status, created_at)
+        VALUES (@id, @sessionId, @name, @arguments, @status, @createdAt)
+      `),
+            updateToolCall: this.db.prepare(`
+        UPDATE tool_calls SET
+          status = @status,
+          result = @result,
+          error = @error,
+          duration_ms = @durationMs,
+          completed_at = @completedAt
+        WHERE id = @id
+      `),
+            insertCheckpoint: this.db.prepare(`
+        INSERT INTO checkpoints (id, session_id, state_json, created_at, description)
+        VALUES (@id, @sessionId, @stateJson, @createdAt, @description)
+      `),
+            getLatestCheckpoint: this.db.prepare(`
+        SELECT id, session_id as sessionId, state_json as stateJson,
+               created_at as createdAt, description
+        FROM checkpoints WHERE session_id = ?
+        ORDER BY created_at DESC, rowid DESC LIMIT 1
+      `),
+            // Cost tracking statements
+            insertUsageLog: this.db.prepare(`
+        INSERT INTO usage_logs (session_id, model_id, prompt_tokens, completion_tokens, cost_usd, timestamp)
+        VALUES (@sessionId, @modelId, @promptTokens, @completionTokens, @costUsd, @timestamp)
+      `),
+            updateSessionCosts: this.db.prepare(`
+        UPDATE sessions SET
+          prompt_tokens = COALESCE(prompt_tokens, 0) + @promptTokens,
+          completion_tokens = COALESCE(completion_tokens, 0) + @completionTokens,
+          cost_usd = COALESCE(cost_usd, 0) + @costUsd
+        WHERE id = @sessionId
+      `),
+            getSessionUsage: this.db.prepare(`
+        SELECT
+          COALESCE(SUM(prompt_tokens), 0) as promptTokens,
+          COALESCE(SUM(completion_tokens), 0) as completionTokens,
+          COALESCE(SUM(cost_usd), 0) as costUsd
+        FROM usage_logs WHERE session_id = ?
+      `),
+            // Session hierarchy statements
+            insertChildSession: this.db.prepare(`
+        INSERT INTO sessions (id, name, workspace_path, workspace_fingerprint, created_at, last_active_at, message_count, token_count, parent_session_id, session_type)
+        VALUES (@id, @name, @workspacePath, @workspaceFingerprint, @createdAt, @lastActiveAt, @messageCount, @tokenCount, @parentSessionId, @sessionType)
+      `),
+            getChildSessions: this.db.prepare(`
+        SELECT id, name, created_at as createdAt, last_active_at as lastActiveAt,
+               workspace_path as workspacePath, workspace_fingerprint as workspaceFingerprint,
+               message_count as messageCount, token_count as tokenCount, summary,
+               parent_session_id as parentSessionId, session_type as sessionType,
+               prompt_tokens as promptTokens, completion_tokens as completionTokens,
+               cost_usd as costUsd
+        FROM sessions WHERE parent_session_id = ?
+        ORDER BY created_at ASC
+      `),
+            getSessionTree: this.db.prepare(`
+        WITH RECURSIVE session_tree AS (
+          SELECT id, name, created_at as createdAt, last_active_at as lastActiveAt,
+                 workspace_path as workspacePath, workspace_fingerprint as workspaceFingerprint,
+                 message_count as messageCount, token_count as tokenCount, summary,
+                 parent_session_id as parentSessionId, session_type as sessionType,
+                 prompt_tokens as promptTokens, completion_tokens as completionTokens,
+                 cost_usd as costUsd, 0 as depth
+          FROM sessions WHERE id = ?
+          UNION ALL
+          SELECT s.id, s.name, s.created_at, s.last_active_at,
+                 s.workspace_path, s.workspace_fingerprint,
+                 s.message_count, s.token_count, s.summary,
+                 s.parent_session_id, s.session_type,
+                 s.prompt_tokens, s.completion_tokens,
+                 s.cost_usd, st.depth + 1
+          FROM sessions s
+          INNER JOIN session_tree st ON s.parent_session_id = st.id
+        )
+        SELECT * FROM session_tree ORDER BY depth, createdAt ASC
+      `),
+        };
+        // Goal integrity statements - only prepare if feature is available
+        if (this.features.goals) {
+            this.stmts.insertGoal = this.db.prepare(`
+        INSERT INTO goals (id, session_id, goal_text, status, priority, parent_goal_id,
+                          progress_current, progress_total, created_at, updated_at, metadata)
+        VALUES (@id, @sessionId, @goalText, @status, @priority, @parentGoalId,
+                @progressCurrent, @progressTotal, @createdAt, @updatedAt, @metadata)
+      `);
+            this.stmts.updateGoal = this.db.prepare(`
+        UPDATE goals SET
+          goal_text = COALESCE(@goalText, goal_text),
+          status = COALESCE(@status, status),
+          priority = COALESCE(@priority, priority),
+          progress_current = COALESCE(@progressCurrent, progress_current),
+          progress_total = COALESCE(@progressTotal, progress_total),
+          updated_at = @updatedAt,
+          completed_at = @completedAt,
+          metadata = COALESCE(@metadata, metadata)
+        WHERE id = @id
+      `);
+            this.stmts.getGoal = this.db.prepare(`
+        SELECT id, session_id as sessionId, goal_text as goalText, status, priority,
+               parent_goal_id as parentGoalId, progress_current as progressCurrent,
+               progress_total as progressTotal, created_at as createdAt,
+               updated_at as updatedAt, completed_at as completedAt, metadata
+        FROM goals WHERE id = ?
+      `);
+            this.stmts.listGoals = this.db.prepare(`
+        SELECT id, session_id as sessionId, goal_text as goalText, status, priority,
+               parent_goal_id as parentGoalId, progress_current as progressCurrent,
+               progress_total as progressTotal, created_at as createdAt,
+               updated_at as updatedAt, completed_at as completedAt, metadata
+        FROM goals WHERE session_id = ? ORDER BY priority ASC, created_at ASC
+      `);
+            this.stmts.listActiveGoals = this.db.prepare(`
+        SELECT id, session_id as sessionId, goal_text as goalText, status, priority,
+               parent_goal_id as parentGoalId, progress_current as progressCurrent,
+               progress_total as progressTotal, created_at as createdAt,
+               updated_at as updatedAt, completed_at as completedAt, metadata
+        FROM goals WHERE session_id = ? AND status = 'active'
+        ORDER BY priority ASC, created_at ASC
+      `);
+            this.stmts.insertJuncture = this.db.prepare(`
+        INSERT INTO junctures (session_id, goal_id, type, description, outcome,
+                               importance, context, created_at)
+        VALUES (@sessionId, @goalId, @type, @description, @outcome,
+                @importance, @context, @createdAt)
+      `);
+            this.stmts.listJunctures = this.db.prepare(`
+        SELECT id, session_id as sessionId, goal_id as goalId, type, description,
+               outcome, importance, context, created_at as createdAt
+        FROM junctures WHERE session_id = ? ORDER BY created_at DESC
+      `);
+        }
+        // Worker result statements - only prepare if feature is available
+        if (this.features.workerResults) {
+            this.stmts.insertWorkerResult = this.db.prepare(`
+        INSERT INTO worker_results (id, session_id, worker_id, task_description, model_used,
+                                    status, summary, full_output, artifacts, metrics, error,
+                                    created_at, completed_at)
+        VALUES (@id, @sessionId, @workerId, @taskDescription, @modelUsed,
+                @status, @summary, @fullOutput, @artifacts, @metrics, @error,
+                @createdAt, @completedAt)
+      `);
+            this.stmts.updateWorkerResult = this.db.prepare(`
+        UPDATE worker_results SET
+          status = COALESCE(@status, status),
+          summary = COALESCE(@summary, summary),
+          full_output = COALESCE(@fullOutput, full_output),
+          artifacts = COALESCE(@artifacts, artifacts),
+          metrics = COALESCE(@metrics, metrics),
+          error = @error,
+          completed_at = @completedAt
+        WHERE id = @id
+      `);
+            this.stmts.getWorkerResult = this.db.prepare(`
+        SELECT id, session_id as sessionId, worker_id as workerId,
+               task_description as taskDescription, model_used as modelUsed,
+               status, summary, full_output as fullOutput, artifacts, metrics,
+               error, created_at as createdAt, completed_at as completedAt
+        FROM worker_results WHERE id = ?
+      `);
+            this.stmts.listWorkerResults = this.db.prepare(`
+        SELECT id, session_id as sessionId, worker_id as workerId,
+               task_description as taskDescription, model_used as modelUsed,
+               status, summary, full_output as fullOutput, artifacts, metrics,
+               error, created_at as createdAt, completed_at as completedAt
+        FROM worker_results WHERE session_id = ?
+        ORDER BY created_at DESC
+      `);
+            this.stmts.listPendingWorkerResults = this.db.prepare(`
+        SELECT id, session_id as sessionId, worker_id as workerId,
+               task_description as taskDescription, model_used as modelUsed,
+               status, summary, created_at as createdAt
+        FROM worker_results WHERE session_id = ? AND status = 'pending'
+        ORDER BY created_at ASC
+      `);
+        }
+        // Pending plan statements (optional - only if pendingPlans feature available)
+        if (this.features.pendingPlans) {
+            this.stmts.insertPendingPlan = this.db.prepare(`
+        INSERT INTO pending_plans (id, session_id, task, proposed_changes, exploration_summary, status, created_at, updated_at)
+        VALUES (@id, @sessionId, @task, @proposedChanges, @explorationSummary, @status, @createdAt, @updatedAt)
+      `);
+            this.stmts.updatePendingPlan = this.db.prepare(`
+        UPDATE pending_plans SET
+          proposed_changes = @proposedChanges,
+          exploration_summary = @explorationSummary,
+          status = @status,
+          updated_at = @updatedAt
+        WHERE id = @id
+      `);
+            this.stmts.getPendingPlan = this.db.prepare(`
+        SELECT id, session_id as sessionId, task, proposed_changes as proposedChanges,
+               exploration_summary as explorationSummary, status, created_at as createdAt, updated_at as updatedAt
+        FROM pending_plans WHERE session_id = ? AND status = 'pending'
+        ORDER BY created_at DESC LIMIT 1
+      `);
+            this.stmts.deletePendingPlan = this.db.prepare(`
+        DELETE FROM pending_plans WHERE id = ?
+      `);
+        }
+        // Remembered permissions statements (optional - only if feature available)
+        if (this.features.rememberedPermissions) {
+            this.stmts.insertRememberedPermission = this.db.prepare(`
+        INSERT OR REPLACE INTO remembered_permissions (tool_name, pattern, decision, created_at)
+        VALUES (@toolName, @pattern, @decision, @createdAt)
+      `);
+            this.stmts.getRememberedPermission = this.db.prepare(`
+        SELECT tool_name as toolName, pattern, decision, created_at as createdAt
+        FROM remembered_permissions
+        WHERE tool_name = ? AND (pattern = ? OR pattern IS NULL)
+        ORDER BY pattern IS NULL ASC
+        LIMIT 1
+      `);
+            this.stmts.listRememberedPermissions = this.db.prepare(`
+        SELECT tool_name as toolName, pattern, decision, created_at as createdAt
+        FROM remembered_permissions
+        ORDER BY tool_name, pattern
+      `);
+            this.stmts.deleteRememberedPermission = this.db.prepare(`
+        DELETE FROM remembered_permissions WHERE tool_name = ? AND (pattern = ? OR (? IS NULL AND pattern IS NULL))
+      `);
+        }
+    }
+    // ===========================================================================
+    // SESSION MANAGEMENT (delegates to session-repository.ts)
+    // ===========================================================================
+    createSession(name) {
+        return sessionRepo.createSession(this.deps, name);
+    }
+    getCurrentSessionId() {
+        return this.currentSessionId;
+    }
+    setCurrentSessionId(sessionId) {
+        this.currentSessionId = sessionId;
+    }
+    appendEntry(entry) {
+        sessionRepo.appendEntry(this.deps, entry);
+    }
+    appendMessage(message) {
+        sessionRepo.appendMessage(this.deps, message);
+    }
+    appendToolCall(toolCall) {
+        sessionRepo.appendToolCall(this.deps, toolCall);
+    }
+    appendToolResult(callId, result) {
+        sessionRepo.appendToolResult(this.deps, callId, result);
+    }
+    appendCompaction(summary, compactedCount) {
+        sessionRepo.appendCompaction(this.deps, summary, compactedCount);
+    }
+    loadSession(sessionId) {
+        return sessionRepo.loadSession(this.deps, sessionId);
+    }
+    loadSessionMessages(sessionId) {
+        return sessionRepo.loadSessionMessages(this.deps, sessionId);
+    }
+    deleteSession(sessionId) {
+        sessionRepo.deleteSession(this.deps, sessionId);
+    }
+    listSessions() {
+        return sessionRepo.listSessions(this.deps);
+    }
+    getRecentSession() {
+        return sessionRepo.getRecentSession(this.deps);
+    }
+    getSessionMetadata(sessionId) {
+        return sessionRepo.getSessionMetadata(this.deps, sessionId);
+    }
+    updateSessionMetadata(sessionId, updates) {
+        sessionRepo.updateSessionMetadata(this.deps, sessionId, updates);
+    }
+    // ===========================================================================
+    // SQLITE-SPECIFIC FEATURES (delegates to session-repository.ts)
+    // ===========================================================================
+    saveCheckpoint(state, description) {
+        return sessionRepo.saveCheckpoint(this.deps, state, description);
+    }
+    loadLatestCheckpoint(sessionId) {
+        return sessionRepo.loadLatestCheckpoint(this.deps, sessionId);
+    }
+    query(sql, params = []) {
+        return sessionRepo.query(this.deps, sql, params);
+    }
+    getStats() {
+        return sessionRepo.getStats(this.deps);
+    }
+    getDatabase() {
+        return this.db;
+    }
+    // ===========================================================================
+    // COST TRACKING (delegates to session-repository.ts)
+    // ===========================================================================
+    logUsage(usage) {
+        sessionRepo.logUsage(this.deps, usage);
+    }
+    getSessionUsage(sessionId) {
+        return sessionRepo.getSessionUsage(this.deps, sessionId);
+    }
+    // ===========================================================================
+    // SESSION HIERARCHY (delegates to session-repository.ts)
+    // ===========================================================================
+    createChildSession(parentId, name, type = 'subagent') {
+        return sessionRepo.createChildSession(this.deps, parentId, name, type);
+    }
+    getChildSessions(parentId) {
+        return sessionRepo.getChildSessions(this.deps, parentId);
+    }
+    getSessionTree(rootId) {
+        return sessionRepo.getSessionTree(this.deps, rootId);
+    }
+    // ===========================================================================
+    // GOAL INTEGRITY (delegates to goal-repository.ts)
+    // ===========================================================================
+    hasGoalsFeature() {
+        return this.features.goals;
+    }
+    createGoal(goalText, options = {}) {
+        return goalRepo.createGoal(this.deps, goalText, options);
+    }
+    updateGoal(goalId, updates) {
+        goalRepo.updateGoal(this.deps, goalId, updates);
+    }
+    completeGoal(goalId) {
+        goalRepo.completeGoal(this.deps, goalId);
+    }
+    getGoal(goalId) {
+        return goalRepo.getGoal(this.deps, goalId);
+    }
+    listGoals(sessionId) {
+        return goalRepo.listGoals(this.deps, sessionId);
+    }
+    listActiveGoals(sessionId) {
+        return goalRepo.listActiveGoals(this.deps, sessionId);
+    }
+    getGoalsSummary(sessionId) {
+        return goalRepo.getGoalsSummary(this.deps, sessionId);
+    }
+    logJuncture(type, description, options = {}) {
+        return goalRepo.logJuncture(this.deps, type, description, options);
+    }
+    listJunctures(sessionId, limit) {
+        return goalRepo.listJunctures(this.deps, sessionId, limit);
+    }
+    getJuncturesSummary(sessionId, limit = 5) {
+        return goalRepo.getJuncturesSummary(this.deps, sessionId, limit);
+    }
+    // ===========================================================================
+    // WORKER RESULTS (delegates to worker-repository.ts)
+    // ===========================================================================
+    hasWorkerResultsFeature() {
+        return this.features.workerResults;
+    }
+    createWorkerResult(workerId, taskDescription, modelUsed) {
+        return workerRepo.createWorkerResult(this.deps, workerId, taskDescription, modelUsed);
+    }
+    completeWorkerResult(resultId, output) {
+        return workerRepo.completeWorkerResult(this.deps, resultId, output);
+    }
+    failWorkerResult(resultId, error) {
+        workerRepo.failWorkerResult(this.deps, resultId, error);
+    }
+    getWorkerResult(resultId) {
+        return workerRepo.getWorkerResult(this.deps, resultId);
+    }
+    getWorkerResultRef(resultId) {
+        return workerRepo.getWorkerResultRef(this.deps, resultId);
+    }
+    listWorkerResults(sessionId) {
+        return workerRepo.listWorkerResults(this.deps, sessionId);
+    }
+    listPendingWorkerResults(sessionId) {
+        return workerRepo.listPendingWorkerResults(this.deps, sessionId);
+    }
+    getWorkerResultsSummary(sessionId) {
+        return workerRepo.getWorkerResultsSummary(this.deps, sessionId);
+    }
+    // ===========================================================================
+    // PENDING PLANS (delegates to session-repository.ts)
+    // ===========================================================================
+    hasPendingPlansFeature() {
+        return this.features.pendingPlans;
+    }
+    savePendingPlan(plan, sessionId) {
+        sessionRepo.savePendingPlan(this.deps, plan, sessionId);
+    }
+    getPendingPlan(sessionId) {
+        return sessionRepo.getPendingPlan(this.deps, sessionId);
+    }
+    updatePlanStatus(planId, status) {
+        sessionRepo.updatePlanStatus(this.deps, planId, status);
+    }
+    deletePendingPlan(planId) {
+        sessionRepo.deletePendingPlan(this.deps, planId);
+    }
+    // ===========================================================================
+    // SESSION MANIFEST (delegates to session-repository.ts)
+    // ===========================================================================
+    exportSessionManifest(sessionId) {
+        return sessionRepo.exportSessionManifest(this.deps, this.manifestCallbacks, sessionId);
+    }
+    exportSessionMarkdown(sessionId) {
+        return sessionRepo.exportSessionMarkdown(this.deps, this.manifestCallbacks, sessionId);
+    }
+    /** Callbacks for manifest export (bridges to goal/worker repositories). */
+    get manifestCallbacks() {
+        return {
+            listGoals: (sid) => this.listGoals(sid),
+            listJunctures: (sid, limit) => this.listJunctures(sid, limit),
+            listWorkerResults: (sid) => this.listWorkerResults(sid),
+        };
+    }
+    // ===========================================================================
+    // MIGRATION (delegates to session-repository.ts)
+    // ===========================================================================
+    async migrateFromJSONL(jsonlDir) {
+        return sessionRepo.migrateFromJSONL(this.deps, jsonlDir);
+    }
+    // ===========================================================================
+    // REMEMBERED PERMISSIONS (delegates to session-repository.ts)
+    // ===========================================================================
+    hasRememberedPermissionsFeature() {
+        return this.features.rememberedPermissions;
+    }
+    rememberPermission(toolName, decision, pattern) {
+        sessionRepo.rememberPermission(this.deps, toolName, decision, pattern);
+    }
+    getRememberedPermission(toolName, pattern) {
+        return sessionRepo.getRememberedPermission(this.deps, toolName, pattern);
+    }
+    listRememberedPermissions() {
+        return sessionRepo.listRememberedPermissions(this.deps);
+    }
+    forgetPermission(toolName, pattern) {
+        sessionRepo.forgetPermission(this.deps, toolName, pattern);
+    }
+    clearRememberedPermissions(toolName) {
+        sessionRepo.clearRememberedPermissions(this.deps, toolName);
+    }
+    // ===========================================================================
+    // LIFECYCLE
+    // ===========================================================================
+    /**
+     * Subscribe to events.
+     */
+    on(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const idx = this.listeners.indexOf(listener);
+            if (idx >= 0)
+                this.listeners.splice(idx, 1);
+        };
+    }
+    /**
+     * Emit an event.
+     */
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Ignore listener errors
+            }
+        }
+    }
+    /**
+     * Close the database connection.
+     */
+    close() {
+        this.db.close();
+    }
+    // ===========================================================================
+    // CODEBASE ANALYSIS PERSISTENCE
+    // ===========================================================================
+    /**
+     * Save codebase analysis to SQLite for warm startup next session.
+     */
+    saveCodebaseAnalysis(root, chunks, dependencyGraph) {
+        codebaseRepo.saveCodebaseAnalysis(this.deps, root, chunks, dependencyGraph);
+    }
+    /**
+     * Load persisted codebase analysis from SQLite.
+     */
+    loadCodebaseAnalysis(root) {
+        return codebaseRepo.loadCodebaseAnalysis(this.deps, root);
+    }
+    /**
+     * Cleanup - same as close for compatibility.
+     */
+    async cleanup() {
+        this.close();
+    }
+}
+// =============================================================================
+// FACTORY
+// =============================================================================
+/**
+ * Create and initialize a SQLite session store.
+ */
+export async function createSQLiteStore(config) {
+    const store = new SQLiteStore(config);
+    await store.initialize();
+    return store;
+}
+//# sourceMappingURL=sqlite-store.js.map