kotadb 2.2.0-next.20260204184036 → 2.2.0-next.20260204230500

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kotadb",
-  "version": "2.2.0-next.20260204184036",
+  "version": "2.2.0-next.20260204230500",
   "description": "Local-only code intelligence tool for CLI agents. SQLite-backed repository indexing and code search via MCP.",
   "type": "module",
   "module": "src/index.ts",

package/src/db/migrations/004_memory_layer.sql

@@ -3,181 +3,53 @@
 -- Migration: 004_memory_layer
 -- Issue: Memory Layer for Agent Intelligence
 -- Author: Claude Code
--- Date: 2026-02-03
+-- Date: 2026-02-03 (UPDATED: 2026-02-04)
 --
--- This migration extends the memory layer tables with additional schema:
--- - decisions: Add status column (active, superseded, deprecated)
--- - failed_approaches: Alternative to failures with clearer naming
--- - pattern_annotations: Enhanced patterns with evidence/confidence scoring
--- - agent_sessions: Track agent work sessions
--- - session_insights: Insights linked to sessions with file references
+-- This migration extends the memory layer with:
+-- - decisions.status column (active, superseded, deprecated)
+-- - agent_sessions table for tracking agent work
 --
 -- Note: The base sqlite-schema.sql already has decisions, failures, patterns,
--- and insights tables. This migration adds enhanced versions and the missing
--- agent_sessions table for complete session tracking.
+-- and insights tables. This migration only adds what's missing.
 
 -- ============================================================================
 -- 1. Extend Decisions Table - Add status column
 -- ============================================================================
 -- Add status column to track decision lifecycle
+-- Note: SQLite ALTER TABLE ADD COLUMN will fail if column exists,
+-- which is the expected behavior (migration already applied)
 
 ALTER TABLE decisions ADD COLUMN status TEXT DEFAULT 'active';
 
--- Add index for active decisions (most common query)
 CREATE INDEX IF NOT EXISTS idx_decisions_status ON decisions(status) WHERE status = 'active';
 
 -- ============================================================================
