@viberlabs/orchestrator 2.1.0

package/dist/core/src/db/index.js

@@ -0,0 +1,1114 @@
+"use strict";
+/**
+ * @viberlabs/viber-core/db
+ * SQLite database layer for VIBER using sql.js (pure JS, no native dependencies)
+ *
+ * Features:
+ * - ACID transactions for atomic operations
+ * - WAL mode optimization for better concurrency
+ * - Batch event inserts for performance
+ * - Agent pool restart recovery
+ * - OpenCode session tracking
+ * - Debounced persistence
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViberDatabase = void 0;
+const sql_js_1 = __importDefault(require("sql.js"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ============================================================================
+// ViberDatabase Class
+// ============================================================================
+class ViberDatabase {
+    db = null;
+    dbPath;
+    initialized = false;
+    saveTimer = null;
+    pendingSaves = 0;
+    constructor(dbPath = ".viber/state.db") {
+        this.dbPath = dbPath;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        const SQL = await (0, sql_js_1.default)();
+        const dbDir = (0, path_1.dirname)(this.dbPath);
+        if (!(0, fs_1.existsSync)(dbDir)) {
+            (0, fs_1.mkdirSync)(dbDir, { recursive: true });
+        }
+        if ((0, fs_1.existsSync)(this.dbPath)) {
+            try {
+                const buffer = (0, fs_1.readFileSync)(this.dbPath);
+                this.db = new SQL.Database(buffer);
+            }
+            catch (error) {
+                console.warn("[ViberDatabase] Failed to load database, creating new one:", error);
+                this.db = new SQL.Database();
+            }
+        }
+        else {
+            this.db = new SQL.Database();
+        }
+        await this.runMigrations();
+        this.configurePragmas();
+        this.initialized = true;
+    }
+    async runMigrations() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        this.ensureSchemaVersionTable();
+        const currentVersion = this.getSchemaVersion();
+        const migrations = [
+            {
+                version: 1,
+                name: "initial schema",
+                run: () => {
+                    // NOTE: This is the oldest supported schema. New columns are added via later migrations.
+                    this.db.run(`CREATE TABLE IF NOT EXISTS tasks (
+            id TEXT PRIMARY KEY, title TEXT NOT NULL, description TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'backlog', logic_status TEXT NOT NULL DEFAULT 'valley',
+            probability REAL NOT NULL DEFAULT 0.5, project_id TEXT NOT NULL, session_id TEXT,
+            created_at TEXT NOT NULL, updated_at TEXT NOT NULL, result TEXT, error TEXT, metadata TEXT
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS agents (
+            id TEXT PRIMARY KEY, task_id TEXT NOT NULL, role TEXT NOT NULL, status TEXT NOT NULL,
+            opencode_session_id TEXT, model TEXT, started_at TEXT NOT NULL,
+            completed_at TEXT, duration_ms INTEGER, input_tokens INTEGER NOT NULL DEFAULT 0,
+            output_tokens INTEGER NOT NULL DEFAULT 0, cost_usd REAL NOT NULL DEFAULT 0,
+            result TEXT, depends_on TEXT
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY, project_id TEXT NOT NULL, status TEXT NOT NULL,
+            started_at TEXT NOT NULL, ended_at TEXT, handoff_path TEXT NOT NULL DEFAULT 'HANDOFF.md',
+            tasks_completed INTEGER NOT NULL DEFAULT 0, agents_spawned INTEGER NOT NULL DEFAULT 0
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS session_notes (
+            id TEXT PRIMARY KEY, session_id TEXT NOT NULL, type TEXT NOT NULL, content TEXT NOT NULL, created_at TEXT NOT NULL
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS events (
+            id TEXT PRIMARY KEY, entity_type TEXT NOT NULL, entity_id TEXT NOT NULL,
+            event_type TEXT NOT NULL, data TEXT, timestamp TEXT NOT NULL
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS premises (
+            id TEXT PRIMARY KEY, task_id TEXT NOT NULL, statement TEXT NOT NULL, logic_var TEXT NOT NULL,
+            is_verified INTEGER NOT NULL DEFAULT 0, is_critical INTEGER NOT NULL DEFAULT 1, confidence REAL NOT NULL DEFAULT 0.5,
+            evidence TEXT, created_at TEXT NOT NULL
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS ip_assets (
+            id TEXT PRIMARY KEY, project_id TEXT NOT NULL, name TEXT NOT NULL, type TEXT NOT NULL,
+            description TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'identified',
+            created_at TEXT NOT NULL, updated_at TEXT NOT NULL, file_date TEXT, grant_date TEXT, metadata TEXT
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS ip_milestones (
+            id TEXT PRIMARY KEY, ip_asset_id TEXT NOT NULL, name TEXT NOT NULL, description TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending', created_at TEXT NOT NULL, completed_at TEXT, evidence TEXT
+          )`);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS projects (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          )`);
+                    // Indexes that only rely on v1 columns
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_agents_task ON agents(task_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_type, entity_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_session_notes_session ON session_notes(session_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_premises_task ON premises(task_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_premises_verified ON premises(is_verified)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_ip_assets_project ON ip_assets(project_id)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_ip_assets_status ON ip_assets(status)`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_ip_milestones_asset ON ip_milestones(ip_asset_id)`);
+                },
+            },
+            {
+                version: 2,
+                name: "tasks: add priority",
+                run: () => {
+                    this.addColumnIfMissing("tasks", "priority", `priority TEXT NOT NULL DEFAULT 'P2'`);
+                    this.db.run(`CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority)`);
+                },
+            },
+            {
+                version: 3,
+                name: "sessions: add task_id",
+                run: () => {
+                    this.addColumnIfMissing("sessions", "task_id", `task_id TEXT`);
+                },
+            },
+            {
+                version: 4,
+                name: "projects: add vision_path + metadata",
+                run: () => {
+                    this.addColumnIfMissing("projects", "vision_path", `vision_path TEXT NOT NULL DEFAULT ''`);
+                    this.addColumnIfMissing("projects", "metadata", `metadata TEXT`);
+                },
+            },
+            {
+                version: 5,
+                name: "agents: add provider/error/timestamps",
+                run: () => {
+                    this.addColumnIfMissing("agents", "provider", `provider TEXT`);
+                    this.addColumnIfMissing("agents", "error", `error TEXT`);
+                    this.addColumnIfMissing("agents", "created_at", `created_at TEXT NOT NULL DEFAULT ''`);
+                    this.addColumnIfMissing("agents", "updated_at", `updated_at TEXT NOT NULL DEFAULT ''`);
+                },
+            },
+            {
+                version: 6,
+                name: "seed: default project",
+                run: () => {
+                    const now = new Date().toISOString();
+                    // After v4, projects has the full column set.
+                    this.db.run(`INSERT OR IGNORE INTO projects (id, name, vision_path, created_at, updated_at, metadata) VALUES (?, ?, ?, ?, ?, ?)`, ["default", "VIBER Project", "", now, now, null]);
+                },
+            },
+        ];
+        for (const m of migrations) {
+            if (m.version <= currentVersion)
+                continue;
+            m.run();
+            this.setSchemaVersion(m.version);
+        }
+        // Migrations must persist immediately so we never re-run them on next startup.
+        this.persistNow();
+    }
+    persistNow() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const data = this.db.export();
+        (0, fs_1.writeFileSync)(this.dbPath, Buffer.from(data));
+        this.pendingSaves = 0;
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+    }
+    ensureSchemaVersionTable() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        this.db.run(`CREATE TABLE IF NOT EXISTS main.schema_version (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        version INTEGER NOT NULL
+      )`);
+        this.db.run(`INSERT OR IGNORE INTO main.schema_version (id, version) VALUES (1, 0)`);
+        const verify = this.db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'");
+        if (verify.length === 0 || verify[0].values.length === 0) {
+            throw new Error("[ViberDatabase] schema_version table missing after creation");
+        }
+    }
+    getSchemaVersion() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const result = this.db.exec(`SELECT version FROM main.schema_version WHERE id = 1`);
+        if (result.length === 0 || result[0].values.length === 0)
+            return 0;
+        const raw = result[0].values[0]?.[0];
+        const n = typeof raw === "number" ? raw : Number(raw);
+        return Number.isFinite(n) ? n : 0;
+    }
+    setSchemaVersion(version) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        this.db.run(`UPDATE main.schema_version SET version = ? WHERE id = 1`, [
+            version,
+        ]);
+    }
+    addColumnIfMissing(tableName, columnName, columnSql) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.tableHasColumn(tableName, columnName)) {
+            this.db.run(`ALTER TABLE ${tableName} ADD COLUMN ${columnSql}`);
+        }
+    }
+    tableHasColumn(tableName, columnName) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const safeTable = tableName.replace(/'/g, "''");
+        const safeCol = columnName.replace(/'/g, "''");
+        // Use pragma_table_info() (table-valued) instead of PRAGMA table_info,
+        // because it behaves like a normal SELECT across environments.
+        const result = this.db.exec(`SELECT 1 FROM pragma_table_info('${safeTable}') WHERE name = '${safeCol}' LIMIT 1`);
+        return result.length > 0 && result[0].values.length > 0;
+    }
+    configurePragmas() {
+        this.db.run(`PRAGMA foreign_keys = ON`);
+        this.db.run(`PRAGMA optimize`);
+    }
+    // Persistence with debouncing
+    save() {
+        this.pendingSaves++;
+        this.debouncedSave();
+    }
+    debouncedSave() {
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = setTimeout(() => this.flush(), 100);
+    }
+    flush() {
+        if (!this.db || this.pendingSaves === 0)
+            return;
+        try {
+            const data = this.db.export();
+            (0, fs_1.writeFileSync)(this.dbPath, Buffer.from(data));
+            this.pendingSaves = 0;
+        }
+        catch (error) {
+            console.error("[ViberDatabase] Failed to save:", error);
+            throw error;
+        }
+    }
+    // Transactions
+    async transaction(callback) {
+        if (!this.db)
+            await this.initialize();
+        this.db.run("BEGIN TRANSACTION");
+        try {
+            const result = await callback(this);
+            this.db.run("COMMIT");
+            this.save();
+            return result;
+        }
+        catch (error) {
+            this.db.run("ROLLBACK");
+            throw error;
+        }
+    }
+    // Batch operations
+    async batchInsertEvents(events) {
+        if (!this.db)
+            await this.initialize();
+        if (events.length === 0)
+            return;
+        const stmt = this.db.prepare(`INSERT INTO events (id, entity_type, entity_id, event_type, data, timestamp) VALUES (?, ?, ?, ?, ?, ?)`);
+        for (const event of events) {
+            stmt.run([
+                event.id,
+                event.entityType,
+                event.entityId,
+                event.eventType,
+                event.data || null,
+                event.timestamp,
+            ]);
+        }
+        stmt.free();
+        this.save();
+    }
+    // Task operations
+    async clearTasks() {
+        if (!this.db)
+            await this.initialize();
+        this.db.run(`DELETE FROM tasks`);
+        this.save();
+    }
+    async createTask(task) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        const record = {
+            ...task,
+            status: task.status || "backlog",
+            priority: task.priority || "P2",
+            logicStatus: task.logicStatus || "valley",
+            probability: task.probability || 0.5,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db.run(`INSERT INTO tasks (id, title, description, status, priority, logic_status, probability, project_id, session_id, created_at, updated_at, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            record.id,
+            record.title,
+            record.description,
+            record.status,
+            record.priority,
+            record.logicStatus,
+            record.probability,
+            record.projectId,
+            record.sessionId || null,
+            record.createdAt,
+            record.updatedAt,
+            record.metadata || null,
+        ]);
+        this.save();
+        return record;
+    }
+    async getTask(id) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, title, description, status, priority, logic_status, probability, project_id, session_id, created_at, updated_at, result, error, metadata
+       FROM tasks WHERE id = ?`, [id]);
+        if (result.length === 0 || result[0].values.length === 0)
+            return undefined;
+        return this.rowToTask(result[0].values[0]);
+    }
+    async getTasks(filter) {
+        if (!this.db)
+            await this.initialize();
+        let query = `SELECT id, title, description, status, priority, logic_status, probability, project_id, session_id, created_at, updated_at, result, error, metadata FROM tasks`;
+        const params = [];
+        if (filter) {
+            const conditions = [];
+            if (filter.status) {
+                conditions.push("status = ?");
+                params.push(filter.status);
+            }
+            if (filter.projectId) {
+                conditions.push("project_id = ?");
+                params.push(filter.projectId);
+            }
+            if (filter.sessionId) {
+                conditions.push("session_id = ?");
+                params.push(filter.sessionId);
+            }
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        query += ` ORDER BY created_at DESC`;
+        const result = this.db.exec(query, params);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToTask(row));
+    }
+    async getEligibleTasksForScheduling(args) {
+        if (!this.db)
+            await this.initialize();
+        const allowSlope = Boolean(args.allowSlope);
+        const logicStatuses = allowSlope ? ["peak", "slope"] : ["peak"];
+        let query = `SELECT id, title, description, status, priority, logic_status, probability, project_id, session_id, created_at, updated_at, result, error, metadata
+      FROM tasks WHERE status = ? AND logic_status IN (${logicStatuses
+            .map(() => "?")
+            .join(", ")})`;
+        const params = ["backlog", ...logicStatuses];
+        if (args.projectId) {
+            query += ` AND project_id = ?`;
+            params.push(args.projectId);
+        }
+        query += ` ORDER BY CASE priority
+      WHEN 'P0' THEN 0
+      WHEN 'P1' THEN 1
+      WHEN 'P2' THEN 2
+      WHEN 'P3' THEN 3
+      WHEN 'P4' THEN 4
+      ELSE 5 END, updated_at ASC`;
+        const result = this.db.exec(query, params);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToTask(row));
+    }
+    async taskHasAgents(taskId) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT 1 FROM agents WHERE task_id = ? LIMIT 1`, [taskId]);
+        return result.length > 0 && result[0].values.length > 0;
+    }
+    async updateTask(id, updates) {
+        if (!this.db)
+            await this.initialize();
+        updates.updatedAt = new Date().toISOString();
+        const setClause = Object.keys(updates)
+            .map((k) => this.camelToSnake(k) + " = ?")
+            .join(", ");
+        const values = [...Object.values(updates), id];
+        this.db.run(`UPDATE tasks SET ${setClause} WHERE id = ?`, values);
+        this.save();
+        const task = await this.getTask(id);
+        if (!task)
+            throw new Error(`Task ${id} not found`);
+        return task;
+    }
+    // Premise operations
+    async clearPremises() {
+        if (!this.db)
+            await this.initialize();
+        this.db.run(`DELETE FROM premises`);
+        this.save();
+    }
+    async replacePremisesForTask(taskId, premises) {
+        if (!this.db)
+            await this.initialize();
+        this.db.run(`DELETE FROM premises WHERE task_id = ?`, [taskId]);
+        if (premises.length === 0) {
+            this.save();
+            return;
+        }
+        const stmt = this.db.prepare(`INSERT INTO premises (id, task_id, statement, logic_var, is_verified, is_critical, confidence, evidence, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const now = new Date().toISOString();
+        for (const p of premises) {
+            stmt.run([
+                p.id,
+                p.taskId,
+                p.statement,
+                p.logicVar,
+                p.isVerified ? 1 : 0,
+                p.isCritical ? 1 : 0,
+                p.confidence,
+                p.evidence ?? null,
+                now,
+            ]);
+        }
+        stmt.free();
+        this.save();
+    }
+    async getPremises(taskId) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, task_id, statement, logic_var, is_verified, is_critical, confidence, evidence, created_at
+       FROM premises WHERE task_id = ? ORDER BY created_at DESC`, [taskId]);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToPremise(row));
+    }
+    // Agent operations
+    async clearAgents() {
+        if (!this.db)
+            await this.initialize();
+        this.db.run(`DELETE FROM agents`);
+        this.save();
+    }
+    async createAgent(agent) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        const record = {
+            ...agent,
+            status: agent.status || "pending",
+            startedAt: now,
+            inputTokens: 0,
+            outputTokens: 0,
+            costUsd: 0,
+        };
+        this.db.run(`INSERT INTO agents (id, task_id, role, status, opencode_session_id, model, provider, started_at, depends_on, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            record.id,
+            record.taskId,
+            record.role,
+            record.status,
+            record.opencodeSessionId || null,
+            record.model || null,
+            record.provider || null,
+            record.startedAt,
+            record.dependsOn || null,
+            now,
+            now,
+        ]);
+        this.save();
+        return record;
+    }
+    async getAgent(id) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, task_id, role, status, opencode_session_id, model, provider, started_at, completed_at, duration_ms, input_tokens, output_tokens, cost_usd, result, error, depends_on
+       FROM agents WHERE id = ?`, [id]);
+        if (result.length === 0 || result[0].values.length === 0)
+            return undefined;
+        return this.rowToAgent(result[0].values[0]);
+    }
+    async getAgents(filter) {
+        if (!this.db)
+            await this.initialize();
+        let query = `SELECT id, task_id, role, status, opencode_session_id, model, provider, started_at, completed_at, duration_ms, input_tokens, output_tokens, cost_usd, result, error, depends_on FROM agents`;
+        const params = [];
+        if (filter) {
+            const conditions = [];
+            if (filter.taskId) {
+                conditions.push("task_id = ?");
+                params.push(filter.taskId);
+            }
+            if (filter.status) {
+                if (Array.isArray(filter.status)) {
+                    conditions.push(`status IN (${filter.status.map(() => "?").join(", ")})`);
+                    params.push(...filter.status);
+                }
+                else {
+                    conditions.push("status = ?");
+                    params.push(filter.status);
+                }
+            }
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        query += ` ORDER BY started_at DESC`;
+        const result = this.db.exec(query, params);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToAgent(row));
+    }
+    async updateAgent(id, updates) {
+        if (!this.db)
+            await this.initialize();
+        // sql.js cannot bind `undefined`. Treat undefined as "no update".
+        updates.updatedAt = new Date().toISOString();
+        const entries = Object.entries(updates).filter(([, v]) => v !== undefined);
+        if (entries.length === 0) {
+            const agent = await this.getAgent(id);
+            if (!agent)
+                throw new Error(`Agent ${id} not found`);
+            return agent;
+        }
+        const setClause = entries
+            .map(([k]) => this.camelToSnake(k) + " = ?")
+            .join(", ");
+        const values = [...entries.map(([, v]) => v), id];
+        this.db.run(`UPDATE agents SET ${setClause} WHERE id = ?`, values);
+        this.save();
+        const agent = await this.getAgent(id);
+        if (!agent)
+            throw new Error(`Agent ${id} not found`);
+        return agent;
+    }
+    // Session operations
+    async createSession(session) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        const record = {
+            ...session,
+            status: "active",
+            startedAt: now,
+            handoffPath: "HANDOFF.md",
+            tasksCompleted: 0,
+            agentsSpawned: 0,
+        };
+        this.db.run(`INSERT INTO sessions (id, project_id, status, task_id, started_at, handoff_path, tasks_completed, agents_spawned)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+            record.id,
+            record.projectId,
+            record.status,
+            record.taskId || null,
+            record.startedAt,
+            record.handoffPath,
+            record.tasksCompleted,
+            record.agentsSpawned,
+        ]);
+        this.save();
+        return record;
+    }
+    async getSession(id) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, project_id, status, task_id, started_at, ended_at, handoff_path, tasks_completed, agents_spawned FROM sessions WHERE id = ?`, [id]);
+        if (result.length === 0 || result[0].values.length === 0)
+            return undefined;
+        return this.rowToSession(result[0].values[0]);
+    }
+    async getSessions(filter) {
+        if (!this.db)
+            await this.initialize();
+        let query = `SELECT id, project_id, status, task_id, started_at, ended_at, handoff_path, tasks_completed, agents_spawned FROM sessions`;
+        const params = [];
+        if (filter) {
+            const conditions = [];
+            if (filter.status) {
+                conditions.push("status = ?");
+                params.push(filter.status);
+            }
+            if (filter.projectId) {
+                conditions.push("project_id = ?");
+                params.push(filter.projectId);
+            }
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        query += ` ORDER BY started_at DESC`;
+        const result = this.db.exec(query, params);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToSession(row));
+    }
+    async getActiveSession(projectId) {
+        if (!this.db)
+            await this.initialize();
+        let query = `SELECT id, project_id, status, task_id, started_at, ended_at, handoff_path, tasks_completed, agents_spawned FROM sessions WHERE status = 'active'`;
+        const params = [];
+        if (projectId) {
+            query += ` AND project_id = ?`;
+            params.push(projectId);
+        }
+        query += ` ORDER BY started_at DESC LIMIT 1`;
+        const result = this.db.exec(query, params);
+        if (result.length === 0 || result[0].values.length === 0)
+            return undefined;
+        return this.rowToSession(result[0].values[0]);
+    }
+    async updateSession(id, updates) {
+        if (!this.db)
+            await this.initialize();
+        const setClause = Object.keys(updates)
+            .map((k) => this.camelToSnake(k) + " = ?")
+            .join(", ");
+        const values = [...Object.values(updates), id];
+        this.db.run(`UPDATE sessions SET ${setClause} WHERE id = ?`, values);
+        this.save();
+        const session = await this.getSession(id);
+        if (!session)
+            throw new Error(`Session ${id} not found`);
+        return session;
+    }
+    async endSession(sessionId, summary) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        this.db.run(`UPDATE sessions SET status = ?, ended_at = ? WHERE id = ?`, [
+            "completed",
+            now,
+            sessionId,
+        ]);
+        if (summary) {
+            this.db.run(`INSERT INTO session_notes (id, session_id, type, content, created_at) VALUES (?, ?, ?, ?, ?)`, [`note-${Date.now()}`, sessionId, "critical", summary, now]);
+        }
+        this.save();
+        const session = await this.getSession(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        return session;
+    }
+    async createSessionNote(note) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        this.db.run(`INSERT INTO session_notes (id, session_id, type, content, created_at) VALUES (?, ?, ?, ?, ?)`, [note.id, note.sessionId, note.type, note.content, now]);
+        this.save();
+        return { ...note, createdAt: now };
+    }
+    async getSessionNotes(sessionId) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, session_id, type, content, created_at FROM session_notes WHERE session_id = ? ORDER BY created_at DESC`, [sessionId]);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => ({
+            id: row[0],
+            sessionId: row[1],
+            type: row[2],
+            content: row[3],
+            createdAt: row[4],
+        }));
+    }
+    // Event operations
+    async clearEvents() {
+        if (!this.db)
+            await this.initialize();
+        this.db.run(`DELETE FROM events`);
+        this.save();
+    }
+    async createEvent(event) {
+        if (!this.db)
+            await this.initialize();
+        this.db.run(`INSERT INTO events (id, entity_type, entity_id, event_type, data, timestamp) VALUES (?, ?, ?, ?, ?, ?)`, [
+            event.id,
+            event.entityType,
+            event.entityId,
+            event.eventType,
+            event.data || null,
+            event.timestamp,
+        ]);
+        this.save();
+        return event;
+    }
+    async getEvents(filter) {
+        if (!this.db)
+            await this.initialize();
+        let query = `SELECT * FROM events`;
+        const params = [];
+        const conditions = [];
+        if (filter) {
+            if (filter.entityType) {
+                conditions.push("entity_type = ?");
+                params.push(filter.entityType);
+            }
+            if (filter.entityId) {
+                conditions.push("entity_id = ?");
+                params.push(filter.entityId);
+            }
+            if (filter.since) {
+                conditions.push("timestamp > ?");
+                params.push(filter.since);
+            }
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        query += ` ORDER BY timestamp DESC`;
+        if (filter?.limit) {
+            query += ` LIMIT ?`;
+            params.push(filter.limit);
+        }
+        const result = this.db.exec(query, params);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToEvent(row));
+    }
+    // IP Asset operations
+    async createIpAsset(asset) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        const record = {
+            ...asset,
+            status: asset.status || "identified",
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db.run(`INSERT INTO ip_assets (id, project_id, name, type, description, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+            record.id,
+            record.projectId,
+            record.name,
+            record.type,
+            record.description,
+            record.status,
+            record.createdAt,
+            record.updatedAt,
+        ]);
+        this.save();
+        return record;
+    }
+    async getIpAsset(id) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT * FROM ip_assets WHERE id = ?`, [id]);
+        if (result.length === 0 || result[0].values.length === 0)
+            return undefined;
+        return this.rowToIpAsset(result[0].values[0]);
+    }
+    async getIpAssets(filter) {
+        if (!this.db)
+            await this.initialize();
+        let query = `SELECT * FROM ip_assets`;
+        const params = [];
+        const conditions = [];
+        if (filter) {
+            if (filter.type) {
+                conditions.push("type = ?");
+                params.push(filter.type);
+            }
+            if (filter.status) {
+                conditions.push("status = ?");
+                params.push(filter.status);
+            }
+            if (filter.projectId) {
+                conditions.push("project_id = ?");
+                params.push(filter.projectId);
+            }
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        query += ` ORDER BY created_at DESC`;
+        const result = this.db.exec(query, params);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToIpAsset(row));
+    }
+    async updateIpAsset(id, updates) {
+        if (!this.db)
+            await this.initialize();
+        updates.updatedAt = new Date().toISOString();
+        const setClause = Object.keys(updates)
+            .map((k) => this.camelToSnake(k) + " = ?")
+            .join(", ");
+        const values = [...Object.values(updates), id];
+        this.db.run(`UPDATE ip_assets SET ${setClause} WHERE id = ?`, values);
+        this.save();
+        const asset = await this.getIpAsset(id);
+        if (!asset)
+            throw new Error(`IP Asset ${id} not found`);
+        return asset;
+    }
+    async createIpMilestone(milestone) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        const record = {
+            ...milestone,
+            status: "pending",
+            createdAt: now,
+        };
+        this.db.run(`INSERT INTO ip_milestones (id, ip_asset_id, name, description, status, created_at) VALUES (?, ?, ?, ?, ?, ?)`, [
+            record.id,
+            record.ipAssetId,
+            record.name,
+            record.description,
+            record.status,
+            record.createdAt,
+        ]);
+        this.save();
+        return record;
+    }
+    async getIpMilestones(ipAssetId) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT * FROM ip_milestones WHERE ip_asset_id = ? ORDER BY created_at ASC`, [ipAssetId]);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToIpMilestone(row));
+    }
+    async updateIpMilestone(id, updates) {
+        if (!this.db)
+            await this.initialize();
+        const setClause = Object.keys(updates)
+            .map((k) => this.camelToSnake(k) + " = ?")
+            .join(", ");
+        const values = [...Object.values(updates), id];
+        this.db.run(`UPDATE ip_milestones SET ${setClause} WHERE id = ?`, values);
+        this.save();
+        const result = this.db.exec(`SELECT * FROM ip_milestones WHERE id = ?`, [
+            id,
+        ]);
+        if (result.length === 0 || result[0].values.length === 0)
+            throw new Error(`IP Milestone ${id} not found`);
+        return this.rowToIpMilestone(result[0].values[0]);
+    }
+    // Project operations
+    async createProject(project) {
+        if (!this.db)
+            await this.initialize();
+        const now = new Date().toISOString();
+        const record = {
+            id: project.id,
+            name: project.name,
+            visionPath: project.visionPath || "",
+            createdAt: now,
+            updatedAt: now,
+            metadata: undefined,
+        };
+        this.db.run(`INSERT INTO projects (id, name, vision_path, created_at, updated_at, metadata)
+       VALUES (?, ?, ?, ?, ?, ?)`, [
+            record.id,
+            record.name,
+            record.visionPath,
+            record.createdAt,
+            record.updatedAt,
+            record.metadata || null,
+        ]);
+        this.save();
+        return record;
+    }
+    async getProject(id) {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, name, vision_path, created_at, updated_at, metadata FROM projects WHERE id = ?`, [id]);
+        if (result.length === 0 || result[0].values.length === 0)
+            return undefined;
+        return this.rowToProject(result[0].values[0]);
+    }
+    async getProjects() {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT id, name, vision_path, created_at, updated_at, metadata FROM projects ORDER BY created_at DESC`);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToProject(row));
+    }
+    async updateProject(id, updates) {
+        if (!this.db)
+            await this.initialize();
+        updates.updatedAt = new Date().toISOString();
+        const setClause = Object.keys(updates)
+            .map((k) => this.camelToSnake(k) + " = ?")
+            .join(", ");
+        const values = [...Object.values(updates), id];
+        this.db.run(`UPDATE projects SET ${setClause} WHERE id = ?`, values);
+        this.save();
+        const project = await this.getProject(id);
+        if (!project)
+            throw new Error(`Project ${id} not found`);
+        return project;
+    }
+    parseProjectMetadata(raw) {
+        if (!raw)
+            return {};
+        try {
+            const parsed = JSON.parse(raw);
+            return typeof parsed === "object" && parsed ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    deriveProjectCode(name) {
+        const source = (name ?? "").toUpperCase().replace(/[^A-Z0-9]/g, "");
+        const trimmed = source.slice(0, 6);
+        if (trimmed.length >= 2)
+            return trimmed;
+        return "V2";
+    }
+    normalizeProjectCode(code, fallback) {
+        const cleaned = (code ?? "").toUpperCase().replace(/[^A-Z0-9]/g, "");
+        if (cleaned.length >= 2)
+            return cleaned.slice(0, 6);
+        if (fallback)
+            return this.deriveProjectCode(fallback);
+        return "V2";
+    }
+    async getNextTaskId(projectId, projectName) {
+        if (!this.db)
+            await this.initialize();
+        let project = await this.getProject(projectId);
+        if (!project) {
+            project = await this.createProject({
+                id: projectId,
+                name: projectName ?? "VIBER Project",
+            });
+        }
+        const metadata = this.parseProjectMetadata(project.metadata);
+        const projectCode = this.normalizeProjectCode(typeof metadata.projectCode === "string" ? metadata.projectCode : undefined, project.name || projectName);
+        const currentCounter = Number(metadata.taskCounter ?? 0);
+        const nextCounter = Number.isFinite(currentCounter) ? currentCounter + 1 : 1;
+        metadata.projectCode = projectCode;
+        metadata.taskCounter = nextCounter;
+        await this.updateProject(project.id, {
+            metadata: JSON.stringify(metadata),
+        });
+        const seq = String(nextCounter).padStart(3, "0");
+        return `VL-${projectCode}-${seq}`;
+    }
+    // Recovery methods
+    async recoverActiveAgents() {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT * FROM agents WHERE status IN ('pending', 'spawned', 'working') ORDER BY started_at ASC`);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToAgent(row));
+    }
+    async recoverActiveSessions() {
+        if (!this.db)
+            await this.initialize();
+        const result = this.db.exec(`SELECT * FROM sessions WHERE status = 'active' ORDER BY started_at DESC`);
+        if (result.length === 0)
+            return [];
+        return result[0].values.map((row) => this.rowToSession(row));
+    }
+    // Close
+    close() {
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.flush();
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initialized = false;
+        }
+    }
+    // Row helpers
+    rowToTask(row) {
+        return {
+            id: row[0],
+            title: row[1],
+            description: row[2],
+            status: row[3],
+            priority: row[4],
+            logicStatus: row[5],
+            probability: row[6],
+            projectId: row[7],
+            sessionId: row[8],
+            createdAt: row[9],
+            updatedAt: row[10],
+            result: row[11],
+            error: row[12],
+            metadata: row[13],
+        };
+    }
+    rowToAgent(row) {
+        return {
+            id: row[0],
+            taskId: row[1],
+            role: row[2],
+            status: row[3],
+            opencodeSessionId: row[4],
+            model: row[5],
+            provider: row[6],
+            startedAt: row[7],
+            completedAt: row[8],
+            durationMs: row[9],
+            inputTokens: row[10],
+            outputTokens: row[11],
+            costUsd: row[12],
+            result: row[13],
+            error: row[14],
+            dependsOn: row[15],
+        };
+    }
+    rowToSession(row) {
+        return {
+            id: row[0],
+            projectId: row[1],
+            status: row[2],
+            taskId: row[3],
+            startedAt: row[4],
+            endedAt: row[5],
+            handoffPath: row[6],
+            tasksCompleted: row[7],
+            agentsSpawned: row[8],
+        };
+    }
+    rowToEvent(row) {
+        return {
+            id: row[0],
+            entityType: row[1],
+            entityId: row[2],
+            eventType: row[3],
+            data: row[4],
+            timestamp: row[5],
+        };
+    }
+    rowToPremise(row) {
+        return {
+            id: row[0],
+            taskId: row[1],
+            statement: row[2],
+            logicVar: row[3],
+            isVerified: Boolean(row[4]),
+            isCritical: Boolean(row[5]),
+            confidence: row[6],
+            evidence: row[7],
+            createdAt: row[8],
+        };
+    }
+    rowToIpAsset(row) {
+        return {
+            id: row[0],
+            projectId: row[1],
+            name: row[2],
+            type: row[3],
+            description: row[4],
+            status: row[5],
+            createdAt: row[6],
+            updatedAt: row[7],
+        };
+    }
+    rowToIpMilestone(row) {
+        return {
+            id: row[0],
+            ipAssetId: row[1],
+            name: row[2],
+            description: row[3],
+            status: row[4],
+            createdAt: row[5],
+        };
+    }
+    rowToProject(row) {
+        return {
+            id: row[0],
+            name: row[1],
+            visionPath: row[2],
+            createdAt: row[3],
+            updatedAt: row[4],
+            metadata: row[5],
+        };
+    }
+    camelToSnake(str) {
+        return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    }
+}
+exports.ViberDatabase = ViberDatabase;
+exports.default = ViberDatabase;
+//# sourceMappingURL=index.js.map