atabey 0.0.32 → 0.0.33

package/dist/shared/src/storage.js

@@ -0,0 +1,724 @@
+import Database from "better-sqlite3";
+import fs from "fs";
+import path from "path";
+import { AUDIT_CHAIN_GENESIS, buildAgentLogChainPayload, sha256Hex, verifyHashChain } from "./audit-chain.js";
+import { databaseHolder } from "./database.js";
+import { logger } from "./logger.js";
+import { maskText } from "./pii.js";
+import { asAgentID, asLogID, asMessageID, asTaskID, } from "./types.js";
+/**
+ * Resolves the framework directory (.atabey) intelligently by ascending the directory tree,
+ * preventing subpackages and test runners from spraying databases in random subfolders.
+ */
+export function resolveFrameworkDir() {
+    const testDir = process.env.ATABEY_TEST_DIR || process.env.ATABEY_FRAMEWORK_DIR;
+    if (testDir)
+        return testDir;
+    let cur = process.cwd();
+    while (cur !== path.parse(cur).root) {
+        const candidate = path.join(cur, ".atabey");
+        if (fs.existsSync(candidate))
+            return candidate;
+        const pkgJson = path.join(cur, "package.json");
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf8"));
+                if (pkg.name === "atabey-monorepo" || (pkg.workspaces && Array.isArray(pkg.workspaces))) {
+                    return path.join(cur, ".atabey");
+                }
+            }
+            catch { /* ignore */ }
+        }
+        cur = path.dirname(cur);
+    }
+    return path.join(process.cwd(), ".atabey");
+}
+/**
+ * [DB] Canonical Atabey Storage Engine (Single Source of Truth)
+ * Central SQLite database for enterprise-scale multi-agent state management.
+ */
+export class AtabeyStorage {
+    static db = null;
+    static getDB() {
+        if (!this.db) {
+            const frameworkDir = resolveFrameworkDir();
+            if (!fs.existsSync(frameworkDir)) {
+                fs.mkdirSync(frameworkDir, { recursive: true });
+            }
+            const dbPath = path.join(frameworkDir, "atabey.db");
+            this.db = new Database(dbPath, { timeout: 5000 });
+            this.db.pragma("journal_mode = WAL");
+            databaseHolder.setDB(this.db);
+            this.initializeSchema();
+        }
+        return this.db;
+    }
+    static initializeSchema() {
+        const db = this.db;
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS agents (
+                name TEXT PRIMARY KEY,
+                state TEXT DEFAULT 'READY',
+                task TEXT DEFAULT 'Idle',
+                description TEXT DEFAULT '',
+                skills TEXT DEFAULT '[]',
+                last_updated DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                sender TEXT,
+                receiver TEXT,
+                category TEXT,
+                content TEXT,
+                trace_id TEXT,
+                parent_id TEXT,
+                status TEXT DEFAULT 'PENDING',
+                priority TEXT DEFAULT 'NORMAL',
+                requires_approval BOOLEAN DEFAULT 0
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS tasks (
+                id TEXT PRIMARY KEY,
+                trace_id TEXT,
+                description TEXT,
+                agent TEXT,
+                status TEXT DEFAULT 'PENDING',
+                priority TEXT DEFAULT 'NORMAL',
+                dependencies TEXT,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                agent TEXT,
+                action TEXT,
+                trace_id TEXT,
+                status TEXT,
+                summary TEXT,
+                findings TEXT,
+                prev_hash TEXT,
+                hash TEXT
+            )
+        `);
+        try {
+            const tableInfo = db.prepare("PRAGMA table_info(logs)").all();
+            const columnNames = tableInfo.map(c => c.name);
+            if (!columnNames.includes("prev_hash"))
+                db.exec("ALTER TABLE logs ADD COLUMN prev_hash TEXT");
+            if (!columnNames.includes("hash"))
+                db.exec("ALTER TABLE logs ADD COLUMN hash TEXT");
+        }
+        catch (err) {
+            logger.error(`Failed to migrate logs table schema: ${err.message}`);
+        }
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS metadata (
+                key TEXT PRIMARY KEY,
+                value TEXT
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS costs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                provider TEXT,
+                model TEXT,
+                input_tokens INTEGER,
+                output_tokens INTEGER,
+                cost REAL,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                trace_id TEXT
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS knowledge (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                filename TEXT UNIQUE,
+                content TEXT,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT UNIQUE,
+                token TEXT UNIQUE,
+                role TEXT DEFAULT 'user',
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS loop_cooldowns (
+                agent TEXT PRIMARY KEY,
+                cooldown_until INTEGER NOT NULL,
+                detail TEXT,
+                cooldown_count INTEGER DEFAULT 1,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS approvals (
+                trace_id TEXT PRIMARY KEY,
+                tool_name TEXT NOT NULL,
+                agent TEXT NOT NULL,
+                risk_score INTEGER NOT NULL,
+                risk_level TEXT NOT NULL,
+                reason TEXT NOT NULL,
+                args TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                expires_at INTEGER NOT NULL,
+                status TEXT DEFAULT 'PENDING',
+                passcode TEXT
+            )
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS discipline (
+                agent TEXT PRIMARY KEY,
+                total_calls INTEGER DEFAULT 0,
+                violations INTEGER DEFAULT 0,
+                last_violation TEXT,
+                cooldown_until INTEGER DEFAULT 0,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+    }
+    // === KNOWLEDGE PERSISTENCE ===
+    static getKnowledgeList() {
+        try {
+            return this.getDB().prepare("SELECT filename, updated_at FROM knowledge ORDER BY updated_at DESC").all();
+        }
+        catch (err) {
+            logger.debug(`Failed to get knowledge list: ${err.message}`);
+            return [];
+        }
+    }
+    static getKnowledgeFile(filename) {
+        try {
+            const row = this.getDB().prepare("SELECT * FROM knowledge WHERE filename = ?").get(filename);
+            return row || null;
+        }
+        catch (err) {
+            logger.debug(`Failed to get knowledge file: ${err.message}`);
+            return null;
+        }
+    }
+    static saveKnowledgeFile(filename, content) {
+        this.getDB().prepare(`
+            INSERT INTO knowledge (filename, content, updated_at) VALUES (?, ?, datetime('now'))
+            ON CONFLICT(filename) DO UPDATE SET content = excluded.content, updated_at = datetime('now')
+        `).run(filename, content);
+    }
+    static deleteKnowledgeFile(filename) {
+        const info = this.getDB().prepare("DELETE FROM knowledge WHERE filename = ?").run(filename);
+        return info.changes > 0;
+    }
+    // === USER PERSISTENCE ===
+    static hasUsers() {
+        try {
+            const row = this.getDB().prepare("SELECT COUNT(*) as count FROM users").get();
+            return row.count > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    static getUsers() {
+        try {
+            return this.getDB().prepare("SELECT name, token, role FROM users ORDER BY id ASC").all();
+        }
+        catch (err) {
+            logger.debug(`Failed to get users: ${err.message}`);
+            return [];
+        }
+    }
+    static getUserByToken(token) {
+        try {
+            const row = this.getDB().prepare("SELECT name, role FROM users WHERE token = ?").get(token);
+            return row || null;
+        }
+        catch (err) {
+            logger.debug(`Failed to get user by token: ${err.message}`);
+            return null;
+        }
+    }
+    static createUser(name, token, role) {
+        this.getDB().prepare("INSERT INTO users (name, token, role) VALUES (?, ?, ?)").run(name, token, role);
+    }
+    static deleteUser(name) {
+        const info = this.getDB().prepare("DELETE FROM users WHERE name = ?").run(name);
+        return info.changes > 0;
+    }
+    // === AGENT DETAILS PERSISTENCE ===
+    static createAgent(name, description, skills) {
+        const cleanName = name.replace("@", "");
+        this.getDB().prepare(`
+            INSERT INTO agents (name, state, task, description, skills, last_updated)
+            VALUES (?, 'READY', 'Idle', ?, ?, datetime('now'))
+            ON CONFLICT(name) DO UPDATE SET description = excluded.description, skills = excluded.skills
+        `).run(cleanName, description, skills);
+    }
+    static deleteAgent(name) {
+        const cleanName = name.replace("@", "");
+        const info = this.getDB().prepare("DELETE FROM agents WHERE name = ?").run(cleanName);
+        return info.changes > 0;
+    }
+    static updateAgentDetails(name, description, state, task, skills) {
+        const cleanName = name.replace("@", "");
+        this.getDB().prepare(`
+            INSERT INTO agents (name, state, task, description, skills, last_updated)
+            VALUES (?, ?, ?, ?, ?, datetime('now'))
+            ON CONFLICT(name) DO UPDATE SET
+                description = excluded.description,
+                state = excluded.state,
+                task = excluded.task,
+                skills = excluded.skills,
+                last_updated = datetime('now')
+        `).run(cleanName, state, task, description, skills);
+    }
+    // === EVENT HOOKS FOR REAL-TIME BROADCASTS ===
+    static onMessageSaved = null;
+    static onMessageStatusUpdated = null;
+    static saveLog(log) {
+        const db = this.getDB();
+        const timestamp = new Date().toISOString();
+        const agent = log.agent.replace("@", "");
+        const maskedSummary = maskText(log.summary);
+        const maskedFindings = log.findings ? maskText(log.findings) : null;
+        const traceId = log.trace_id || "";
+        let lastId = 0;
+        const insert = db.transaction(() => {
+            let prevHash = AUDIT_CHAIN_GENESIS;
+            try {
+                const lastRow = db.prepare("SELECT hash FROM logs WHERE hash IS NOT NULL ORDER BY id DESC LIMIT 1").get();
+                if (lastRow && lastRow.hash) {
+                    prevHash = lastRow.hash;
+                }
+            }
+            catch { /* best-effort fallback to genesis */ }
+            const payload = buildAgentLogChainPayload({
+                prevHash,
+                timestamp,
+                agent,
+                action: log.action,
+                traceId: traceId || "",
+                status: log.status,
+                summary: maskedSummary,
+            });
+            const hash = sha256Hex(payload);
+            const result = db.prepare(`
+                INSERT INTO logs (timestamp, agent, action, trace_id, status, summary, findings, prev_hash, hash)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(timestamp, agent, log.action, log.trace_id || null, log.status, maskedSummary, maskedFindings, prevHash, hash);
+            lastId = Number(result.lastInsertRowid);
+        });
+        insert();
+        return lastId;
+    }
+    static verifyLogIntegrity() {
+        const db = this.getDB();
+        try {
+            const rows = db.prepare("SELECT * FROM logs ORDER BY id ASC").all();
+            const hashed = rows.filter((r) => r.hash);
+            if (hashed.length === 0) {
+                return { valid: true, checked: 0, reason: "No hashed log rows yet" };
+            }
+            return verifyHashChain(hashed, (row, prevHash) => buildAgentLogChainPayload({
+                prevHash,
+                agent: row.agent,
+                action: row.action,
+                traceId: row.trace_id || "",
+                status: row.status,
+                summary: row.summary,
+                timestamp: row.timestamp,
+            }));
+        }
+        catch (err) {
+            return { valid: false, reason: `Verification error: ${err.message}` };
+        }
+    }
+    static saveCost(cost) {
+        const db = this.getDB();
+        db.prepare(`
+            INSERT INTO costs (provider, model, input_tokens, output_tokens, cost, timestamp, trace_id)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(cost.provider, cost.model, cost.inputTokens, cost.outputTokens, cost.cost, cost.timestamp, cost.traceId || null);
+    }
+    static getAllCosts() {
+        const db = this.getDB();
+        const rows = db.prepare("SELECT * FROM costs ORDER BY timestamp ASC").all();
+        return rows.map(r => ({
+            provider: r.provider,
+            model: r.model,
+            inputTokens: r.input_tokens,
+            outputTokens: r.output_tokens,
+            cost: r.cost,
+            timestamp: r.timestamp,
+            traceId: r.trace_id || undefined
+        }));
+    }
+    static updateAgentStatus(name, state, task, lastUpdated) {
+        const cleanName = name.replace("@", "");
+        const timestamp = lastUpdated || new Date().toISOString();
+        this.getDB().prepare(`
+            INSERT INTO agents (name, state, task, last_updated)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(name) DO UPDATE SET
+                state = excluded.state,
+                task = excluded.task,
+                last_updated = excluded.last_updated
+        `).run(cleanName, state, task, timestamp);
+    }
+    static getAllAgents() {
+        const db = this.getDB();
+        const rows = db.prepare("SELECT * FROM agents").all();
+        return rows.map(r => ({
+            name: asAgentID(r.name),
+            state: r.state,
+            task: r.task,
+            last_updated: r.last_updated
+        }));
+    }
+    static saveMessage(msg) {
+        const from = msg.from.replace("@", "");
+        const to = msg.to.replace("@", "");
+        const cleanContent = maskText(msg.content);
+        this.getDB().prepare(`
+            INSERT INTO messages (timestamp, sender, receiver, category, content, trace_id, parent_id, status, priority, requires_approval)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(msg.timestamp, from, to, msg.category, cleanContent, msg.traceId, msg.parentId || null, msg.status, msg.priority, msg.requiresApproval ? 1 : 0);
+        if (this.onMessageSaved) {
+            try {
+                this.onMessageSaved({ traceId: msg.traceId, category: msg.category });
+            }
+            catch (err) {
+                logger.debug(`onMessageSaved hook error: ${err.message}`);
+            }
+        }
+    }
+    static getPendingMessages() {
+        const db = this.getDB();
+        const rows = db.prepare("SELECT * FROM messages WHERE status = 'PENDING'").all();
+        return rows.map(r => ({
+            id: asMessageID(r.id),
+            timestamp: r.timestamp,
+            from: asAgentID(r.sender),
+            to: asAgentID(r.receiver),
+            category: r.category,
+            content: maskText(r.content),
+            traceId: r.trace_id,
+            parentId: r.parent_id || undefined,
+            status: r.status,
+            priority: r.priority,
+            requiresApproval: r.requires_approval === 1
+        }));
+    }
+    static updateMessageStatus(id, status) {
+        this.getDB().prepare("UPDATE messages SET status = ? WHERE id = ?").run(status, id);
+        if (this.onMessageStatusUpdated) {
+            try {
+                this.onMessageStatusUpdated(id, status);
+            }
+            catch (err) {
+                logger.debug(`onMessageStatusUpdated hook error: ${err.message}`);
+            }
+        }
+    }
+    static saveTask(task) {
+        const agent = task.agent;
+        const cleanDesc = task.description;
+        this.getDB().prepare(`
+            INSERT INTO tasks (id, trace_id, description, agent, status, priority, dependencies, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                status = excluded.status,
+                priority = excluded.priority,
+                dependencies = excluded.dependencies,
+                agent = excluded.agent
+        `).run(task.id, task.traceId, cleanDesc, agent, task.status, task.priority, JSON.stringify(task.dependencies), task.createdAt || new Date().toISOString());
+    }
+    static getTasks(traceId) {
+        const db = this.getDB();
+        let rows;
+        if (traceId) {
+            rows = db.prepare("SELECT * FROM tasks WHERE trace_id = ?").all(traceId);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM tasks").all();
+        }
+        return rows.map(r => {
+            let deps;
+            try {
+                deps = JSON.parse(r.dependencies || "[]");
+            }
+            catch {
+                deps = [];
+            }
+            return {
+                id: asTaskID(r.id),
+                traceId: r.trace_id,
+                description: maskText(r.description),
+                agent: asAgentID(r.agent),
+                status: r.status,
+                priority: r.priority,
+                dependencies: deps,
+                createdAt: r.created_at
+            };
+        });
+    }
+    static getLogs(agentName) {
+        const db = this.getDB();
+        let rows;
+        const cleanName = agentName ? agentName.replace("@", "") : undefined;
+        if (cleanName) {
+            rows = db.prepare("SELECT * FROM logs WHERE agent = ? ORDER BY timestamp DESC").all(cleanName);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM logs ORDER BY timestamp DESC").all();
+        }
+        return rows.map(r => ({
+            id: asLogID(r.id),
+            timestamp: r.timestamp,
+            agent: asAgentID(r.agent),
+            action: r.action,
+            trace_id: r.trace_id || undefined,
+            status: r.status,
+            summary: maskText(r.summary),
+            findings: r.findings ? maskText(r.findings) : undefined,
+            prev_hash: r.prev_hash || undefined,
+            hash: r.hash || undefined
+        }));
+    }
+    static setMetadata(key, value) {
+        this.getDB().prepare(`
+            INSERT INTO metadata (key, value) VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        `).run(key, value);
+    }
+    static getMetadata(key) {
+        const row = this.getDB().prepare("SELECT value FROM metadata WHERE key = ?").get(key);
+        return row ? row.value : null;
+    }
+    // === LOOP COOLDOWN PERSISTENCE ===
+    static saveLoopCooldown(agent, cooldownUntil, detail, cooldownCount = 1) {
+        const cleanAgent = agent.replace("@", "");
+        this.getDB().prepare(`
+            INSERT INTO loop_cooldowns (agent, cooldown_until, detail, cooldown_count, updated_at)
+            VALUES (?, ?, ?, ?, datetime('now'))
+            ON CONFLICT(agent) DO UPDATE SET
+                cooldown_until = excluded.cooldown_until,
+                detail = excluded.detail,
+                cooldown_count = excluded.cooldown_count,
+                updated_at = datetime('now')
+        `).run(cleanAgent, cooldownUntil, detail, cooldownCount);
+    }
+    static getLoopCooldown(agent) {
+        const cleanAgent = agent.replace("@", "");
+        try {
+            const row = this.getDB().prepare("SELECT * FROM loop_cooldowns WHERE agent = ?").get(cleanAgent);
+            if (!row)
+                return null;
+            return {
+                agent: row.agent,
+                cooldownUntil: row.cooldown_until,
+                detail: row.detail,
+                cooldownCount: row.cooldown_count
+            };
+        }
+        catch (err) {
+            logger.debug(`Failed to get loop cooldown: ${err.message}`);
+            return null;
+        }
+    }
+    static clearLoopCooldown(agent) {
+        const cleanAgent = agent.replace("@", "");
+        const info = this.getDB().prepare("DELETE FROM loop_cooldowns WHERE agent = ?").run(cleanAgent);
+        return info.changes > 0;
+    }
+    static clearAllLoopCooldowns() {
+        try {
+            this.getDB().prepare("DELETE FROM loop_cooldowns").run();
+        }
+        catch (err) {
+            logger.debug(`Failed to clear all loop cooldowns: ${err.message}`);
+        }
+    }
+    static listActiveLoopCooldowns() {
+        const now = Date.now();
+        try {
+            const rows = this.getDB().prepare("SELECT * FROM loop_cooldowns WHERE cooldown_until > ?").all(now);
+            return rows.map(r => ({
+                agent: r.agent,
+                cooldownUntil: r.cooldown_until,
+                detail: r.detail,
+                cooldownCount: r.cooldown_count
+            }));
+        }
+        catch (err) {
+            logger.debug(`Failed to list active loop cooldowns: ${err.message}`);
+            return [];
+        }
+    }
+    static purgeExpiredLoopCooldowns() {
+        const now = Date.now();
+        try {
+            const info = this.getDB().prepare("DELETE FROM loop_cooldowns WHERE cooldown_until <= ?").run(now);
+            return info.changes;
+        }
+        catch (err) {
+            logger.debug(`Failed to purge expired loop cooldowns: ${err.message}`);
+            return 0;
+        }
+    }
+    // === APPROVALS PERSISTENCE ===
+    static saveApproval(app) {
+        this.saveApprovalRequest(app);
+    }
+    static saveApprovalRequest(request) {
+        const db = this.getDB();
+        db.prepare(`
+            INSERT OR REPLACE INTO approvals (
+                trace_id, tool_name, agent, risk_score, risk_level, reason, args,
+                created_at, expires_at, status, passcode
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(request.traceId, request.toolName, request.agent, request.riskScore, request.riskLevel, request.reason, JSON.stringify(request.args), request.createdAt, request.expiresAt, request.status || "PENDING", request.passcode || null);
+    }
+    static getApproval(traceId) {
+        try {
+            const row = this.getDB().prepare("SELECT * FROM approvals WHERE trace_id = ?").get(traceId);
+            if (!row)
+                return null;
+            return {
+                traceId: row.trace_id,
+                toolName: row.tool_name,
+                agent: row.agent,
+                riskScore: row.risk_score,
+                riskLevel: row.risk_level,
+                reason: row.reason,
+                args: JSON.parse(row.args || "{}"),
+                createdAt: row.created_at,
+                expiresAt: row.expires_at,
+                status: row.status,
+                passcode: row.passcode || undefined
+            };
+        }
+        catch (err) {
+            logger.debug(`Failed to get approval: ${err.message}`);
+            return null;
+        }
+    }
+    static getPendingApprovals() {
+        try {
+            const rows = this.getDB().prepare("SELECT * FROM approvals WHERE status = 'PENDING'").all();
+            return rows.map(row => ({
+                traceId: row.trace_id,
+                toolName: row.tool_name,
+                agent: row.agent,
+                riskScore: row.risk_score,
+                riskLevel: row.risk_level,
+                reason: row.reason,
+                args: JSON.parse(row.args || "{}"),
+                createdAt: row.created_at,
+                expiresAt: row.expires_at,
+                status: row.status,
+                passcode: row.passcode || undefined
+            }));
+        }
+        catch (err) {
+            logger.debug(`Failed to get pending approvals: ${err.message}`);
+            return [];
+        }
+    }
+    static updateApprovalStatus(traceId, status) {
+        this.getDB().prepare("UPDATE approvals SET status = ? WHERE trace_id = ?").run(status, traceId);
+    }
+    static clearAllApprovals() {
+        try {
+            this.getDB().prepare("DELETE FROM approvals").run();
+        }
+        catch (err) {
+            logger.debug(`Failed to clear approvals: ${err.message}`);
+        }
+    }
+    // === DISCIPLINE PERSISTENCE ===
+    static saveDiscipline(agent, stats) {
+        const cleanAgent = agent.replace("@", "");
+        this.getDB().prepare(`
+            INSERT INTO discipline (agent, total_calls, violations, last_violation, cooldown_until, updated_at)
+            VALUES (?, ?, ?, ?, ?, datetime('now'))
+            ON CONFLICT(agent) DO UPDATE SET
+                total_calls = excluded.total_calls,
+                violations = excluded.violations,
+                last_violation = excluded.last_violation,
+                cooldown_until = excluded.cooldown_until,
+                updated_at = datetime('now')
+        `).run(cleanAgent, stats.totalCalls, stats.violations, stats.lastViolation, stats.cooldownUntil);
+    }
+    static getDiscipline(agent) {
+        const cleanAgent = agent.replace("@", "");
+        try {
+            const row = this.getDB().prepare("SELECT * FROM discipline WHERE agent = ?").get(cleanAgent);
+            if (!row)
+                return null;
+            return {
+                agent: row.agent,
+                totalCalls: row.total_calls,
+                violations: row.violations,
+                lastViolation: row.last_violation,
+                cooldownUntil: row.cooldown_until
+            };
+        }
+        catch (err) {
+            logger.debug(`Failed to get discipline: ${err.message}`);
+            return null;
+        }
+    }
+    static getAllDiscipline() {
+        try {
+            const rows = this.getDB().prepare("SELECT * FROM discipline").all();
+            return rows.map(row => ({
+                agent: row.agent,
+                totalCalls: row.total_calls,
+                violations: row.violations,
+                lastViolation: row.last_violation,
+                cooldownUntil: row.cooldown_until
+            }));
+        }
+        catch (err) {
+            logger.debug(`Failed to get all discipline: ${err.message}`);
+            return [];
+        }
+    }
+    static clearAllDiscipline() {
+        try {
+            this.getDB().prepare("DELETE FROM discipline").run();
+        }
+        catch (err) {
+            logger.debug(`Failed to clear discipline: ${err.message}`);
+        }
+    }
+    static checkIntegrity() {
+        try {
+            const db = this.getDB();
+            const rows = db.pragma("quick_check");
+            const status = rows && rows[0] ? rows[0].quick_check : "unknown";
+            return { ok: status === "ok", message: status };
+        }
+        catch (err) {
+            return { ok: false, message: err.message };
+        }
+    }
+    static reset() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}
+/** Canonical alias */
+export const Storage = AtabeyStorage;
+//# sourceMappingURL=storage.js.map