--- 2. Failed Approaches Table (alternative to failures with clearer naming)
--- ============================================================================
--- Tracks what didn't work to prevent repeating mistakes
-
-CREATE TABLE IF NOT EXISTS failed_approaches (
-    id TEXT PRIMARY KEY,                         -- uuid → TEXT
-    repository_id TEXT NOT NULL,                 -- Foreign key to repositories
-    title TEXT NOT NULL,                         -- Short description
-    problem TEXT NOT NULL,                       -- What problem was being solved
-    approach TEXT NOT NULL,                      -- What was tried
-    failure_reason TEXT NOT NULL,                -- Why it failed
-    related_files TEXT,                          -- JSON array of related file paths
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
-    
-    FOREIGN KEY (repository_id) REFERENCES repositories(id) ON DELETE CASCADE
-);
-
--- Indexes for common queries
-CREATE INDEX IF NOT EXISTS idx_failed_approaches_repository_id ON failed_approaches(repository_id);
-CREATE INDEX IF NOT EXISTS idx_failed_approaches_created_at ON failed_approaches(created_at DESC);
-
--- ============================================================================
--- 3. Failed Approaches FTS5 Virtual Table
--- ============================================================================
--- External content FTS5 for searching failed approaches
-
-CREATE VIRTUAL TABLE IF NOT EXISTS failed_approaches_fts USING fts5(
-    title,
-    problem,
-    approach,
-    failure_reason,
-    content='failed_approaches',
-    content_rowid='rowid'
-);
-
--- ============================================================================
--- 4. Failed Approaches FTS5 Sync Triggers
--- ============================================================================
-
--- After INSERT: Add new failed approach to FTS index
-CREATE TRIGGER IF NOT EXISTS failed_approaches_fts_ai 
-AFTER INSERT ON failed_approaches 
-BEGIN
-    INSERT INTO failed_approaches_fts(rowid, title, problem, approach, failure_reason) 
-    VALUES (new.rowid, new.title, new.problem, new.approach, new.failure_reason);
-END;
-
--- After DELETE: Remove failed approach from FTS index
-CREATE TRIGGER IF NOT EXISTS failed_approaches_fts_ad 
-AFTER DELETE ON failed_approaches 
-BEGIN
-    INSERT INTO failed_approaches_fts(failed_approaches_fts, rowid, title, problem, approach, failure_reason) 
-    VALUES ('delete', old.rowid, old.title, old.problem, old.approach, old.failure_reason);
-END;
-
--- After UPDATE: Update failed approach in FTS index (delete old, insert new)
-CREATE TRIGGER IF NOT EXISTS failed_approaches_fts_au 
-AFTER UPDATE ON failed_approaches 
-BEGIN
-    INSERT INTO failed_approaches_fts(failed_approaches_fts, rowid, title, problem, approach, failure_reason) 
-    VALUES ('delete', old.rowid, old.title, old.problem, old.approach, old.failure_reason);
-    INSERT INTO failed_approaches_fts(rowid, title, problem, approach, failure_reason) 
-    VALUES (new.rowid, new.title, new.problem, new.approach, new.failure_reason);
-END;
-
--- ============================================================================
--- 5. Pattern Annotations Table
--- ============================================================================
--- Enhanced pattern detection with evidence counting and confidence scoring
-
-CREATE TABLE IF NOT EXISTS pattern_annotations (
-    id TEXT PRIMARY KEY,                         -- uuid → TEXT
-    repository_id TEXT NOT NULL,                 -- Foreign key to repositories
-    pattern_type TEXT NOT NULL,                  -- Pattern category (logging, error-handling, testing, etc.)
-    pattern_name TEXT NOT NULL,                  -- Pattern identifier
-    description TEXT NOT NULL,                   -- Human-readable description
-    example_code TEXT,                           -- Code example (optional)
-    evidence_count INTEGER NOT NULL DEFAULT 1,   -- Number of occurrences found
-    confidence REAL NOT NULL DEFAULT 1.0,        -- Confidence score (0.0-1.0)
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
-    
-    FOREIGN KEY (repository_id) REFERENCES repositories(id) ON DELETE CASCADE,
-    
-    CHECK (confidence >= 0.0 AND confidence <= 1.0),
-    CHECK (evidence_count >= 1)
-);
-
--- Indexes for common queries
-CREATE INDEX IF NOT EXISTS idx_pattern_annotations_repository_id ON pattern_annotations(repository_id);
-CREATE INDEX IF NOT EXISTS idx_pattern_annotations_pattern_type ON pattern_annotations(pattern_type);
-CREATE INDEX IF NOT EXISTS idx_pattern_annotations_confidence ON pattern_annotations(confidence DESC);
--- Composite index for high-confidence patterns by type
-CREATE INDEX IF NOT EXISTS idx_pattern_annotations_type_confidence 
-ON pattern_annotations(repository_id, pattern_type, confidence DESC);
-
--- ============================================================================
--- 6. Agent Sessions Table
+-- 2. Agent Sessions Table
 -- ============================================================================
 -- Tracks agent work sessions for learning and analysis
 
 CREATE TABLE IF NOT EXISTS agent_sessions (
-    id TEXT PRIMARY KEY,                         -- uuid → TEXT
-    repository_id TEXT NOT NULL,                 -- Foreign key to repositories
-    agent_type TEXT,                             -- Type of agent (plan, build, improve, etc.)
-    task_summary TEXT,                           -- What the agent was working on
-    outcome TEXT,                                -- Session outcome
-    files_modified TEXT,                         -- JSON array of modified file paths
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    agent_type TEXT,
+    task_summary TEXT,
+    outcome TEXT,
+    files_modified TEXT,
     started_at TEXT NOT NULL DEFAULT (datetime('now')),
-    ended_at TEXT,                               -- NULL if session is ongoing
+    ended_at TEXT,
     
     FOREIGN KEY (repository_id) REFERENCES repositories(id) ON DELETE CASCADE,
-    
     CHECK (outcome IS NULL OR outcome IN ('success', 'failure', 'partial'))
 );
 
--- Indexes for common queries
 CREATE INDEX IF NOT EXISTS idx_agent_sessions_repository_id ON agent_sessions(repository_id);
 CREATE INDEX IF NOT EXISTS idx_agent_sessions_agent_type ON agent_sessions(agent_type) WHERE agent_type IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_agent_sessions_outcome ON agent_sessions(outcome) WHERE outcome IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_agent_sessions_started_at ON agent_sessions(started_at DESC);
--- Partial index for ongoing sessions
 CREATE INDEX IF NOT EXISTS idx_agent_sessions_ongoing ON agent_sessions(repository_id) WHERE ended_at IS NULL;
 
 -- ============================================================================
--- 7. Session Insights Table
--- ============================================================================
--- Insights discovered during agent sessions with proper foreign keys
-
-CREATE TABLE IF NOT EXISTS session_insights (
-    id TEXT PRIMARY KEY,                         -- uuid → TEXT
-    session_id TEXT NOT NULL,                    -- Foreign key to agent_sessions
-    insight_type TEXT NOT NULL,                  -- Type of insight
-    content TEXT NOT NULL,                       -- The insight content
-    related_file_id TEXT,                        -- Optional reference to indexed_files
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
-    
-    FOREIGN KEY (session_id) REFERENCES agent_sessions(id) ON DELETE CASCADE,
-    FOREIGN KEY (related_file_id) REFERENCES indexed_files(id) ON DELETE SET NULL,
-    
-    CHECK (insight_type IN ('discovery', 'failure', 'workaround'))
-);
-
--- Indexes for common queries
-CREATE INDEX IF NOT EXISTS idx_session_insights_session_id ON session_insights(session_id);
-CREATE INDEX IF NOT EXISTS idx_session_insights_insight_type ON session_insights(insight_type);
-CREATE INDEX IF NOT EXISTS idx_session_insights_related_file ON session_insights(related_file_id) 
-WHERE related_file_id IS NOT NULL;
-CREATE INDEX IF NOT EXISTS idx_session_insights_created_at ON session_insights(created_at DESC);
-
--- ============================================================================
--- 8. Record Migration
+-- 3. Record Migration
 -- ============================================================================
 
 INSERT OR IGNORE INTO schema_migrations (name) VALUES ('004_memory_layer');

package/src/db/migrations/006_add_migration_checksums.sql

@@ -0,0 +1,15 @@
+-- SQLite Migration: Add Checksum Tracking to Schema Migrations
+--
+-- Migration: 006_add_migration_checksums
+-- Issue: #166 - Migration infrastructure
+-- Author: Claude Code
+-- Date: 2026-02-04
+--
+-- Adds checksum column to schema_migrations table for drift detection.
+-- Existing migrations will have NULL checksums (validation skipped).
+
+ALTER TABLE schema_migrations ADD COLUMN checksum TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_schema_migrations_name ON schema_migrations(name);
+
+INSERT OR IGNORE INTO schema_migrations (name) VALUES ('006_add_migration_checksums');

package/src/db/sqlite/migration-runner.ts

@@ -0,0 +1,335 @@
+/**
+ * Migration runner for KotaDB SQLite schema management.
+ *
+ * Features:
+ * - Scans migrations directory for .sql files
+ * - Applies pending migrations in order
+ * - Validates checksums for drift detection
+ * - Transactional execution with automatic rollback
+ *
+ * @module @db/sqlite/migration-runner
+ */
+
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import type { KotaDatabase } from "./sqlite-client.js";
+import { createLogger } from "@logging/logger.js";
+
+const logger = createLogger({ module: "migration-runner" });
+
+/**
+ * Parsed migration file information
+ */
+export interface Migration {
+	filename: string;
+	name: string;
+	number: number;
+	path: string;
+	content: string;
+	checksum: string;
+}
+
+/**
+ * Migration record from the database
+ */
+export interface AppliedMigration {
+	name: string;
+	applied_at: string;
+	checksum?: string | null;
+}
+
+/**
+ * Result of a migration run
+ */
+export interface MigrationResult {
+	appliedCount: number;
+	driftDetected: boolean;
+	appliedMigrations: string[];
+	errors: string[];
+}
+
+/**
+ * Parse migration filename to extract number and name.
+ * Format: {number}_{name}.sql
+ *
+ * @param filename - Migration filename (e.g., "004_memory_layer.sql")
+ * @returns Parsed number and name, or null if invalid format
+ */
+export function parseMigrationFilename(
+	filename: string
+): { number: number; name: string } | null {
+	const match = filename.match(/^(\d+)_(.+)\.sql$/);
+	if (!match) return null;
+
+	const numStr = match[1];
+	const name = match[2];
+	if (!numStr || !name) return null;
+
+	return { number: parseInt(numStr, 10), name: `${numStr}_${name}` };
+}
+
+/**
+ * Compute SHA-256 checksum of migration content.
+ *
+ * @param content - Migration SQL content
+ * @returns Hex-encoded SHA-256 hash
+ */
+export function computeChecksum(content: string): string {
+	return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+
+/**
+ * Scan migrations directory and return sorted list of migrations.
+ *
+ * @param migrationsDir - Path to migrations directory
+ * @returns Array of migrations sorted by number
+ */
+export function scanMigrations(migrationsDir: string): Migration[] {
+	if (!existsSync(migrationsDir)) {
+		logger.warn("Migrations directory does not exist", { path: migrationsDir });
+		return [];
+	}
+
+	const files = readdirSync(migrationsDir)
+		.filter((f) => f.endsWith(".sql"))
+		.sort(); // Alphabetical sort ensures numeric order for 001, 002, etc.
+
+	const migrations: Migration[] = [];
+
+	for (const filename of files) {
+		const parsed = parseMigrationFilename(filename);
+		if (!parsed) {
+			logger.warn("Invalid migration filename (skipping)", { filename });
+			continue;
+		}
+
+		const path = join(migrationsDir, filename);
+		const content = readFileSync(path, "utf-8");
+		const checksum = computeChecksum(content);
+
+		migrations.push({
+			filename,
+			name: parsed.name,
+			number: parsed.number,
+			path,
+			content,
+			checksum,
+		});
+	}
+
+	// Sort by number (redundant if naming is correct, but ensures correctness)
+	migrations.sort((a, b) => a.number - b.number);
+
+	return migrations;
+}
+
+/**
+ * Get list of applied migrations from schema_migrations table.
+ *
+ * @param db - Database instance
+ * @returns Map of migration name to applied migration record
+ */
+export function getAppliedMigrations(
+	db: KotaDatabase
+): Map<string, AppliedMigration> {
+	// Ensure schema_migrations table exists
+	if (!db.tableExists("schema_migrations")) {
+		logger.warn("schema_migrations table does not exist");
+		return new Map();
+	}
+
+	// Check if checksum column exists
+	const columns = db.query<{ name: string }>(
+		"SELECT name FROM pragma_table_info('schema_migrations')"
+	);
+	const hasChecksum = columns.some((c) => c.name === "checksum");
+
+	// Query with or without checksum column
+	const query = hasChecksum
+		? "SELECT name, applied_at, checksum FROM schema_migrations ORDER BY id"
+		: "SELECT name, applied_at, NULL as checksum FROM schema_migrations ORDER BY id";
+
+	const rows = db.query<AppliedMigration>(query);
+
+	return new Map(rows.map((r) => [r.name, r]));
+}
+
+/**
+ * Apply a single migration within a transaction.
+ *
+ * @param db - Database instance
+ * @param migration - Migration to apply
+ */
+export function applyMigration(db: KotaDatabase, migration: Migration): void {
+	logger.info("Applying migration", { name: migration.name });
+
+	db.immediateTransaction(() => {
+		// Execute migration SQL
+		db.exec(migration.content);
+
+		// Check if checksum column exists for INSERT
+		const columns = db.query<{ name: string }>(
+			"SELECT name FROM pragma_table_info('schema_migrations')"
+		);
+		const hasChecksum = columns.some((c) => c.name === "checksum");
+
+		// Record migration (with checksum if column exists)
+		if (hasChecksum) {
+			db.run(
+				"INSERT OR REPLACE INTO schema_migrations (name, checksum, applied_at) VALUES (?, ?, datetime('now'))",
+				[migration.name, migration.checksum]
+			);
+		} else {
+			// Migration file already contains INSERT OR IGNORE for name
+			// Just ensure the record exists
+			db.run(
+				"INSERT OR IGNORE INTO schema_migrations (name, applied_at) VALUES (?, datetime('now'))",
+				[migration.name]
+			);
+		}
+	});
+
+	logger.info("Migration applied successfully", { name: migration.name });
+}
+
+/**
+ * Validate checksum for already-applied migration (drift detection).
+ *
+ * @param migration - Migration file info
+ * @param applied - Applied migration record
+ * @returns True if checksum matches or no checksum stored
+ */
+export function validateChecksum(
+	migration: Migration,
+	applied: AppliedMigration
+): boolean {
+	if (!applied.checksum) {
+		// Old migrations may not have checksum - skip validation
+		logger.debug("No checksum stored for migration (skipping validation)", {
+			name: migration.name,
+		});
+		return true;
+	}
+
+	if (migration.checksum !== applied.checksum) {
+		logger.warn("Migration checksum mismatch (DRIFT DETECTED)", {
+			name: migration.name,
+			expected: applied.checksum,
+			actual: migration.checksum,
+			message:
+				"Migration file was modified after being applied. This may indicate schema drift.",
+		});
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Run all pending migrations.
+ *
+ * @param db - Database instance
+ * @param migrationsDir - Path to migrations directory
+ * @returns Migration result with count and status
+ */
+export function runMigrations(
+	db: KotaDatabase,
+	migrationsDir: string
+): MigrationResult {
+	logger.info("Starting migration runner", { migrationsDir });
+
+	const result: MigrationResult = {
+		appliedCount: 0,
+		driftDetected: false,
+		appliedMigrations: [],
+		errors: [],
+	};
+
+	// Scan filesystem for migration files
+	const availableMigrations = scanMigrations(migrationsDir);
+	logger.debug("Found migration files", { count: availableMigrations.length });
+
+	// Get applied migrations from database
+	const appliedMigrations = getAppliedMigrations(db);
+	logger.debug("Found applied migrations", { count: appliedMigrations.size });
+
+	for (const migration of availableMigrations) {
+		const applied = appliedMigrations.get(migration.name);
+
+		if (applied) {
+			// Migration already applied - validate checksum
+			const valid = validateChecksum(migration, applied);
+			if (!valid) {
+				result.driftDetected = true;
+			}
+		} else {
+			// Migration not yet applied - apply it
+			try {
+				applyMigration(db, migration);
+				result.appliedCount++;
+				result.appliedMigrations.push(migration.name);
+			} catch (error) {
+				const errorMessage =
+					error instanceof Error ? error.message : String(error);
+				logger.error("Migration failed", {
+					name: migration.name,
+					error: errorMessage,
+				});
+				result.errors.push(`Migration ${migration.name} failed: ${errorMessage}`);
+				// Stop applying further migrations on failure
+				break;
+			}
+		}
+	}
+
+	if (result.driftDetected) {
+		logger.warn(
+			"Schema drift detected. Some migration files have been modified after being applied."
+		);
+	}
+
+	logger.info("Migration runner completed", {
+		appliedCount: result.appliedCount,
+		driftDetected: result.driftDetected,
+	});
+
+	return result;
+}
+
+/**
+ * Update checksums for all existing migrations.
+ * Useful after adding checksum column to update records.
+ *
+ * @param db - Database instance
+ * @param migrationsDir - Path to migrations directory
+ * @returns Number of records updated
+ */
+export function updateExistingChecksums(
+	db: KotaDatabase,
+	migrationsDir: string
+): number {
+	const migrations = scanMigrations(migrationsDir);
+	const applied = getAppliedMigrations(db);
+	let updatedCount = 0;
+
+	for (const migration of migrations) {
+		const record = applied.get(migration.name);
+		if (record && !record.checksum) {
+			db.run("UPDATE schema_migrations SET checksum = ? WHERE name = ?", [
+				migration.checksum,
+				migration.name,
+			]);
+			updatedCount++;
+			logger.debug("Updated checksum for migration", { name: migration.name });
+		}
+	}
+
+	if (updatedCount > 0) {
+		logger.info("Updated checksums for existing migrations", {
+			count: updatedCount,
+		});
+	}
+
+	return updatedCount;
+}

package/src/db/sqlite/sqlite-client.ts

@@ -19,6 +19,7 @@ import { cpus } from "node:os";
 import { createLogger } from "@logging/logger.js";
 import { findProjectRoot } from "@config/project-root.js";
 import { ensureKotadbIgnored } from "@config/gitignore.js";
+import { runMigrations, updateExistingChecksums } from "./migration-runner.js";
 
 const logger = createLogger({ module: "sqlite-client" });
 
@@ -137,8 +138,11 @@ export class KotaDatabase {
 		this.configurePragmas();
 
 		// Auto-initialize schema if not already present (writer only)
+		// - New database: Apply full base schema
+		// - Existing database: Run pending migrations
 		if (!this.config.readonly && !this.config.skipSchemaInit) {
 			if (!this.tableExists("indexed_files")) {
+				// NEW DATABASE: Apply base schema
 				const schemaPath = join(__dirname, "../sqlite-schema.sql");
 				const schema = readFileSync(schemaPath, "utf-8");
 				this.exec(schema);
@@ -146,7 +150,28 @@ export class KotaDatabase {
 					path: this.config.path,
 				});
 			} else {
-				logger.debug("SQLite schema already initialized");
+				// EXISTING DATABASE: Run migrations
+				const migrationsDir = join(__dirname, "../migrations");
+				try {
+					const result = runMigrations(this, migrationsDir);
+					if (result.appliedCount > 0) {
+						logger.info("Applied pending migrations", {
+							count: result.appliedCount,
+							migrations: result.appliedMigrations,
+						});
+					}
+					// Update checksums for existing migrations (after checksum column added)
+					updateExistingChecksums(this, migrationsDir);
+					if (result.errors.length > 0) {
+						logger.error("Migration errors", { errors: result.errors });
+					}
+				} catch (error) {
+					logger.error("Migration runner failed", {
+						error: error instanceof Error ? error.message : String(error),
+					});
+					// Do not throw - allow database to continue operating with current schema
+					// This prevents startup failures due to migration issues
+				}
 			}
 		}
 

package/src/db/sqlite-schema.sql

@@ -462,6 +462,54 @@ BEGIN
     VALUES (new.rowid, new.content);
 END;
 
+-- ============================================================================
+-- 11. Workflow Contexts Table (Issue #144)
+-- ============================================================================
+-- Stores curated context data for each workflow phase
+
+CREATE TABLE IF NOT EXISTS workflow_contexts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    workflow_id TEXT NOT NULL,
+    phase TEXT NOT NULL,
+    context_data TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    
+    UNIQUE(workflow_id, phase),
+    CHECK (phase IN ('analysis', 'plan', 'build', 'improve'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_contexts_workflow_id 
+ON workflow_contexts(workflow_id);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_contexts_created_at 
+ON workflow_contexts(created_at DESC);
+
+-- ============================================================================
+-- 12. Agent Sessions Table
+-- ============================================================================
+-- Tracks agent work sessions for learning and analysis
+
+CREATE TABLE IF NOT EXISTS agent_sessions (
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    agent_type TEXT,
+    task_summary TEXT,
+    outcome TEXT,
+    files_modified TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    ended_at TEXT,
+    
+    FOREIGN KEY (repository_id) REFERENCES repositories(id) ON DELETE CASCADE,
+    CHECK (outcome IS NULL OR outcome IN ('success', 'failure', 'partial'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_repository_id ON agent_sessions(repository_id);
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_agent_type ON agent_sessions(agent_type) WHERE agent_type IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_outcome ON agent_sessions(outcome) WHERE outcome IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_started_at ON agent_sessions(started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_ongoing ON agent_sessions(repository_id) WHERE ended_at IS NULL;
+
 -- Record memory layer migration
 INSERT OR IGNORE INTO schema_migrations (name) VALUES ('002_memory_layer_tables');
 

package/src/indexer/constants.ts

@@ -25,6 +25,7 @@ export const SUPPORTED_EXTENSIONS = [
 	".jsx",
 	".mjs",
 	".cjs",
+	".sql",
 ] as const;
 
 /**

package/src/indexer/parsers.ts

@@ -15,6 +15,7 @@ const SUPPORTED_EXTENSIONS = new Set<string>([
 	".cjs",
 	".mjs",
 	".json",
+	".sql",
 ]);
 
 const IGNORED_DIRECTORIES = new Set<string>([
@@ -161,7 +162,8 @@ export async function parseSourceFile(
 		return null;
 	}
 
-	const dependencies = extractDependencies(content);
+	// Skip dependency extraction for SQL files
+	const dependencies = extname(path) === ".sql" ? [] : extractDependencies(content);
 
 	return {
 		projectRoot: resolve(projectRoot),