aimeat 1.2.0

package/dist/src/storage/providers/sqlite/index.js

@@ -0,0 +1,4156 @@
+import Database from 'better-sqlite3';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { initializeSchema } from './schema.js';
+import { matchWildcardPattern, consentMatchPattern } from '../../pattern-utils.js';
+import { matchesRecipient } from '../../../services/consent.js';
+import { parseGaiiLoose } from '../../../utils/gaii.js';
+export class SqliteStorage {
+    db;
+    chunkedUploads = new Map();
+    constructor(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('busy_timeout = 5000');
+        this.db.pragma('foreign_keys = ON');
+        initializeSchema(this.db);
+    }
+    /** Close the database connection */
+    close() {
+        this.db.close();
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Owners ──
+    // ══════════════════════════════════════════════════════════
+    async createOwner(owner) {
+        try {
+            this.db.prepare(`INSERT INTO owners (name, displayName, publicKey, roles, createdAt)
+         VALUES (?, ?, ?, ?, ?)`).run(owner.name, owner.displayName ?? null, owner.publicKey, JSON.stringify(owner.roles), owner.createdAt);
+            return owner;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('NAME_TAKEN', { cause: err });
+            throw err;
+        }
+    }
+    async getOwner(name) {
+        const row = this.db.prepare('SELECT * FROM owners WHERE name = ?').get(name);
+        return row ? this.deserializeOwner(row) : null;
+    }
+    async listOwners() {
+        const rows = this.db.prepare('SELECT * FROM owners').all();
+        return rows.map(r => this.deserializeOwner(r));
+    }
+    async updateOwner(name, updates) {
+        const existing = await this.getOwner(name);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE owners SET displayName = ?, publicKey = ?, roles = ?, createdAt = ? WHERE name = ?`).run(updated.displayName ?? null, updated.publicKey, JSON.stringify(updated.roles), updated.createdAt, name);
+        return updated;
+    }
+    async deleteOwner(name) {
+        const txn = this.db.transaction(() => {
+            // 1. Get all agents belonging to this owner
+            const agentRows = this.db.prepare('SELECT gaii FROM agents WHERE owner = ?').all(name);
+            const agentGaiis = agentRows.map(r => r.gaii);
+            // 2. Cascade delete all agent-related data for each agent
+            for (const gaii of agentGaiis) {
+                this.cascadeDeleteAgentData(gaii);
+            }
+            // 3. Delete all agents for this owner
+            this.db.prepare('DELETE FROM agents WHERE owner = ?').run(name);
+            // 4. Delete GHII records for this owner
+            this.db.prepare('DELETE FROM ghiis WHERE ownerName = ?').run(name);
+            // 5. Delete personal nodes and their mailbox items & push subscriptions
+            const nodeRows = this.db.prepare('SELECT nodeId FROM personal_nodes WHERE ownerName = ?').all(name);
+            for (const node of nodeRows) {
+                this.db.prepare('DELETE FROM mailbox_items WHERE personalNodeId = ?').run(node.nodeId);
+                this.db.prepare('DELETE FROM personal_push_subscriptions WHERE personalNodeId = ?').run(node.nodeId);
+                this.db.prepare('DELETE FROM notification_preferences WHERE personalNodeId = ?').run(node.nodeId);
+            }
+            this.db.prepare('DELETE FROM personal_nodes WHERE ownerName = ?').run(name);
+            // 6. Delete push subscriptions for this owner
+            this.db.prepare('DELETE FROM push_subscriptions WHERE ownerName = ?').run(name);
+            this.db.prepare('DELETE FROM personal_push_subscriptions WHERE ownerName = ?').run(name);
+            // 7. Delete listings for this owner
+            this.db.prepare('DELETE FROM listings WHERE ownerName = ?').run(name);
+            // 8. Delete purchases for this owner (as buyer or seller)
+            this.db.prepare('DELETE FROM purchases WHERE buyerOwner = ? OR sellerOwner = ?').run(name, name);
+            // 9. Delete chat instances for this owner
+            this.db.prepare('DELETE FROM chat_instances WHERE ownerName = ?').run(name);
+            // 10. Delete email verifications for this owner
+            this.db.prepare('DELETE FROM email_verifications WHERE ownerName = ?').run(name);
+            // 11. Delete the owner record itself
+            const result = this.db.prepare('DELETE FROM owners WHERE name = ?').run(name);
+            return result.changes > 0;
+        });
+        return txn();
+    }
+    /**
+     * Cascade-delete all data associated with a single agent GAII.
+     * Called inside a transaction by both deleteOwner and deleteAgent.
+     */
+    cascadeDeleteAgentData(gaii) {
+        // Memory
+        this.db.prepare('DELETE FROM memory WHERE ownerGaii = ?').run(gaii);
+        // Micro-memory
+        this.db.prepare('DELETE FROM micro_memory WHERE gaii = ?').run(gaii);
+        // Actions
+        this.db.prepare('DELETE FROM actions WHERE providerGaii = ?').run(gaii);
+        // Work (as provider or requester) — also clean up related disputes
+        const workRows = this.db.prepare('SELECT trackingCode FROM work WHERE providerGaii = ? OR requesterGaii = ?').all(gaii, gaii);
+        for (const w of workRows) {
+            this.db.prepare('DELETE FROM dispute_audit WHERE disputeId IN (SELECT id FROM disputes WHERE trackingCode = ?)').run(w.trackingCode);
+            this.db.prepare('DELETE FROM disputes WHERE trackingCode = ?').run(w.trackingCode);
+        }
+        this.db.prepare('DELETE FROM work WHERE providerGaii = ? OR requesterGaii = ?').run(gaii, gaii);
+        // Wallet transactions
+        this.db.prepare('DELETE FROM wallet_transactions WHERE gaii = ?').run(gaii);
+        // Board posts authored by this agent
+        this.db.prepare('DELETE FROM board_posts WHERE authorGaii = ?').run(gaii);
+        // Board subscriptions
+        this.db.prepare('DELETE FROM board_subscriptions WHERE gaii = ?').run(gaii);
+        // Boards owned by this agent — also delete their posts and subscriptions
+        const boardRows = this.db.prepare('SELECT id FROM boards WHERE ownerGaii = ?').all(gaii);
+        for (const b of boardRows) {
+            this.db.prepare('DELETE FROM board_posts WHERE boardId = ?').run(b.id);
+            this.db.prepare('DELETE FROM board_subscriptions WHERE boardId = ?').run(b.id);
+        }
+        this.db.prepare('DELETE FROM boards WHERE ownerGaii = ?').run(gaii);
+        // Consents and consent audit
+        this.db.prepare('DELETE FROM consent_audit WHERE ownerGaii = ?').run(gaii);
+        this.db.prepare('DELETE FROM consents WHERE ownerGaii = ?').run(gaii);
+        // Storage files
+        this.db.prepare('DELETE FROM storage_files WHERE ownerGaii = ?').run(gaii);
+        // Matches (as profileA or profileB)
+        this.db.prepare('DELETE FROM matches WHERE profileA = ? OR profileB = ?').run(gaii, gaii);
+        // Flags raised by this agent
+        this.db.prepare('DELETE FROM flags WHERE flaggedBy = ?').run(gaii);
+        // Escrow holds
+        this.db.prepare('DELETE FROM escrow_holds WHERE fromGaii = ?').run(gaii);
+        // OTKs (one-time keys)
+        this.db.prepare('DELETE FROM otks WHERE ownerGaii = ?').run(gaii);
+        // OAuth refresh tokens and approvals for this agent
+        this.db.prepare('DELETE FROM oauth_refresh_tokens WHERE gaii = ?').run(gaii);
+        this.db.prepare('DELETE FROM oauth_approvals WHERE gaii = ?').run(gaii);
+    }
+    deserializeOwner(row) {
+        return {
+            name: row.name,
+            displayName: row.displayName ?? undefined,
+            publicKey: row.publicKey,
+            roles: JSON.parse(row.roles),
+            createdAt: row.createdAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Agents ──
+    // ══════════════════════════════════════════════════════════
+    async createAgent(agent) {
+        try {
+            this.db.prepare(`INSERT INTO agents (gaii, name, owner, displayName, description, capabilities, publicKey, trustScore, morselBalance, createdAt, lastSeen, semantic, allowedOrigins, defaultScopes)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(agent.gaii, agent.name, agent.owner, agent.displayName ?? null, agent.description ?? null, JSON.stringify(agent.capabilities), agent.publicKey, agent.trustScore, agent.morselBalance, agent.createdAt, agent.lastSeen, agent.semantic ? JSON.stringify(agent.semantic) : null, agent.allowedOrigins ? JSON.stringify(agent.allowedOrigins) : null, agent.defaultScopes ? JSON.stringify(agent.defaultScopes) : null);
+            return agent;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('NAME_TAKEN', { cause: err });
+            throw err;
+        }
+    }
+    async getAgent(gaii) {
+        const row = this.db.prepare('SELECT * FROM agents WHERE gaii = ?').get(gaii);
+        return row ? this.deserializeAgent(row) : null;
+    }
+    async getAgentsByOwner(owner) {
+        const rows = this.db.prepare('SELECT * FROM agents WHERE owner = ?').all(owner);
+        return rows.map(r => this.deserializeAgent(r));
+    }
+    async updateAgent(gaii, updates) {
+        const existing = await this.getAgent(gaii);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE agents SET name = ?, owner = ?, displayName = ?, description = ?, capabilities = ?,
+       publicKey = ?, trustScore = ?, morselBalance = ?, createdAt = ?, lastSeen = ?, semantic = ?,
+       allowedOrigins = ?, defaultScopes = ?
+       WHERE gaii = ?`).run(updated.name, updated.owner, updated.displayName ?? null, updated.description ?? null, JSON.stringify(updated.capabilities), updated.publicKey, updated.trustScore, updated.morselBalance, updated.createdAt, updated.lastSeen, updated.semantic ? JSON.stringify(updated.semantic) : null, updated.allowedOrigins ? JSON.stringify(updated.allowedOrigins) : null, updated.defaultScopes ? JSON.stringify(updated.defaultScopes) : null, gaii);
+        return updated;
+    }
+    async deleteAgent(gaii) {
+        const txn = this.db.transaction(() => {
+            // Cascade delete all agent-related data
+            this.cascadeDeleteAgentData(gaii);
+            // Delete the agent record itself
+            const result = this.db.prepare('DELETE FROM agents WHERE gaii = ?').run(gaii);
+            return result.changes > 0;
+        });
+        return txn();
+    }
+    async listAgents() {
+        const rows = this.db.prepare('SELECT * FROM agents').all();
+        return rows.map(r => this.deserializeAgent(r));
+    }
+    /**
+     * Resolve any identity (GAII, GHII, bare owner) to the owner's GHII identifier.
+     * All balance operations go through GHII — agents don't have their own balance.
+     */
+    resolveGhii(identity) {
+        // GHII format: owner@node (no #)
+        if (!identity.includes('#') && identity.includes('@'))
+            return identity;
+        // GAII format: agent#owner@node → extract owner → lookup GHII
+        if (identity.includes('#')) {
+            const hashIdx = identity.indexOf('#');
+            const atIdx = identity.lastIndexOf('@');
+            if (atIdx > hashIdx) {
+                const owner = identity.slice(hashIdx + 1, atIdx);
+                const row = this.db.prepare('SELECT ghii FROM ghiis WHERE username = ?').get(owner);
+                return row?.ghii ?? null;
+            }
+        }
+        // Bare owner name → lookup GHII
+        const row = this.db.prepare('SELECT ghii FROM ghiis WHERE username = ?').get(identity);
+        return row?.ghii ?? null;
+    }
+    async debitBalance(gaii, amount) {
+        const ghii = this.resolveGhii(gaii);
+        if (!ghii)
+            return false;
+        const result = this.db.prepare(`UPDATE ghiis SET morselBalance = COALESCE(morselBalance, 0) - ? WHERE ghii = ? AND COALESCE(morselBalance, 0) >= ?`).run(amount, ghii, amount);
+        return result.changes > 0;
+    }
+    async creditBalance(gaii, amount) {
+        const ghii = this.resolveGhii(gaii);
+        if (!ghii)
+            return false;
+        const result = this.db.prepare(`UPDATE ghiis SET morselBalance = COALESCE(morselBalance, 0) + ? WHERE ghii = ?`).run(amount, ghii);
+        return result.changes > 0;
+    }
+    async creditBalanceCapped(gaii, amount, cap) {
+        const ghii = this.resolveGhii(gaii);
+        if (!ghii)
+            return 0;
+        const txn = this.db.transaction(() => {
+            const row = this.db.prepare('SELECT morselBalance FROM ghiis WHERE ghii = ?').get(ghii);
+            if (!row)
+                return 0;
+            const oldBalance = row.morselBalance ?? 0;
+            if (oldBalance >= cap)
+                return 0;
+            const actualCredit = Math.min(amount, cap - oldBalance);
+            if (actualCredit <= 0)
+                return 0;
+            this.db.prepare('UPDATE ghiis SET morselBalance = COALESCE(morselBalance, 0) + ? WHERE ghii = ?').run(actualCredit, ghii);
+            return actualCredit;
+        });
+        return txn();
+    }
+    async transferBalance(fromGaii, toGaii, amount) {
+        const fromGhii = this.resolveGhii(fromGaii);
+        const toGhii = this.resolveGhii(toGaii);
+        if (!fromGhii || !toGhii)
+            return false;
+        if (fromGhii === toGhii)
+            return true; // Same owner — no-op
+        const txn = this.db.transaction(() => {
+            const debit = this.db.prepare(`UPDATE ghiis SET morselBalance = COALESCE(morselBalance, 0) - ? WHERE ghii = ? AND COALESCE(morselBalance, 0) >= ?`).run(amount, fromGhii, amount);
+            if (debit.changes === 0)
+                return false;
+            this.db.prepare(`UPDATE ghiis SET morselBalance = COALESCE(morselBalance, 0) + ? WHERE ghii = ?`).run(amount, toGhii);
+            return true;
+        });
+        return txn();
+    }
+    deserializeAgent(row) {
+        const record = {
+            gaii: row.gaii,
+            name: row.name,
+            owner: row.owner,
+            capabilities: JSON.parse(row.capabilities),
+            publicKey: row.publicKey,
+            trustScore: row.trustScore,
+            morselBalance: row.morselBalance,
+            createdAt: row.createdAt,
+            lastSeen: row.lastSeen,
+        };
+        if (row.displayName)
+            record.displayName = row.displayName;
+        if (row.description)
+            record.description = row.description;
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        if (row.allowedOrigins)
+            record.allowedOrigins = JSON.parse(row.allowedOrigins);
+        if (row.defaultScopes)
+            record.defaultScopes = JSON.parse(row.defaultScopes);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Memory ──
+    // ══════════════════════════════════════════════════════════
+    async setMemory(record) {
+        const existing = await this.getMemory(record.ownerGaii, record.key);
+        if (existing) {
+            record.version = existing.version + 1;
+            this.db.prepare(`UPDATE memory SET value = ?, visibility = ?, tags = ?, ttlHours = ?, version = ?,
+         createdAt = ?, updatedAt = ?, flagCount = ?, allowedOrigins = ? WHERE ownerGaii = ? AND key = ?`).run(JSON.stringify(record.value), record.visibility, JSON.stringify(record.tags), record.ttlHours, record.version, record.createdAt, record.updatedAt, record.flagCount ?? 0, record.allowedOrigins ? JSON.stringify(record.allowedOrigins) : null, record.ownerGaii, record.key);
+        }
+        else {
+            this.db.prepare(`INSERT INTO memory (ownerGaii, key, value, visibility, tags, ttlHours, version, createdAt, updatedAt, flagCount, allowedOrigins)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.ownerGaii, record.key, JSON.stringify(record.value), record.visibility, JSON.stringify(record.tags), record.ttlHours, record.version, record.createdAt, record.updatedAt, record.flagCount ?? 0, record.allowedOrigins ? JSON.stringify(record.allowedOrigins) : null);
+        }
+        return record;
+    }
+    async setMemoryIfVersion(record, expectedVersion) {
+        const result = this.db.prepare(`UPDATE memory SET value = ?, visibility = ?, tags = ?, ttlHours = ?, version = ?,
+       updatedAt = ?, flagCount = ?, allowedOrigins = ? WHERE ownerGaii = ? AND key = ? AND version = ?`).run(JSON.stringify(record.value), record.visibility, JSON.stringify(record.tags), record.ttlHours, record.version, record.updatedAt, record.flagCount ?? 0, record.allowedOrigins ? JSON.stringify(record.allowedOrigins) : null, record.ownerGaii, record.key, expectedVersion);
+        if (result.changes === 0)
+            return null; // version conflict
+        return record;
+    }
+    isMemoryExpired(record) {
+        if (!record.ttlHours)
+            return false;
+        const createdMs = new Date(record.createdAt).getTime();
+        return Date.now() > createdMs + record.ttlHours * 3_600_000;
+    }
+    async getMemory(ownerGaii, key) {
+        const row = this.db.prepare('SELECT * FROM memory WHERE ownerGaii = ? AND key = ?').get(ownerGaii, key);
+        if (!row)
+            return null;
+        const record = this.deserializeMemory(row);
+        if (this.isMemoryExpired(record)) {
+            this.db.prepare('DELETE FROM memory WHERE ownerGaii = ? AND key = ?').run(ownerGaii, key);
+            return null;
+        }
+        return record;
+    }
+    async listMemory(ownerGaii, opts) {
+        let sql = 'SELECT * FROM memory WHERE ownerGaii = ?';
+        const params = [ownerGaii];
+        if (opts?.prefix) {
+            sql += ' AND key LIKE ?';
+            params.push(opts.prefix + '%');
+        }
+        if (opts?.visibility) {
+            sql += ' AND visibility = ?';
+            params.push(opts.visibility);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        const results = [];
+        for (const row of rows) {
+            const record = this.deserializeMemory(row);
+            if (this.isMemoryExpired(record)) {
+                this.db.prepare('DELETE FROM memory WHERE ownerGaii = ? AND key = ?').run(record.ownerGaii, record.key);
+                continue;
+            }
+            if (opts?.tags?.length) {
+                const hasTags = opts.tags.every(t => record.tags.includes(t));
+                if (!hasTags)
+                    continue;
+            }
+            if (opts?.maxFlags !== undefined && (record.flagCount ?? 0) > opts.maxFlags)
+                continue;
+            results.push(record);
+        }
+        return results;
+    }
+    async listAllMemory(opts) {
+        let whereClauses = '';
+        const params = [];
+        if (opts?.ownerPrefix) {
+            whereClauses += ' AND ownerGaii LIKE ?';
+            params.push(opts.ownerPrefix + '%');
+        }
+        if (opts?.prefix) {
+            whereClauses += ' AND key LIKE ?';
+            params.push(opts.prefix + '%');
+        }
+        if (opts?.visibility) {
+            whereClauses += ' AND visibility = ?';
+            params.push(opts.visibility);
+        }
+        const whereStr = whereClauses ? ' WHERE ' + whereClauses.slice(5) : '';
+        const countRow = this.db.prepare('SELECT COUNT(*) as cnt FROM memory' + whereStr).get(...params);
+        const total = countRow.cnt;
+        const limit = opts?.limit ?? 50;
+        const offset = opts?.offset ?? 0;
+        const rows = this.db.prepare('SELECT * FROM memory' + whereStr + ' ORDER BY updatedAt DESC LIMIT ? OFFSET ?').all(...params, limit, offset);
+        const items = [];
+        for (const row of rows) {
+            const record = this.deserializeMemory(row);
+            if (this.isMemoryExpired(record)) {
+                this.db.prepare('DELETE FROM memory WHERE ownerGaii = ? AND key = ?').run(record.ownerGaii, record.key);
+                continue;
+            }
+            items.push(record);
+        }
+        return { items, total };
+    }
+    async deleteMemory(ownerGaii, key) {
+        const result = this.db.prepare('DELETE FROM memory WHERE ownerGaii = ? AND key = ?').run(ownerGaii, key);
+        return result.changes > 0;
+    }
+    async deleteAllMemory(ownerGaii) {
+        const result = this.db.prepare('DELETE FROM memory WHERE ownerGaii = ?').run(ownerGaii);
+        return result.changes;
+    }
+    async incrementMemoryFlagCount(ownerGaii, key) {
+        this.db.prepare('UPDATE memory SET flagCount = COALESCE(flagCount, 0) + 1 WHERE ownerGaii = ? AND key = ?').run(ownerGaii, key);
+    }
+    async searchMemory(ownerGaii, query, opts) {
+        const q = query.toLowerCase();
+        let sql = 'SELECT * FROM memory WHERE ownerGaii = ?';
+        const params = [ownerGaii];
+        if (opts?.visibility) {
+            sql += ' AND visibility = ?';
+            params.push(opts.visibility);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        const results = [];
+        for (const row of rows) {
+            const record = this.deserializeMemory(row);
+            if (this.isMemoryExpired(record)) {
+                this.db.prepare('DELETE FROM memory WHERE ownerGaii = ? AND key = ?').run(record.ownerGaii, record.key);
+                continue;
+            }
+            if (opts?.maxFlags !== undefined && (record.flagCount ?? 0) > opts.maxFlags)
+                continue;
+            const valStr = typeof record.value === 'string' ? record.value : JSON.stringify(record.value);
+            if (record.key.toLowerCase().includes(q) ||
+                valStr.toLowerCase().includes(q) ||
+                record.tags.some(t => t.toLowerCase().includes(q))) {
+                results.push(record);
+            }
+        }
+        return results;
+    }
+    deserializeMemory(row) {
+        const record = {
+            key: row.key,
+            ownerGaii: row.ownerGaii,
+            value: JSON.parse(row.value),
+            visibility: row.visibility,
+            tags: JSON.parse(row.tags),
+            ttlHours: row.ttlHours,
+            version: row.version,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.flagCount !== null && row.flagCount !== undefined) {
+            record.flagCount = row.flagCount;
+        }
+        if (row.allowedOrigins)
+            record.allowedOrigins = JSON.parse(row.allowedOrigins);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Actions ──
+    // ══════════════════════════════════════════════════════════
+    async createAction(action) {
+        try {
+            this.db.prepare(`INSERT INTO actions (providerGaii, id, displayName, description, category, inputSchema, outputSchema, pricing, estimatedTimeSeconds, maxInputSizeBytes, tags, webhookUrl, createdAt, updatedAt, semantic)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(action.providerGaii, action.id, action.displayName, action.description, action.category ?? null, JSON.stringify(action.inputSchema), JSON.stringify(action.outputSchema), JSON.stringify(action.pricing), action.estimatedTimeSeconds ?? null, action.maxInputSizeBytes ?? null, JSON.stringify(action.tags), action.webhookUrl ?? null, action.createdAt, action.updatedAt, action.semantic ? JSON.stringify(action.semantic) : null);
+            return action;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('ACTION_EXISTS', { cause: err });
+            throw err;
+        }
+    }
+    async getAction(id, providerGaii) {
+        const row = this.db.prepare('SELECT * FROM actions WHERE providerGaii = ? AND id = ?').get(providerGaii, id);
+        return row ? this.deserializeAction(row) : null;
+    }
+    async listActions(opts) {
+        const rows = this.db.prepare('SELECT * FROM actions').all();
+        let results = rows.map(r => this.deserializeAction(r));
+        if (opts?.category) {
+            results = results.filter(a => a.category === opts.category);
+        }
+        if (opts?.search) {
+            const q = opts.search.toLowerCase();
+            results = results.filter(a => a.displayName.toLowerCase().includes(q) ||
+                a.description.toLowerCase().includes(q) ||
+                a.tags.some(t => t.toLowerCase().includes(q)));
+        }
+        return results;
+    }
+    async deleteAction(id, providerGaii) {
+        const result = this.db.prepare('DELETE FROM actions WHERE providerGaii = ? AND id = ?').run(providerGaii, id);
+        return result.changes > 0;
+    }
+    async deleteActionsByProvider(gaii) {
+        const result = this.db.prepare('DELETE FROM actions WHERE providerGaii = ?').run(gaii);
+        return result.changes;
+    }
+    async listActionsByProvider(gaii) {
+        const rows = this.db.prepare('SELECT * FROM actions WHERE providerGaii = ?').all(gaii);
+        return rows.map(r => this.deserializeAction(r));
+    }
+    async updateAction(id, providerGaii, updates) {
+        const existing = await this.getAction(id, providerGaii);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE actions SET displayName = ?, description = ?, category = ?, inputSchema = ?,
+       outputSchema = ?, pricing = ?, estimatedTimeSeconds = ?, maxInputSizeBytes = ?,
+       tags = ?, webhookUrl = ?, createdAt = ?, updatedAt = ?, semantic = ?
+       WHERE providerGaii = ? AND id = ?`).run(updated.displayName, updated.description, updated.category ?? null, JSON.stringify(updated.inputSchema), JSON.stringify(updated.outputSchema), JSON.stringify(updated.pricing), updated.estimatedTimeSeconds ?? null, updated.maxInputSizeBytes ?? null, JSON.stringify(updated.tags), updated.webhookUrl ?? null, updated.createdAt, updated.updatedAt, updated.semantic ? JSON.stringify(updated.semantic) : null, providerGaii, id);
+        return updated;
+    }
+    deserializeAction(row) {
+        const record = {
+            id: row.id,
+            providerGaii: row.providerGaii,
+            displayName: row.displayName,
+            description: row.description,
+            inputSchema: JSON.parse(row.inputSchema),
+            outputSchema: JSON.parse(row.outputSchema),
+            pricing: JSON.parse(row.pricing),
+            tags: JSON.parse(row.tags),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.category)
+            record.category = row.category;
+        if (row.estimatedTimeSeconds !== null)
+            record.estimatedTimeSeconds = row.estimatedTimeSeconds;
+        if (row.maxInputSizeBytes !== null)
+            record.maxInputSizeBytes = row.maxInputSizeBytes;
+        if (row.webhookUrl)
+            record.webhookUrl = row.webhookUrl;
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Work ──
+    // ══════════════════════════════════════════════════════════
+    async createWork(work) {
+        this.db.prepare(`INSERT INTO work (trackingCode, status, actionId, providerGaii, requesterGaii, input, output, cost, ttlExpiresAt, callbackUrl, rating, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(work.trackingCode, work.status, work.actionId, work.providerGaii, work.requesterGaii, JSON.stringify(work.input), work.output ? JSON.stringify(work.output) : null, JSON.stringify(work.cost), work.ttlExpiresAt, work.callbackUrl ?? null, work.rating ? JSON.stringify(work.rating) : null, work.createdAt, work.updatedAt);
+        return work;
+    }
+    async getWork(trackingCode) {
+        const row = this.db.prepare('SELECT * FROM work WHERE trackingCode = ?').get(trackingCode);
+        return row ? this.deserializeWork(row) : null;
+    }
+    async updateWork(trackingCode, updates) {
+        const existing = await this.getWork(trackingCode);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE work SET status = ?, actionId = ?, providerGaii = ?, requesterGaii = ?,
+       input = ?, output = ?, cost = ?, ttlExpiresAt = ?, callbackUrl = ?, rating = ?,
+       createdAt = ?, updatedAt = ? WHERE trackingCode = ?`).run(updated.status, updated.actionId, updated.providerGaii, updated.requesterGaii, JSON.stringify(updated.input), updated.output ? JSON.stringify(updated.output) : null, JSON.stringify(updated.cost), updated.ttlExpiresAt, updated.callbackUrl ?? null, updated.rating ? JSON.stringify(updated.rating) : null, updated.createdAt, updated.updatedAt, trackingCode);
+        return updated;
+    }
+    async listWorkByProvider(gaii) {
+        const rows = this.db.prepare('SELECT * FROM work WHERE providerGaii = ?').all(gaii);
+        return rows.map(r => this.deserializeWork(r));
+    }
+    async listWorkByRequester(gaii) {
+        const rows = this.db.prepare('SELECT * FROM work WHERE requesterGaii = ?').all(gaii);
+        return rows.map(r => this.deserializeWork(r));
+    }
+    async listAllWork(limit = 10000) {
+        const rows = this.db.prepare('SELECT * FROM work ORDER BY createdAt DESC LIMIT ?').all(Math.min(limit, 10000));
+        return rows.map(r => this.deserializeWork(r));
+    }
+    deserializeWork(row) {
+        const record = {
+            trackingCode: row.trackingCode,
+            status: row.status,
+            actionId: row.actionId,
+            providerGaii: row.providerGaii,
+            requesterGaii: row.requesterGaii,
+            input: JSON.parse(row.input),
+            cost: JSON.parse(row.cost),
+            ttlExpiresAt: row.ttlExpiresAt,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.output)
+            record.output = JSON.parse(row.output);
+        if (row.callbackUrl)
+            record.callbackUrl = row.callbackUrl;
+        if (row.rating)
+            record.rating = JSON.parse(row.rating);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Wallet Transactions ──
+    // ══════════════════════════════════════════════════════════
+    async addTransaction(tx) {
+        this.db.prepare(`INSERT INTO wallet_transactions (id, gaii, type, amount, counterpartyGaii, trackingCode, timestamp)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(tx.id, tx.gaii, tx.type, tx.amount, tx.counterpartyGaii ?? null, tx.trackingCode ?? null, tx.timestamp);
+        return tx;
+    }
+    async getTransactions(gaii, limit = 50) {
+        const rows = this.db.prepare('SELECT * FROM wallet_transactions WHERE gaii = ? ORDER BY timestamp DESC LIMIT ?').all(gaii, limit);
+        return rows.reverse().map(r => this.deserializeTransaction(r));
+    }
+    async listAllTransactions(limit = 10000) {
+        const rows = this.db.prepare('SELECT * FROM wallet_transactions ORDER BY timestamp DESC LIMIT ?').all(Math.min(limit, 10000));
+        return rows.map(r => this.deserializeTransaction(r));
+    }
+    async deleteTransactions(gaii) {
+        const result = this.db.prepare('DELETE FROM wallet_transactions WHERE gaii = ?').run(gaii);
+        return result.changes;
+    }
+    deserializeTransaction(row) {
+        const record = {
+            id: row.id,
+            gaii: row.gaii,
+            type: row.type,
+            amount: row.amount,
+            timestamp: row.timestamp,
+        };
+        if (row.counterpartyGaii)
+            record.counterpartyGaii = row.counterpartyGaii;
+        if (row.trackingCode)
+            record.trackingCode = row.trackingCode;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Boards ──
+    // ══════════════════════════════════════════════════════════
+    async createBoard(board) {
+        this.db.prepare(`INSERT INTO boards (id, name, description, visibility, ownerGaii, allowedGaiis, createdAt, semantic)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(board.id, board.name, board.description ?? null, board.visibility, board.ownerGaii, JSON.stringify(board.allowedGaiis), board.createdAt, board.semantic ? JSON.stringify(board.semantic) : null);
+        return board;
+    }
+    async getBoard(id) {
+        const row = this.db.prepare('SELECT * FROM boards WHERE id = ?').get(id);
+        return row ? this.deserializeBoard(row) : null;
+    }
+    async listBoards(opts) {
+        let sql = 'SELECT * FROM boards WHERE 1=1';
+        const params = [];
+        if (opts?.visibility) {
+            sql += ' AND visibility = ?';
+            params.push(opts.visibility);
+        }
+        if (opts?.ownerGaii) {
+            sql += ' AND ownerGaii = ?';
+            params.push(opts.ownerGaii);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeBoard(r));
+    }
+    async updateBoardVisibility(id, visibility) {
+        const result = this.db.prepare('UPDATE boards SET visibility = ? WHERE id = ?').run(visibility, id);
+        if (result.changes === 0)
+            return null;
+        return this.getBoard(id);
+    }
+    async updateBoardMembers(id, allowedGaiis) {
+        const result = this.db.prepare('UPDATE boards SET allowedGaiis = ? WHERE id = ?').run(JSON.stringify(allowedGaiis), id);
+        if (result.changes === 0)
+            return null;
+        return this.getBoard(id);
+    }
+    async deleteBoard(id) {
+        // Delete all posts in the board
+        this.db.prepare('DELETE FROM board_posts WHERE boardId = ?').run(id);
+        const result = this.db.prepare('DELETE FROM boards WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async createPost(post) {
+        this.db.prepare(`INSERT INTO board_posts (boardId, id, authorGaii, title, body, category, tags, ttlExpiresAt, reactions, replyTo, createdAt, semantic)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(post.boardId, post.id, post.authorGaii, post.title, post.body, post.category ?? null, JSON.stringify(post.tags), post.ttlExpiresAt ?? null, JSON.stringify(post.reactions), post.replyTo ?? null, post.createdAt, post.semantic ? JSON.stringify(post.semantic) : null);
+        return post;
+    }
+    async getPost(boardId, postId) {
+        const row = this.db.prepare('SELECT * FROM board_posts WHERE boardId = ? AND id = ?').get(boardId, postId);
+        return row ? this.deserializePost(row) : null;
+    }
+    async listPosts(boardId, opts) {
+        const limit = opts?.limit ?? 20;
+        const now = Date.now();
+        let sql = 'SELECT * FROM board_posts WHERE boardId = ? AND replyTo IS NULL';
+        const params = [boardId];
+        if (opts?.category) {
+            sql += ' AND category = ?';
+            params.push(opts.category);
+        }
+        sql += ' ORDER BY createdAt DESC';
+        const rows = this.db.prepare(sql).all(...params);
+        let results = [];
+        for (const row of rows) {
+            const post = this.deserializePost(row);
+            if (post.ttlExpiresAt && new Date(post.ttlExpiresAt).getTime() < now) {
+                this.db.prepare('DELETE FROM board_posts WHERE boardId = ? AND id = ?').run(post.boardId, post.id);
+                continue;
+            }
+            results.push(post);
+        }
+        if (opts?.cursor) {
+            const idx = results.findIndex(p => p.id === opts.cursor);
+            if (idx >= 0)
+                results = results.slice(idx + 1);
+        }
+        return results.slice(0, limit);
+    }
+    async deletePost(boardId, postId) {
+        const result = this.db.prepare('DELETE FROM board_posts WHERE boardId = ? AND id = ?').run(boardId, postId);
+        return result.changes > 0;
+    }
+    async addReaction(boardId, postId, emoji, gaii) {
+        const row = this.db.prepare('SELECT reactions FROM board_posts WHERE boardId = ? AND id = ?').get(boardId, postId);
+        if (!row)
+            return false;
+        const reactions = JSON.parse(row.reactions);
+        if (!reactions[emoji])
+            reactions[emoji] = [];
+        if (!reactions[emoji].includes(gaii))
+            reactions[emoji].push(gaii);
+        this.db.prepare('UPDATE board_posts SET reactions = ? WHERE boardId = ? AND id = ?').run(JSON.stringify(reactions), boardId, postId);
+        return true;
+    }
+    deserializeBoard(row) {
+        const record = {
+            id: row.id,
+            name: row.name,
+            visibility: row.visibility,
+            ownerGaii: row.ownerGaii,
+            allowedGaiis: JSON.parse(row.allowedGaiis),
+            createdAt: row.createdAt,
+        };
+        if (row.description)
+            record.description = row.description;
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        return record;
+    }
+    deserializePost(row) {
+        const record = {
+            id: row.id,
+            boardId: row.boardId,
+            authorGaii: row.authorGaii,
+            title: row.title,
+            body: row.body,
+            tags: JSON.parse(row.tags),
+            reactions: JSON.parse(row.reactions),
+            createdAt: row.createdAt,
+        };
+        if (row.category)
+            record.category = row.category;
+        if (row.ttlExpiresAt)
+            record.ttlExpiresAt = row.ttlExpiresAt;
+        if (row.replyTo)
+            record.replyTo = row.replyTo;
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Board Subscriptions ──
+    // ══════════════════════════════════════════════════════════
+    async createBoardSubscription(sub) {
+        this.db.prepare(`INSERT OR REPLACE INTO board_subscriptions (id, boardId, gaii, callbackUrl, filters, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(sub.id, sub.boardId, sub.gaii, sub.callbackUrl ?? null, sub.filters ? JSON.stringify(sub.filters) : null, sub.createdAt);
+        return sub;
+    }
+    async getBoardSubscription(boardId, gaii) {
+        const row = this.db.prepare('SELECT * FROM board_subscriptions WHERE boardId = ? AND gaii = ?').get(boardId, gaii);
+        return row ? this.deserializeBoardSubscription(row) : null;
+    }
+    async listBoardSubscriptions(boardId) {
+        const rows = this.db.prepare('SELECT * FROM board_subscriptions WHERE boardId = ?').all(boardId);
+        return rows.map(r => this.deserializeBoardSubscription(r));
+    }
+    async listSubscriptionsByAgent(gaii) {
+        const rows = this.db.prepare('SELECT * FROM board_subscriptions WHERE gaii = ?').all(gaii);
+        return rows.map(r => this.deserializeBoardSubscription(r));
+    }
+    async deleteBoardSubscription(boardId, gaii) {
+        const result = this.db.prepare('DELETE FROM board_subscriptions WHERE boardId = ? AND gaii = ?').run(boardId, gaii);
+        return result.changes > 0;
+    }
+    deserializeBoardSubscription(row) {
+        const record = {
+            id: row.id,
+            boardId: row.boardId,
+            gaii: row.gaii,
+            createdAt: row.createdAt,
+        };
+        if (row.callbackUrl)
+            record.callbackUrl = row.callbackUrl;
+        if (row.filters)
+            record.filters = JSON.parse(row.filters);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── OTK (One-Time Keys) ──
+    // ══════════════════════════════════════════════════════════
+    async createOtk(otk) {
+        this.db.prepare(`INSERT INTO otks (key, ownerGaii, action, params, expiresAt, initial, used, usedAt, sessionId, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(otk.key, otk.ownerGaii, otk.action, JSON.stringify(otk.params), otk.expiresAt, otk.initial ? 1 : 0, otk.used ? 1 : 0, otk.usedAt, otk.sessionId, otk.createdAt);
+        return otk;
+    }
+    async getOtk(key) {
+        const row = this.db.prepare('SELECT * FROM otks WHERE key = ?').get(key);
+        return row ? this.deserializeOtk(row) : null;
+    }
+    async consumeOtk(key, graceMs = 60_000) {
+        const otk = await this.getOtk(key);
+        if (!otk)
+            return null;
+        // Initial OTK: timer hasn't started yet -- activate on first use
+        if (otk.initial && !otk.used) {
+            otk.used = true;
+            otk.usedAt = new Date().toISOString();
+            otk.expiresAt = new Date(Date.now() + graceMs).toISOString();
+            this.db.prepare('UPDATE otks SET used = 1, usedAt = ?, expiresAt = ? WHERE key = ?').run(otk.usedAt, otk.expiresAt, key);
+            return otk;
+        }
+        if (new Date(otk.expiresAt) < new Date()) {
+            this.db.prepare('DELETE FROM otks WHERE key = ?').run(key);
+            return null;
+        }
+        // Configurable post-use window: allow re-use within graceMs of first use
+        if (otk.used && otk.usedAt) {
+            const usedAt = new Date(otk.usedAt).getTime();
+            if (Date.now() - usedAt > graceMs) {
+                this.db.prepare('DELETE FROM otks WHERE key = ?').run(key);
+                return null;
+            }
+            return otk; // still within grace window
+        }
+        otk.used = true;
+        otk.usedAt = new Date().toISOString();
+        this.db.prepare('UPDATE otks SET used = 1, usedAt = ? WHERE key = ?').run(otk.usedAt, key);
+        return otk;
+    }
+    async listOtksBySession(sessionId) {
+        const rows = this.db.prepare('SELECT * FROM otks WHERE sessionId = ?').all(sessionId);
+        return rows.map(r => this.deserializeOtk(r));
+    }
+    async expireSessionOtks(sessionId) {
+        const result = this.db.prepare('DELETE FROM otks WHERE sessionId = ?').run(sessionId);
+        return result.changes;
+    }
+    deserializeOtk(row) {
+        return {
+            key: row.key,
+            ownerGaii: row.ownerGaii,
+            action: row.action,
+            params: JSON.parse(row.params),
+            expiresAt: row.expiresAt,
+            initial: row.initial === 1,
+            used: row.used === 1,
+            usedAt: row.usedAt ?? null,
+            sessionId: row.sessionId ?? null,
+            createdAt: row.createdAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Node Key ──
+    // ══════════════════════════════════════════════════════════
+    async setNodeKey(publicKey, privateKey) {
+        this.db.prepare(`INSERT OR REPLACE INTO node_key (id, publicKey, privateKey) VALUES (1, ?, ?)`).run(publicKey, privateKey);
+    }
+    async getNodeKey() {
+        const row = this.db.prepare('SELECT * FROM node_key WHERE id = 1').get();
+        if (!row)
+            return null;
+        return { publicKey: row.publicKey, privateKey: row.privateKey };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Disputes ──
+    // ══════════════════════════════════════════════════════════
+    async createDispute(dispute) {
+        this.db.prepare(`INSERT INTO disputes (id, trackingCode, status, openedBy, reason, ruling, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(dispute.id, dispute.trackingCode, dispute.status, dispute.openedBy, dispute.reason, dispute.ruling ? JSON.stringify(dispute.ruling) : null, dispute.createdAt, dispute.updatedAt);
+        return dispute;
+    }
+    async getDispute(id) {
+        const row = this.db.prepare('SELECT * FROM disputes WHERE id = ?').get(id);
+        return row ? this.deserializeDispute(row) : null;
+    }
+    async getDisputeByTrackingCode(tc) {
+        const row = this.db.prepare('SELECT * FROM disputes WHERE trackingCode = ?').get(tc);
+        return row ? this.deserializeDispute(row) : null;
+    }
+    async updateDispute(id, updates) {
+        const existing = await this.getDispute(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE disputes SET trackingCode = ?, status = ?, openedBy = ?, reason = ?, ruling = ?,
+       createdAt = ?, updatedAt = ? WHERE id = ?`).run(updated.trackingCode, updated.status, updated.openedBy, updated.reason, updated.ruling ? JSON.stringify(updated.ruling) : null, updated.createdAt, updated.updatedAt, id);
+        return updated;
+    }
+    async addDisputeAuditEntry(disputeId, entry) {
+        this.db.prepare(`INSERT INTO dispute_audit (disputeId, sequence, event, actor, timestamp, data, hash, previousHash)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(disputeId, entry.sequence, entry.event, entry.actor, entry.timestamp, JSON.stringify(entry.data), entry.hash, entry.previousHash);
+        return entry;
+    }
+    async getDisputeAuditLog(disputeId) {
+        const rows = this.db.prepare('SELECT * FROM dispute_audit WHERE disputeId = ? ORDER BY sequence ASC').all(disputeId);
+        return rows.map(r => ({
+            sequence: r.sequence,
+            event: r.event,
+            actor: r.actor,
+            timestamp: r.timestamp,
+            data: JSON.parse(r.data),
+            hash: r.hash,
+            previousHash: r.previousHash,
+        }));
+    }
+    async listDisputesByProvider(gaii) {
+        // Need to join with work to find by provider
+        const rows = this.db.prepare(`SELECT d.* FROM disputes d
+       INNER JOIN work w ON d.trackingCode = w.trackingCode
+       WHERE w.providerGaii = ?`).all(gaii);
+        return rows.map(r => this.deserializeDispute(r));
+    }
+    async listAllDisputes(limit = 10000) {
+        const rows = this.db.prepare('SELECT * FROM disputes ORDER BY createdAt DESC LIMIT ?').all(Math.min(limit, 10000));
+        return rows.map(r => this.deserializeDispute(r));
+    }
+    deserializeDispute(row) {
+        const record = {
+            id: row.id,
+            trackingCode: row.trackingCode,
+            status: row.status,
+            openedBy: row.openedBy,
+            reason: row.reason,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.ruling)
+            record.ruling = JSON.parse(row.ruling);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Micro-Memory ──
+    // ══════════════════════════════════════════════════════════
+    async setMicroMemory(record) {
+        this.db.prepare(`INSERT OR REPLACE INTO micro_memory (gaii, setName, entries, visibility, accessCode, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(record.gaii, record.set, JSON.stringify(record.entries), record.visibility, record.accessCode ?? null, record.updatedAt);
+        return record;
+    }
+    async getMicroMemory(gaii, set) {
+        const row = this.db.prepare('SELECT * FROM micro_memory WHERE gaii = ? AND setName = ?').get(gaii, set);
+        return row ? this.deserializeMicroMemory(row) : null;
+    }
+    async listMicroMemorySets(gaii) {
+        const rows = this.db.prepare('SELECT * FROM micro_memory WHERE gaii = ?').all(gaii);
+        return rows.map(r => this.deserializeMicroMemory(r));
+    }
+    async deleteMicroMemory(gaii, set) {
+        const result = this.db.prepare('DELETE FROM micro_memory WHERE gaii = ? AND setName = ?').run(gaii, set);
+        return result.changes > 0;
+    }
+    async deleteMicroMemoryEntry(gaii, set, key) {
+        const record = await this.getMicroMemory(gaii, set);
+        if (!record || !(key in record.entries))
+            return false;
+        delete record.entries[key];
+        this.db.prepare('UPDATE micro_memory SET entries = ? WHERE gaii = ? AND setName = ?').run(JSON.stringify(record.entries), gaii, set);
+        return true;
+    }
+    async findMicroMemoryByAccessCode(set, accessCode) {
+        const row = this.db.prepare(`SELECT * FROM micro_memory WHERE setName = ? AND accessCode = ? AND (visibility = 'shared_read' OR visibility = 'shared_write')`).get(set, accessCode);
+        return row ? this.deserializeMicroMemory(row) : null;
+    }
+    deserializeMicroMemory(row) {
+        const record = {
+            gaii: row.gaii,
+            set: row.setName,
+            entries: JSON.parse(row.entries),
+            visibility: row.visibility,
+            updatedAt: row.updatedAt,
+        };
+        if (row.accessCode)
+            record.accessCode = row.accessCode;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Storage (Binary Files) ──
+    // ══════════════════════════════════════════════════════════
+    async createStorageFile(file) {
+        this.db.prepare(`INSERT OR REPLACE INTO storage_files (ownerGaii, key, visibility, mimeType, size, data, accessCode, tags, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(file.ownerGaii, file.key, file.visibility, file.mimeType, file.size, file.data, file.accessCode ?? null, JSON.stringify(file.tags || []), file.createdAt);
+        return file;
+    }
+    async getStorageFile(ownerGaii, key) {
+        const row = this.db.prepare('SELECT * FROM storage_files WHERE ownerGaii = ? AND key = ?').get(ownerGaii, key);
+        if (!row)
+            return null;
+        const record = {
+            key: row.key,
+            ownerGaii: row.ownerGaii,
+            visibility: row.visibility,
+            mimeType: row.mimeType,
+            size: row.size,
+            data: row.data,
+            tags: row.tags ? JSON.parse(row.tags) : [],
+            createdAt: row.createdAt,
+        };
+        if (row.accessCode)
+            record.accessCode = row.accessCode;
+        return record;
+    }
+    async listStorageFiles(ownerGaii) {
+        const rows = this.db.prepare('SELECT * FROM storage_files WHERE ownerGaii = ?').all(ownerGaii);
+        return rows.map(r => {
+            const record = {
+                key: r.key,
+                ownerGaii: r.ownerGaii,
+                visibility: r.visibility,
+                mimeType: r.mimeType,
+                size: r.size,
+                data: r.data,
+                tags: r.tags ? JSON.parse(r.tags) : [],
+                createdAt: r.createdAt,
+            };
+            if (r.accessCode)
+                record.accessCode = r.accessCode;
+            return record;
+        });
+    }
+    async deleteStorageFile(ownerGaii, key) {
+        const result = this.db.prepare('DELETE FROM storage_files WHERE ownerGaii = ? AND key = ?').run(ownerGaii, key);
+        return result.changes > 0;
+    }
+    async updateFileTagsByKey(ownerGaii, key, tags) {
+        const result = this.db.prepare('UPDATE storage_files SET tags = ? WHERE ownerGaii = ? AND key = ?').run(JSON.stringify(tags), ownerGaii, key);
+        if (result.changes === 0)
+            return null;
+        return this.getStorageFile(ownerGaii, key);
+    }
+    async updateFileVisibility(ownerGaii, key, visibility) {
+        const result = this.db.prepare('UPDATE storage_files SET visibility = ? WHERE ownerGaii = ? AND key = ?').run(visibility, ownerGaii, key);
+        if (result.changes === 0)
+            return null;
+        return this.getStorageFile(ownerGaii, key);
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Peering Requests ──
+    // ══════════════════════════════════════════════════════════
+    async createPeeringRequest(req) {
+        this.db.prepare(`INSERT INTO peering_requests (id, fromNodeUrl, fromNodeId, toNodeId, targetUrl, publicKey, message, status, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(req.id, req.fromNodeUrl, req.fromNodeId ?? null, req.toNodeId ?? null, req.targetUrl ?? null, req.publicKey ?? null, req.message ?? null, req.status, req.createdAt, req.updatedAt);
+        return req;
+    }
+    async getPeeringRequest(id) {
+        const row = this.db.prepare('SELECT * FROM peering_requests WHERE id = ?').get(id);
+        return row ? this.deserializePeeringRequest(row) : null;
+    }
+    async listPeeringRequests(status) {
+        let sql = 'SELECT * FROM peering_requests';
+        const params = [];
+        if (status) {
+            sql += ' WHERE status = ?';
+            params.push(status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializePeeringRequest(r));
+    }
+    async updatePeeringRequest(id, updates) {
+        const existing = await this.getPeeringRequest(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE peering_requests SET fromNodeUrl = ?, fromNodeId = ?, toNodeId = ?, targetUrl = ?,
+       publicKey = ?, message = ?, status = ?, createdAt = ?, updatedAt = ? WHERE id = ?`).run(updated.fromNodeUrl, updated.fromNodeId ?? null, updated.toNodeId ?? null, updated.targetUrl ?? null, updated.publicKey ?? null, updated.message ?? null, updated.status, updated.createdAt, updated.updatedAt, id);
+        return updated;
+    }
+    deserializePeeringRequest(row) {
+        const record = {
+            id: row.id,
+            fromNodeUrl: row.fromNodeUrl,
+            status: row.status,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.fromNodeId)
+            record.fromNodeId = row.fromNodeId;
+        if (row.toNodeId)
+            record.toNodeId = row.toNodeId;
+        if (row.targetUrl)
+            record.targetUrl = row.targetUrl;
+        if (row.publicKey)
+            record.publicKey = row.publicKey;
+        if (row.message)
+            record.message = row.message;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Chunked Uploads (in-memory, same as MongoDB adapter) ──
+    // ══════════════════════════════════════════════════════════
+    async createChunkedUpload(record) {
+        this.chunkedUploads.set(record.uploadId, record);
+        return record;
+    }
+    async getChunkedUpload(uploadId) {
+        const record = this.chunkedUploads.get(uploadId) ?? null;
+        if (record && new Date(record.expiresAt).getTime() < Date.now()) {
+            this.chunkedUploads.delete(uploadId);
+            return null;
+        }
+        return record;
+    }
+    async addChunk(uploadId, chunkIndex, data) {
+        const record = this.chunkedUploads.get(uploadId);
+        if (!record)
+            return false;
+        if (new Date(record.expiresAt).getTime() < Date.now()) {
+            this.chunkedUploads.delete(uploadId);
+            return false;
+        }
+        record.receivedChunks.set(chunkIndex, data);
+        return true;
+    }
+    async deleteChunkedUpload(uploadId) {
+        return this.chunkedUploads.delete(uploadId);
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── GHII (Global Human Identity Identifier) ──
+    // ══════════════════════════════════════════════════════════
+    async createGHII(record) {
+        try {
+            this.db.prepare(`INSERT INTO ghiis (ghii, username, nodeId, displayName, bio, avatar, locale, passwordHash,
+         verificationLevel, ownerName, createdAt, updatedAt, totpSecret, totpEnabled, totpBackupCodes,
+         totpLastUsedAt, totpLastUsedCode, totpFailedAttempts, totpLockedUntil, semantic, emailHash,
+         emailVerifiedAt, verificationMethod, magicLinkEnabled, notificationEmail, lastLoginAt,
+         loginCount, verifiedAttributes, verificationIssuer, verificationCredentialHash, ftnVerified,
+         trustScore, morselBalance, allowedOrigins)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.ghii, record.username, record.nodeId, record.displayName, record.bio ?? null, record.avatar ?? null, record.locale ?? null, record.passwordHash ?? null, record.verificationLevel, record.ownerName, record.createdAt, record.updatedAt, record.totpSecret ?? null, record.totpEnabled ? 1 : 0, record.totpBackupCodes ? JSON.stringify(record.totpBackupCodes) : null, record.totpLastUsedAt ?? null, record.totpLastUsedCode ?? null, record.totpFailedAttempts ?? 0, record.totpLockedUntil ?? null, record.semantic ? JSON.stringify(record.semantic) : null, record.emailHash ?? null, record.emailVerifiedAt ?? null, record.verificationMethod ?? null, record.magicLinkEnabled ? 1 : 0, record.notificationEmail ?? null, record.lastLoginAt ?? null, record.loginCount ?? 0, record.verifiedAttributes ? JSON.stringify(record.verifiedAttributes) : null, record.verificationIssuer ?? null, record.verificationCredentialHash ?? null, record.ftnVerified ? 1 : 0, record.trustScore ?? null, record.morselBalance ?? null, record.allowedOrigins ? JSON.stringify(record.allowedOrigins) : null);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('GHII_TAKEN', { cause: err });
+            throw err;
+        }
+    }
+    async getGHII(ghii) {
+        const row = this.db.prepare('SELECT * FROM ghiis WHERE ghii = ?').get(ghii);
+        return row ? this.deserializeGHII(row) : null;
+    }
+    async getGHIIByOwner(ownerName) {
+        const row = this.db.prepare('SELECT * FROM ghiis WHERE ownerName = ?').get(ownerName);
+        return row ? this.deserializeGHII(row) : null;
+    }
+    async getGHIIByEmailHash(emailHash) {
+        const row = this.db.prepare('SELECT * FROM ghiis WHERE emailHash = ?').get(emailHash);
+        return row ? this.deserializeGHII(row) : null;
+    }
+    async updateGHII(ghii, updates) {
+        const existing = await this.getGHII(ghii);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+        this.db.prepare(`UPDATE ghiis SET username = ?, nodeId = ?, displayName = ?, bio = ?, avatar = ?, locale = ?,
+       passwordHash = ?, verificationLevel = ?, ownerName = ?, createdAt = ?, updatedAt = ?,
+       totpSecret = ?, totpEnabled = ?, totpBackupCodes = ?, totpLastUsedAt = ?,
+       totpLastUsedCode = ?, totpFailedAttempts = ?, totpLockedUntil = ?, semantic = ?,
+       emailHash = ?, emailVerifiedAt = ?, verificationMethod = ?, magicLinkEnabled = ?,
+       notificationEmail = ?, lastLoginAt = ?, loginCount = ?, verifiedAttributes = ?,
+       verificationIssuer = ?, verificationCredentialHash = ?, ftnVerified = ?,
+       trustScore = ?, morselBalance = ?, allowedOrigins = ?
+       WHERE ghii = ?`).run(updated.username, updated.nodeId, updated.displayName, updated.bio ?? null, updated.avatar ?? null, updated.locale ?? null, updated.passwordHash ?? null, updated.verificationLevel, updated.ownerName, updated.createdAt, updated.updatedAt, updated.totpSecret ?? null, updated.totpEnabled ? 1 : 0, updated.totpBackupCodes ? JSON.stringify(updated.totpBackupCodes) : null, updated.totpLastUsedAt ?? null, updated.totpLastUsedCode ?? null, updated.totpFailedAttempts ?? 0, updated.totpLockedUntil ?? null, updated.semantic ? JSON.stringify(updated.semantic) : null, updated.emailHash ?? null, updated.emailVerifiedAt ?? null, updated.verificationMethod ?? null, updated.magicLinkEnabled ? 1 : 0, updated.notificationEmail ?? null, updated.lastLoginAt ?? null, updated.loginCount ?? 0, updated.verifiedAttributes ? JSON.stringify(updated.verifiedAttributes) : null, updated.verificationIssuer ?? null, updated.verificationCredentialHash ?? null, updated.ftnVerified ? 1 : 0, updated.trustScore ?? null, updated.morselBalance ?? null, updated.allowedOrigins ? JSON.stringify(updated.allowedOrigins) : null, ghii);
+        return updated;
+    }
+    async listGHIIs(opts) {
+        const rows = this.db.prepare('SELECT * FROM ghiis').all();
+        let results = rows.map(r => this.deserializeGHII(r));
+        if (opts?.q) {
+            const q = opts.q.toLowerCase();
+            results = results.filter(r => r.username.toLowerCase().includes(q) ||
+                r.displayName.toLowerCase().includes(q) ||
+                (r.bio?.toLowerCase().includes(q) ?? false));
+        }
+        if (opts?.level !== undefined) {
+            results = results.filter(r => r.verificationLevel >= opts.level);
+        }
+        return results;
+    }
+    async deleteGHII(ghii) {
+        const result = this.db.prepare('DELETE FROM ghiis WHERE ghii = ?').run(ghii);
+        return result.changes > 0;
+    }
+    deserializeGHII(row) {
+        const record = {
+            username: row.username,
+            nodeId: row.nodeId,
+            ghii: row.ghii,
+            displayName: row.displayName,
+            verificationLevel: row.verificationLevel,
+            ownerName: row.ownerName,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+            totpEnabled: row.totpEnabled === 1,
+        };
+        if (row.bio)
+            record.bio = row.bio;
+        if (row.avatar)
+            record.avatar = row.avatar;
+        if (row.locale)
+            record.locale = row.locale;
+        if (row.passwordHash)
+            record.passwordHash = row.passwordHash;
+        if (row.totpSecret)
+            record.totpSecret = row.totpSecret;
+        if (row.totpBackupCodes)
+            record.totpBackupCodes = JSON.parse(row.totpBackupCodes);
+        if (row.totpLastUsedAt)
+            record.totpLastUsedAt = row.totpLastUsedAt;
+        if (row.totpLastUsedCode)
+            record.totpLastUsedCode = row.totpLastUsedCode;
+        if (row.totpFailedAttempts)
+            record.totpFailedAttempts = row.totpFailedAttempts;
+        if (row.totpLockedUntil)
+            record.totpLockedUntil = row.totpLockedUntil;
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        if (row.emailHash)
+            record.emailHash = row.emailHash;
+        if (row.emailVerifiedAt)
+            record.emailVerifiedAt = row.emailVerifiedAt;
+        if (row.verificationMethod)
+            record.verificationMethod = row.verificationMethod;
+        if (row.magicLinkEnabled)
+            record.magicLinkEnabled = row.magicLinkEnabled === 1;
+        if (row.notificationEmail)
+            record.notificationEmail = row.notificationEmail;
+        if (row.lastLoginAt)
+            record.lastLoginAt = row.lastLoginAt;
+        if (row.loginCount)
+            record.loginCount = row.loginCount;
+        if (row.verifiedAttributes)
+            record.verifiedAttributes = JSON.parse(row.verifiedAttributes);
+        if (row.verificationIssuer)
+            record.verificationIssuer = row.verificationIssuer;
+        if (row.verificationCredentialHash)
+            record.verificationCredentialHash = row.verificationCredentialHash;
+        if (row.ftnVerified)
+            record.ftnVerified = row.ftnVerified === 1;
+        if (row.trustScore !== null && row.trustScore !== undefined)
+            record.trustScore = row.trustScore;
+        if (row.morselBalance !== null && row.morselBalance !== undefined)
+            record.morselBalance = row.morselBalance;
+        if (row.allowedOrigins)
+            record.allowedOrigins = JSON.parse(row.allowedOrigins);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Chat Instances ──
+    // ══════════════════════════════════════════════════════════
+    async createChatInstance(record) {
+        try {
+            this.db.prepare(`INSERT INTO chat_instances (id, platform, appName, ownerName, ghii, nodeId, isAnonymous, createdAt, lastSeen, agentGaii, mcpClientId)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.platform, record.appName, record.ownerName, record.ghii, record.nodeId, record.isAnonymous ? 1 : 0, record.createdAt, record.lastSeen, record.agentGaii ?? null, record.mcpClientId ?? null);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('CHAT_INSTANCE_EXISTS', { cause: err });
+            throw err;
+        }
+    }
+    async getChatInstance(id) {
+        const row = this.db.prepare('SELECT * FROM chat_instances WHERE id = ?').get(id);
+        return row ? this.deserializeChatInstance(row) : null;
+    }
+    async listChatInstances(opts) {
+        let sql = 'SELECT * FROM chat_instances WHERE 1=1';
+        const params = [];
+        if (opts?.ownerName) {
+            sql += ' AND ownerName = ?';
+            params.push(opts.ownerName);
+        }
+        if (opts?.platform) {
+            sql += ' AND platform = ?';
+            params.push(opts.platform);
+        }
+        if (opts?.ghii) {
+            sql += ' AND ghii = ?';
+            params.push(opts.ghii);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeChatInstance(r));
+    }
+    async updateChatInstance(id, updates) {
+        const existing = await this.getChatInstance(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE chat_instances SET platform = ?, appName = ?, ownerName = ?, ghii = ?,
+       nodeId = ?, isAnonymous = ?, createdAt = ?, lastSeen = ?, agentGaii = ?, mcpClientId = ? WHERE id = ?`).run(updated.platform, updated.appName, updated.ownerName, updated.ghii, updated.nodeId, updated.isAnonymous ? 1 : 0, updated.createdAt, updated.lastSeen, updated.agentGaii ?? null, updated.mcpClientId ?? null, id);
+        return updated;
+    }
+    async deleteChatInstance(id) {
+        const result = this.db.prepare('DELETE FROM chat_instances WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deserializeChatInstance(row) {
+        return {
+            id: row.id,
+            platform: row.platform,
+            appName: row.appName,
+            ownerName: row.ownerName,
+            ghii: row.ghii,
+            nodeId: row.nodeId,
+            isAnonymous: row.isAnonymous === 1,
+            createdAt: row.createdAt,
+            lastSeen: row.lastSeen,
+            agentGaii: row.agentGaii || undefined,
+            mcpClientId: row.mcpClientId || undefined,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Email Verifications ──
+    // ══════════════════════════════════════════════════════════
+    async createEmailVerification(record) {
+        this.db.prepare(`INSERT INTO email_verifications (id, ownerName, emailHash, code, purpose, status, attempts, expiresAt, createdAt, verifiedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.ownerName, record.emailHash, record.code, record.purpose, record.status, record.attempts, record.expiresAt, record.createdAt, record.verifiedAt);
+        return record;
+    }
+    async getEmailVerification(id) {
+        const row = this.db.prepare('SELECT * FROM email_verifications WHERE id = ?').get(id);
+        return row ? this.deserializeEmailVerification(row) : null;
+    }
+    async getActiveEmailVerification(ownerName, purpose) {
+        const now = new Date().toISOString();
+        const row = this.db.prepare(`SELECT * FROM email_verifications WHERE ownerName = ? AND purpose = ? AND status = 'pending' AND expiresAt > ? LIMIT 1`).get(ownerName, purpose, now);
+        return row ? this.deserializeEmailVerification(row) : null;
+    }
+    async updateEmailVerification(id, updates) {
+        const existing = await this.getEmailVerification(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE email_verifications SET ownerName = ?, emailHash = ?, code = ?, purpose = ?,
+       status = ?, attempts = ?, expiresAt = ?, createdAt = ?, verifiedAt = ? WHERE id = ?`).run(updated.ownerName, updated.emailHash, updated.code, updated.purpose, updated.status, updated.attempts, updated.expiresAt, updated.createdAt, updated.verifiedAt, id);
+        return updated;
+    }
+    async getEmailVerificationsByOwner(ownerName) {
+        const rows = this.db.prepare('SELECT * FROM email_verifications WHERE ownerName = ?').all(ownerName);
+        return rows.map(r => this.deserializeEmailVerification(r));
+    }
+    async deleteExpiredEmailVerifications() {
+        const now = new Date().toISOString();
+        const result = this.db.prepare(`DELETE FROM email_verifications WHERE status = 'pending' AND expiresAt < ?`).run(now);
+        return result.changes;
+    }
+    deserializeEmailVerification(row) {
+        return {
+            id: row.id,
+            ownerName: row.ownerName,
+            emailHash: row.emailHash,
+            code: row.code,
+            purpose: row.purpose,
+            status: row.status,
+            attempts: row.attempts,
+            expiresAt: row.expiresAt,
+            createdAt: row.createdAt,
+            verifiedAt: row.verifiedAt ?? null,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Personal Nodes ──
+    // ══════════════════════════════════════════════════════════
+    async createPersonalNode(node) {
+        this.db.prepare(`INSERT INTO personal_nodes (nodeId, ownerName, anchorNodeId, publicKey, status, agentGaiis,
+       lastSeen, mailboxQuotaBytes, mailboxUsedBytes, visibility, createdAt, updatedAt, semantic)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(node.nodeId, node.ownerName, node.anchorNodeId, node.publicKey, node.status, JSON.stringify(node.agentGaiis), node.lastSeen, node.mailboxQuotaBytes, node.mailboxUsedBytes, node.visibility, node.createdAt, node.updatedAt, node.semantic ? JSON.stringify(node.semantic) : null);
+        return { ...node };
+    }
+    async getPersonalNode(nodeId) {
+        const row = this.db.prepare('SELECT * FROM personal_nodes WHERE nodeId = ?').get(nodeId);
+        return row ? this.deserializePersonalNode(row) : null;
+    }
+    async getPersonalNodeByOwner(ownerName) {
+        const row = this.db.prepare('SELECT * FROM personal_nodes WHERE ownerName = ?').get(ownerName);
+        return row ? this.deserializePersonalNode(row) : null;
+    }
+    async listPersonalNodes(opts) {
+        let sql = 'SELECT * FROM personal_nodes';
+        const params = [];
+        if (opts?.status) {
+            sql += ' WHERE status = ?';
+            params.push(opts.status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializePersonalNode(r));
+    }
+    async updatePersonalNode(nodeId, updates) {
+        const existing = await this.getPersonalNode(nodeId);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+        this.db.prepare(`UPDATE personal_nodes SET ownerName = ?, anchorNodeId = ?, publicKey = ?, status = ?,
+       agentGaiis = ?, lastSeen = ?, mailboxQuotaBytes = ?, mailboxUsedBytes = ?,
+       visibility = ?, createdAt = ?, updatedAt = ?, semantic = ? WHERE nodeId = ?`).run(updated.ownerName, updated.anchorNodeId, updated.publicKey, updated.status, JSON.stringify(updated.agentGaiis), updated.lastSeen, updated.mailboxQuotaBytes, updated.mailboxUsedBytes, updated.visibility, updated.createdAt, updated.updatedAt, updated.semantic ? JSON.stringify(updated.semantic) : null, nodeId);
+        return { ...updated };
+    }
+    async deletePersonalNode(nodeId) {
+        const result = this.db.prepare('DELETE FROM personal_nodes WHERE nodeId = ?').run(nodeId);
+        return result.changes > 0;
+    }
+    deserializePersonalNode(row) {
+        const record = {
+            nodeId: row.nodeId,
+            ownerName: row.ownerName,
+            anchorNodeId: row.anchorNodeId,
+            publicKey: row.publicKey,
+            status: row.status,
+            agentGaiis: JSON.parse(row.agentGaiis),
+            lastSeen: row.lastSeen,
+            mailboxQuotaBytes: row.mailboxQuotaBytes,
+            mailboxUsedBytes: row.mailboxUsedBytes,
+            visibility: row.visibility,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Mailbox ──
+    // ══════════════════════════════════════════════════════════
+    async createMailboxItem(item) {
+        this.db.prepare(`INSERT INTO mailbox_items (id, personalNodeId, type, fromGaii, toGaii, payload, sizeBytes, retentionDays, expiresAt, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(item.id, item.personalNodeId, item.type, item.fromGaii, item.toGaii, item.payload, item.sizeBytes, item.retentionDays, item.expiresAt, item.createdAt);
+        // Update the personal node's mailbox usage
+        this.db.prepare('UPDATE personal_nodes SET mailboxUsedBytes = mailboxUsedBytes + ? WHERE nodeId = ?').run(item.sizeBytes, item.personalNodeId);
+        return { ...item };
+    }
+    async getMailboxItem(id) {
+        const row = this.db.prepare('SELECT * FROM mailbox_items WHERE id = ?').get(id);
+        return row ? this.deserializeMailboxItem(row) : null;
+    }
+    async listMailboxItems(personalNodeId, opts) {
+        let sql = 'SELECT * FROM mailbox_items WHERE personalNodeId = ?';
+        const params = [personalNodeId];
+        if (opts?.type) {
+            sql += ' AND type = ?';
+            params.push(opts.type);
+        }
+        sql += ' ORDER BY createdAt ASC';
+        if (opts?.limit) {
+            sql += ' LIMIT ?';
+            params.push(opts.limit);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeMailboxItem(r));
+    }
+    async deleteMailboxItem(id) {
+        const item = await this.getMailboxItem(id);
+        if (!item)
+            return false;
+        // Update the personal node's mailbox usage
+        this.db.prepare('UPDATE personal_nodes SET mailboxUsedBytes = MAX(0, mailboxUsedBytes - ?) WHERE nodeId = ?').run(item.sizeBytes, item.personalNodeId);
+        const result = this.db.prepare('DELETE FROM mailbox_items WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async deleteMailboxItemsByNode(personalNodeId) {
+        const result = this.db.prepare('DELETE FROM mailbox_items WHERE personalNodeId = ?').run(personalNodeId);
+        this.db.prepare('UPDATE personal_nodes SET mailboxUsedBytes = 0 WHERE nodeId = ?').run(personalNodeId);
+        return result.changes;
+    }
+    async getMailboxStats(personalNodeId) {
+        const row = this.db.prepare('SELECT COUNT(*) as count, COALESCE(SUM(sizeBytes), 0) as totalBytes FROM mailbox_items WHERE personalNodeId = ?').get(personalNodeId);
+        return {
+            count: row.count,
+            totalBytes: row.totalBytes,
+        };
+    }
+    async cleanExpiredMailboxItems() {
+        const now = new Date().toISOString();
+        // Get expired items to update personal node usage
+        const expiredItems = this.db.prepare('SELECT personalNodeId, sizeBytes FROM mailbox_items WHERE expiresAt < ?').all(now);
+        // Aggregate by personalNodeId
+        const bytesPerNode = new Map();
+        for (const item of expiredItems) {
+            const nodeId = item.personalNodeId;
+            bytesPerNode.set(nodeId, (bytesPerNode.get(nodeId) ?? 0) + item.sizeBytes);
+        }
+        // Delete expired items
+        const result = this.db.prepare('DELETE FROM mailbox_items WHERE expiresAt < ?').run(now);
+        // Update personal node usage
+        for (const [nodeId, bytes] of bytesPerNode) {
+            this.db.prepare('UPDATE personal_nodes SET mailboxUsedBytes = MAX(0, mailboxUsedBytes - ?) WHERE nodeId = ?').run(bytes, nodeId);
+        }
+        return result.changes;
+    }
+    deserializeMailboxItem(row) {
+        return {
+            id: row.id,
+            personalNodeId: row.personalNodeId,
+            type: row.type,
+            fromGaii: row.fromGaii,
+            toGaii: row.toGaii,
+            payload: row.payload,
+            sizeBytes: row.sizeBytes,
+            retentionDays: row.retentionDays,
+            expiresAt: row.expiresAt,
+            createdAt: row.createdAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Maintenance Mode ──
+    // ══════════════════════════════════════════════════════════
+    async getMaintenanceMode() {
+        const row = this.db.prepare('SELECT * FROM maintenance WHERE id = 1').get();
+        if (!row) {
+            return { enabled: false, message: '', enabledAt: null, enabledBy: null };
+        }
+        return {
+            enabled: row.enabled === 1,
+            message: row.message,
+            enabledAt: row.enabledAt ?? null,
+            enabledBy: row.enabledBy ?? null,
+        };
+    }
+    async setMaintenanceMode(state) {
+        this.db.prepare(`INSERT OR REPLACE INTO maintenance (id, enabled, message, enabledAt, enabledBy) VALUES (1, ?, ?, ?, ?)`).run(state.enabled ? 1 : 0, state.message, state.enabledAt, state.enabledBy);
+        return state;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Consent Layer ──
+    // ══════════════════════════════════════════════════════════
+    async createConsent(record) {
+        this.db.prepare(`INSERT INTO consents (id, ownerGaii, dataPattern, recipient, purpose, scope, expires, status, grantedAt, revokedAt, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.ownerGaii, record.dataPattern, record.recipient, record.purpose, record.scope, record.expires, record.status, record.grantedAt, record.revokedAt, record.metadata ? JSON.stringify(record.metadata) : null);
+        return record;
+    }
+    async getConsent(id) {
+        const row = this.db.prepare('SELECT * FROM consents WHERE id = ?').get(id);
+        return row ? this.deserializeConsent(row) : null;
+    }
+    async listConsents(ownerGaii, opts) {
+        let sql = 'SELECT * FROM consents WHERE ownerGaii = ?';
+        const params = [ownerGaii];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        if (opts?.recipient) {
+            sql += ' AND recipient = ?';
+            params.push(opts.recipient);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeConsent(r));
+    }
+    async updateConsent(id, updates) {
+        const existing = await this.getConsent(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE consents SET ownerGaii = ?, dataPattern = ?, recipient = ?, purpose = ?,
+       scope = ?, expires = ?, status = ?, grantedAt = ?, revokedAt = ?, metadata = ? WHERE id = ?`).run(updated.ownerGaii, updated.dataPattern, updated.recipient, updated.purpose, updated.scope, updated.expires, updated.status, updated.grantedAt, updated.revokedAt, updated.metadata ? JSON.stringify(updated.metadata) : null, id);
+        return updated;
+    }
+    async deleteConsent(id) {
+        const result = this.db.prepare('DELETE FROM consents WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async findMatchingConsents(ownerGaii, memoryKey, accessorGaii) {
+        const now = new Date().toISOString();
+        const rows = this.db.prepare(`SELECT * FROM consents WHERE ownerGaii = ? AND status = 'active'`).all(ownerGaii);
+        const results = [];
+        for (const row of rows) {
+            const consent = this.deserializeConsent(row);
+            // Check expiration
+            if (consent.expires && consent.expires < now) {
+                this.db.prepare('UPDATE consents SET status = ? WHERE id = ?').run('expired', consent.id);
+                continue;
+            }
+            // Check recipient (supports *, exact GAII, ghii:, domain:, node:)
+            const accessor = parseGaiiLoose(accessorGaii);
+            if (!matchesRecipient(consent.recipient, accessorGaii, accessor.owner, accessor.node))
+                continue;
+            // Check data_pattern (glob match)
+            if (!consentMatchPattern(consent.dataPattern, memoryKey))
+                continue;
+            results.push(consent);
+        }
+        return results;
+    }
+    // Consent Audit
+    async addConsentAuditEntry(entry) {
+        this.db.prepare(`INSERT INTO consent_audit (id, consentId, ownerGaii, accessorGaii, memoryKey, action, timestamp, allowed)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(entry.id, entry.consentId, entry.ownerGaii, entry.accessorGaii, entry.memoryKey, entry.action, entry.timestamp, entry.allowed ? 1 : 0);
+        return entry;
+    }
+    async listConsentAudit(ownerGaii, opts) {
+        let sql = 'SELECT * FROM consent_audit WHERE ownerGaii = ?';
+        const params = [ownerGaii];
+        if (opts?.days) {
+            const cutoff = new Date(Date.now() - opts.days * 86400000).toISOString();
+            sql += ' AND timestamp >= ?';
+            params.push(cutoff);
+        }
+        if (opts?.consentId) {
+            sql += ' AND consentId = ?';
+            params.push(opts.consentId);
+        }
+        if (opts?.accessorGaii) {
+            sql += ' AND accessorGaii = ?';
+            params.push(opts.accessorGaii);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => ({
+            id: r.id,
+            consentId: r.consentId,
+            ownerGaii: r.ownerGaii,
+            accessorGaii: r.accessorGaii,
+            memoryKey: r.memoryKey,
+            action: r.action,
+            timestamp: r.timestamp,
+            allowed: r.allowed === 1,
+        }));
+    }
+    deserializeConsent(row) {
+        const record = {
+            id: row.id,
+            ownerGaii: row.ownerGaii,
+            dataPattern: row.dataPattern,
+            recipient: row.recipient,
+            purpose: row.purpose,
+            scope: row.scope,
+            expires: row.expires ?? null,
+            status: row.status,
+            grantedAt: row.grantedAt,
+            revokedAt: row.revokedAt ?? null,
+        };
+        if (row.metadata)
+            record.metadata = JSON.parse(row.metadata);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Schema Locking ──
+    // ══════════════════════════════════════════════════════════
+    async setSchema(record) {
+        this.db.prepare(`INSERT OR REPLACE INTO schemas (keyPattern, applyTo, schemaJson, schemaMode, lockedBy, setAt, updatedAt, semanticContext)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(record.keyPattern, record.applyTo, JSON.stringify(record.schemaJson), record.schemaMode, record.lockedBy, record.setAt, record.updatedAt, record.semanticContext ? JSON.stringify(record.semanticContext) : null);
+        return record;
+    }
+    async getSchema(keyPattern, applyTo) {
+        if (applyTo) {
+            const row = this.db.prepare('SELECT * FROM schemas WHERE keyPattern = ? AND applyTo = ?').get(keyPattern, applyTo);
+            return row ? this.deserializeSchema(row) : null;
+        }
+        // Try exact first, then prefix
+        const exactRow = this.db.prepare('SELECT * FROM schemas WHERE keyPattern = ? AND applyTo = ?').get(keyPattern, 'exact');
+        if (exactRow)
+            return this.deserializeSchema(exactRow);
+        const prefixRow = this.db.prepare('SELECT * FROM schemas WHERE keyPattern = ? AND applyTo = ?').get(keyPattern, 'prefix');
+        return prefixRow ? this.deserializeSchema(prefixRow) : null;
+    }
+    async deleteSchema(keyPattern) {
+        const result = this.db.prepare('DELETE FROM schemas WHERE keyPattern = ?').run(keyPattern);
+        return result.changes > 0;
+    }
+    async listSchemas(prefix) {
+        let sql = 'SELECT * FROM schemas';
+        const params = [];
+        if (prefix) {
+            sql += ' WHERE keyPattern LIKE ?';
+            params.push(prefix + '%');
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeSchema(r));
+    }
+    async findApplicableSchema(memoryKey) {
+        // 1. Exact match -- highest priority
+        const exactRow = this.db.prepare('SELECT * FROM schemas WHERE keyPattern = ? AND applyTo = ?').get(memoryKey, 'exact');
+        if (exactRow)
+            return this.deserializeSchema(exactRow);
+        // 2. Wildcard pattern match -- supports profile.*.interests style
+        const prefixSchemas = this.db.prepare('SELECT * FROM schemas WHERE applyTo = ?').all('prefix');
+        let bestWildcard = null;
+        let bestSegments = 0;
+        for (const row of prefixSchemas) {
+            const record = this.deserializeSchema(row);
+            if (!record.keyPattern.includes('*'))
+                continue;
+            if (matchWildcardPattern(record.keyPattern, memoryKey)) {
+                const segments = record.keyPattern.split('.').length;
+                if (segments > bestSegments) {
+                    bestWildcard = record;
+                    bestSegments = segments;
+                }
+            }
+        }
+        if (bestWildcard)
+            return bestWildcard;
+        // 3. Simple prefix match -- longest prefix wins
+        const parts = memoryKey.split('.');
+        for (let i = parts.length - 1; i >= 1; i--) {
+            const prefix = parts.slice(0, i).join('.');
+            const prefixRow = this.db.prepare('SELECT * FROM schemas WHERE keyPattern = ? AND applyTo = ?').get(prefix, 'prefix');
+            if (prefixRow)
+                return this.deserializeSchema(prefixRow);
+        }
+        return null;
+    }
+    deserializeSchema(row) {
+        const record = {
+            keyPattern: row.keyPattern,
+            applyTo: row.applyTo,
+            schemaJson: JSON.parse(row.schemaJson),
+            schemaMode: row.schemaMode,
+            lockedBy: row.lockedBy,
+            setAt: row.setAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.semanticContext)
+            record.semanticContext = JSON.parse(row.semanticContext);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── CSM (Community Service Manifest) ──
+    // ══════════════════════════════════════════════════════════
+    async createCsm(record) {
+        try {
+            this.db.prepare(`INSERT INTO csms (name, definition, jsonSchemaKey, serviceType, registeredBy, registeredAt, updatedAt, semantic, federate)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.name, JSON.stringify(record.definition), record.jsonSchemaKey, record.serviceType, record.registeredBy, record.registeredAt, record.updatedAt, record.semantic ? JSON.stringify(record.semantic) : null, record.federate ? 1 : 0);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('CSM_NAME_TAKEN', { cause: err });
+            throw err;
+        }
+    }
+    async getCsm(name) {
+        const row = this.db.prepare('SELECT * FROM csms WHERE name = ?').get(name);
+        return row ? this.deserializeCsm(row) : null;
+    }
+    async listCsms(opts) {
+        let sql = 'SELECT * FROM csms';
+        const params = [];
+        if (opts?.serviceType) {
+            sql += ' WHERE serviceType = ?';
+            params.push(opts.serviceType);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeCsm(r));
+    }
+    async updateCsm(name, updates) {
+        const existing = await this.getCsm(name);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, name: existing.name };
+        this.db.prepare(`UPDATE csms SET definition = ?, jsonSchemaKey = ?, serviceType = ?, registeredBy = ?,
+       registeredAt = ?, updatedAt = ?, semantic = ?, federate = ? WHERE name = ?`).run(JSON.stringify(updated.definition), updated.jsonSchemaKey, updated.serviceType, updated.registeredBy, updated.registeredAt, updated.updatedAt, updated.semantic ? JSON.stringify(updated.semantic) : null, updated.federate ? 1 : 0, name);
+        return updated;
+    }
+    async deleteCsm(name) {
+        const result = this.db.prepare('DELETE FROM csms WHERE name = ?').run(name);
+        return result.changes > 0;
+    }
+    deserializeCsm(row) {
+        const record = {
+            name: row.name,
+            definition: JSON.parse(row.definition),
+            jsonSchemaKey: row.jsonSchemaKey,
+            serviceType: row.serviceType,
+            registeredBy: row.registeredBy,
+            registeredAt: row.registeredAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        if (row.federate)
+            record.federate = row.federate === 1;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── MSM (Machine Service Manifest) ──
+    // ══════════════════════════════════════════════════════════
+    async createMsm(record) {
+        try {
+            this.db.prepare(`INSERT INTO msms (name, definition, category, authType, actionsCount, registeredBy, registeredAt, updatedAt, federate)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.name, JSON.stringify(record.definition), record.category, record.authType, record.actionsCount, record.registeredBy, record.registeredAt, record.updatedAt, record.federate ? 1 : 0);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed'))
+                throw new Error('MSM_NAME_TAKEN', { cause: err });
+            throw err;
+        }
+    }
+    async getMsm(name) {
+        const row = this.db.prepare('SELECT * FROM msms WHERE name = ?').get(name);
+        return row ? this.deserializeMsm(row) : null;
+    }
+    async listMsms(opts) {
+        let sql = 'SELECT * FROM msms';
+        const params = [];
+        if (opts?.category) {
+            sql += ' WHERE category = ?';
+            params.push(opts.category);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeMsm(r));
+    }
+    async updateMsm(name, updates) {
+        const existing = await this.getMsm(name);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, name: existing.name, updatedAt: new Date().toISOString() };
+        this.db.prepare(`UPDATE msms SET definition = ?, category = ?, authType = ?, actionsCount = ?,
+       registeredBy = ?, registeredAt = ?, updatedAt = ?, federate = ? WHERE name = ?`).run(JSON.stringify(updated.definition), updated.category, updated.authType, updated.actionsCount, updated.registeredBy, updated.registeredAt, updated.updatedAt, updated.federate ? 1 : 0, name);
+        return updated;
+    }
+    async deleteMsm(name) {
+        const result = this.db.prepare('DELETE FROM msms WHERE name = ?').run(name);
+        return result.changes > 0;
+    }
+    deserializeMsm(row) {
+        const record = {
+            name: row.name,
+            definition: JSON.parse(row.definition),
+            category: row.category,
+            authType: row.authType,
+            actionsCount: row.actionsCount,
+            registeredBy: row.registeredBy,
+            registeredAt: row.registeredAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.federate)
+            record.federate = row.federate === 1;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Flags (Moderation) ──
+    // ══════════════════════════════════════════════════════════
+    async createFlag(record) {
+        this.db.prepare(`INSERT INTO flags (id, targetType, targetId, flaggedBy, reason, description, status, reviewedBy, reviewedAt, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.targetType, record.targetId, record.flaggedBy, record.reason, record.description ?? null, record.status, record.reviewedBy ?? null, record.reviewedAt ?? null, record.createdAt);
+        return record;
+    }
+    async getFlag(id) {
+        const row = this.db.prepare('SELECT * FROM flags WHERE id = ?').get(id);
+        return row ? this.deserializeFlag(row) : null;
+    }
+    async getFlagsByTarget(targetType, targetId) {
+        const rows = this.db.prepare('SELECT * FROM flags WHERE targetType = ? AND targetId = ?').all(targetType, targetId);
+        return rows.map(r => this.deserializeFlag(r));
+    }
+    async getFlagByUser(targetType, targetId, flaggedBy) {
+        const row = this.db.prepare('SELECT * FROM flags WHERE targetType = ? AND targetId = ? AND flaggedBy = ?').get(targetType, targetId, flaggedBy);
+        return row ? this.deserializeFlag(row) : null;
+    }
+    async getFlagSummary(targetType, targetId) {
+        const rows = this.db.prepare('SELECT * FROM flags WHERE targetType = ? AND targetId = ?').all(targetType, targetId);
+        if (rows.length === 0)
+            return null;
+        const byReason = {};
+        let latestFlag = '';
+        for (const r of rows) {
+            const reason = r.reason;
+            byReason[reason] = (byReason[reason] ?? 0) + 1;
+            if (r.createdAt > latestFlag)
+                latestFlag = r.createdAt;
+        }
+        return {
+            targetType,
+            targetId,
+            totalFlags: rows.length,
+            byReason,
+            latestFlag,
+        };
+    }
+    async updateFlag(id, updates) {
+        const existing = await this.getFlag(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE flags SET targetType = ?, targetId = ?, flaggedBy = ?, reason = ?,
+       description = ?, status = ?, reviewedBy = ?, reviewedAt = ?, createdAt = ? WHERE id = ?`).run(updated.targetType, updated.targetId, updated.flaggedBy, updated.reason, updated.description ?? null, updated.status, updated.reviewedBy ?? null, updated.reviewedAt ?? null, updated.createdAt, id);
+        return updated;
+    }
+    async listFlags(opts) {
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        let sql = 'SELECT * FROM flags WHERE 1=1';
+        const params = [];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        if (opts?.targetType) {
+            sql += ' AND targetType = ?';
+            params.push(opts.targetType);
+        }
+        sql += ' ORDER BY createdAt DESC';
+        sql += ' LIMIT ? OFFSET ?';
+        params.push(perPage, (page - 1) * perPage);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeFlag(r));
+    }
+    deserializeFlag(row) {
+        const record = {
+            id: row.id,
+            targetType: row.targetType,
+            targetId: row.targetId,
+            flaggedBy: row.flaggedBy,
+            reason: row.reason,
+            status: row.status,
+            createdAt: row.createdAt,
+        };
+        if (row.description)
+            record.description = row.description;
+        if (row.reviewedBy)
+            record.reviewedBy = row.reviewedBy;
+        if (row.reviewedAt)
+            record.reviewedAt = row.reviewedAt;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Matches ──
+    // ══════════════════════════════════════════════════════════
+    async createMatch(record) {
+        this.db.prepare(`INSERT INTO matches (id, profileA, profileB, score, breakdown, status, notifiedAt, respondedAt, expiresAt, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.profileA, record.profileB, record.score, JSON.stringify(record.breakdown), record.status, record.notifiedAt, record.respondedAt, record.expiresAt, record.createdAt);
+        return record;
+    }
+    async getMatch(id) {
+        const row = this.db.prepare('SELECT * FROM matches WHERE id = ?').get(id);
+        return row ? this.deserializeMatch(row) : null;
+    }
+    async getMatchByPair(profileA, profileB) {
+        const row = this.db.prepare('SELECT * FROM matches WHERE (profileA = ? AND profileB = ?) OR (profileA = ? AND profileB = ?)').get(profileA, profileB, profileB, profileA);
+        return row ? this.deserializeMatch(row) : null;
+    }
+    async listMatchesByProfile(profile, opts) {
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 10;
+        let sql = 'SELECT * FROM matches WHERE (profileA = ? OR profileB = ?)';
+        const params = [profile, profile];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        sql += ' ORDER BY createdAt DESC LIMIT ? OFFSET ?';
+        params.push(perPage, (page - 1) * perPage);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeMatch(r));
+    }
+    async updateMatch(id, updates) {
+        const existing = await this.getMatch(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE matches SET profileA = ?, profileB = ?, score = ?, breakdown = ?,
+       status = ?, notifiedAt = ?, respondedAt = ?, expiresAt = ?, createdAt = ? WHERE id = ?`).run(updated.profileA, updated.profileB, updated.score, JSON.stringify(updated.breakdown), updated.status, updated.notifiedAt, updated.respondedAt, updated.expiresAt, updated.createdAt, id);
+        return updated;
+    }
+    async deleteExpiredMatches() {
+        const now = new Date().toISOString();
+        const result = this.db.prepare(`DELETE FROM matches WHERE expiresAt < ? AND status != 'accepted'`).run(now);
+        return result.changes;
+    }
+    async listAllMatches(limit = 10000) {
+        const rows = this.db.prepare('SELECT * FROM matches ORDER BY createdAt DESC LIMIT ?').all(Math.min(limit, 10000));
+        return rows.map(r => this.deserializeMatch(r));
+    }
+    deserializeMatch(row) {
+        return {
+            id: row.id,
+            profileA: row.profileA,
+            profileB: row.profileB,
+            score: row.score,
+            breakdown: JSON.parse(row.breakdown),
+            status: row.status,
+            notifiedAt: row.notifiedAt ?? null,
+            respondedAt: row.respondedAt ?? null,
+            expiresAt: row.expiresAt,
+            createdAt: row.createdAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Organisms ──
+    // ══════════════════════════════════════════════════════════
+    async createOrganism(record) {
+        this.db.prepare(`INSERT INTO organisms (id, name, description, type, location, interests, creatorGhii, admins,
+       members, agentGaiis, boardId, joinPolicy, maxMembers, visibility, moderationConfig,
+       memoryNamespace, semantic, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.name, record.description, record.type, record.location ? JSON.stringify(record.location) : null, JSON.stringify(record.interests), record.creatorGhii, JSON.stringify(record.admins), JSON.stringify(record.members), JSON.stringify(record.agentGaiis), record.boardId, record.joinPolicy, record.maxMembers, record.visibility, JSON.stringify(record.moderationConfig), record.memoryNamespace, record.semantic ? JSON.stringify(record.semantic) : null, record.createdAt, record.updatedAt);
+        return record;
+    }
+    async getOrganism(id) {
+        const row = this.db.prepare('SELECT * FROM organisms WHERE id = ?').get(id);
+        return row ? this.deserializeOrganism(row) : null;
+    }
+    async listOrganisms(opts) {
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const rows = this.db.prepare('SELECT * FROM organisms ORDER BY createdAt DESC').all();
+        let results = rows.map(r => this.deserializeOrganism(r));
+        if (opts?.type)
+            results = results.filter(o => o.type === opts.type);
+        if (opts?.city)
+            results = results.filter(o => o.location?.city?.toLowerCase() === opts.city.toLowerCase());
+        if (opts?.interest)
+            results = results.filter(o => o.interests.some(i => i.toLowerCase() === opts.interest.toLowerCase()));
+        if (opts?.member)
+            results = results.filter(o => o.members.includes(opts.member));
+        if (opts?.visibility)
+            results = results.filter(o => o.visibility === opts.visibility);
+        const start = (page - 1) * perPage;
+        return results.slice(start, start + perPage);
+    }
+    async updateOrganism(id, updates) {
+        const existing = await this.getOrganism(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, id: existing.id };
+        this.db.prepare(`UPDATE organisms SET name = ?, description = ?, type = ?, location = ?, interests = ?,
+       creatorGhii = ?, admins = ?, members = ?, agentGaiis = ?, boardId = ?,
+       joinPolicy = ?, maxMembers = ?, visibility = ?, moderationConfig = ?,
+       memoryNamespace = ?, semantic = ?, createdAt = ?, updatedAt = ? WHERE id = ?`).run(updated.name, updated.description, updated.type, updated.location ? JSON.stringify(updated.location) : null, JSON.stringify(updated.interests), updated.creatorGhii, JSON.stringify(updated.admins), JSON.stringify(updated.members), JSON.stringify(updated.agentGaiis), updated.boardId, updated.joinPolicy, updated.maxMembers, updated.visibility, JSON.stringify(updated.moderationConfig), updated.memoryNamespace, updated.semantic ? JSON.stringify(updated.semantic) : null, updated.createdAt, updated.updatedAt, id);
+        return updated;
+    }
+    async deleteOrganism(id) {
+        const txn = this.db.transaction(() => {
+            // Get the organism to find its boardId and memoryNamespace
+            const org = this.db.prepare('SELECT boardId, memoryNamespace FROM organisms WHERE id = ?').get(id);
+            // Cascade: delete memberships and join requests
+            this.db.prepare('DELETE FROM organism_memberships WHERE organismId = ?').run(id);
+            this.db.prepare('DELETE FROM join_requests WHERE organismId = ?').run(id);
+            // Cascade: delete organism reputation
+            this.db.prepare('DELETE FROM organism_reputations WHERE organismId = ?').run(id);
+            if (org) {
+                // Cascade: delete the organism's board and its posts/subscriptions
+                this.db.prepare('DELETE FROM board_posts WHERE boardId = ?').run(org.boardId);
+                this.db.prepare('DELETE FROM board_subscriptions WHERE boardId = ?').run(org.boardId);
+                this.db.prepare('DELETE FROM boards WHERE id = ?').run(org.boardId);
+                // Cascade: delete memory entries under the organism's namespace
+                this.db.prepare('DELETE FROM memory WHERE ownerGaii = ?').run(org.memoryNamespace);
+            }
+            const result = this.db.prepare('DELETE FROM organisms WHERE id = ?').run(id);
+            return result.changes > 0;
+        });
+        return txn();
+    }
+    deserializeOrganism(row) {
+        const record = {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            type: row.type,
+            interests: JSON.parse(row.interests),
+            creatorGhii: row.creatorGhii,
+            admins: JSON.parse(row.admins),
+            members: JSON.parse(row.members),
+            agentGaiis: JSON.parse(row.agentGaiis),
+            boardId: row.boardId,
+            joinPolicy: row.joinPolicy,
+            maxMembers: row.maxMembers,
+            visibility: row.visibility,
+            moderationConfig: JSON.parse(row.moderationConfig),
+            memoryNamespace: row.memoryNamespace,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.location)
+            record.location = JSON.parse(row.location);
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Memberships ──
+    // ══════════════════════════════════════════════════════════
+    async createMembership(record) {
+        this.db.prepare(`INSERT INTO organism_memberships (id, organismId, ghii, role, status, joinedAt, invitedBy)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.organismId, record.ghii, record.role, record.status, record.joinedAt, record.invitedBy ?? null);
+        return record;
+    }
+    async getMembership(organismId, ghii) {
+        const row = this.db.prepare('SELECT * FROM organism_memberships WHERE organismId = ? AND ghii = ?').get(organismId, ghii);
+        return row ? this.deserializeMembership(row) : null;
+    }
+    async listMembers(organismId, opts) {
+        let sql = 'SELECT * FROM organism_memberships WHERE organismId = ?';
+        const params = [organismId];
+        if (opts?.role) {
+            sql += ' AND role = ?';
+            params.push(opts.role);
+        }
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeMembership(r));
+    }
+    async listMembershipsByGhii(ghii) {
+        const rows = this.db.prepare('SELECT * FROM organism_memberships WHERE ghii = ?').all(ghii);
+        return rows.map(r => this.deserializeMembership(r));
+    }
+    async updateMembership(id, updates) {
+        const row = this.db.prepare('SELECT * FROM organism_memberships WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        const existing = this.deserializeMembership(row);
+        const updated = { ...existing, ...updates, id: existing.id };
+        this.db.prepare(`UPDATE organism_memberships SET organismId = ?, ghii = ?, role = ?, status = ?, joinedAt = ?, invitedBy = ? WHERE id = ?`).run(updated.organismId, updated.ghii, updated.role, updated.status, updated.joinedAt, updated.invitedBy ?? null, id);
+        return updated;
+    }
+    async deleteMembership(id) {
+        const result = this.db.prepare('DELETE FROM organism_memberships WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deserializeMembership(row) {
+        const record = {
+            id: row.id,
+            organismId: row.organismId,
+            ghii: row.ghii,
+            role: row.role,
+            status: row.status,
+            joinedAt: row.joinedAt,
+        };
+        if (row.invitedBy)
+            record.invitedBy = row.invitedBy;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Join Requests ──
+    // ══════════════════════════════════════════════════════════
+    async createJoinRequest(record) {
+        this.db.prepare(`INSERT INTO join_requests (id, organismId, ghii, message, status, reviewedBy, createdAt, reviewedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.organismId, record.ghii, record.message ?? null, record.status, record.reviewedBy ?? null, record.createdAt, record.reviewedAt ?? null);
+        return record;
+    }
+    async getJoinRequest(id) {
+        const row = this.db.prepare('SELECT * FROM join_requests WHERE id = ?').get(id);
+        return row ? this.deserializeJoinRequest(row) : null;
+    }
+    async listJoinRequests(organismId, opts) {
+        let sql = 'SELECT * FROM join_requests WHERE organismId = ?';
+        const params = [organismId];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeJoinRequest(r));
+    }
+    async updateJoinRequest(id, updates) {
+        const existing = await this.getJoinRequest(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, id: existing.id };
+        this.db.prepare(`UPDATE join_requests SET organismId = ?, ghii = ?, message = ?, status = ?,
+       reviewedBy = ?, createdAt = ?, reviewedAt = ? WHERE id = ?`).run(updated.organismId, updated.ghii, updated.message ?? null, updated.status, updated.reviewedBy ?? null, updated.createdAt, updated.reviewedAt ?? null, id);
+        return updated;
+    }
+    deserializeJoinRequest(row) {
+        const record = {
+            id: row.id,
+            organismId: row.organismId,
+            ghii: row.ghii,
+            status: row.status,
+            createdAt: row.createdAt,
+        };
+        if (row.message)
+            record.message = row.message;
+        if (row.reviewedBy)
+            record.reviewedBy = row.reviewedBy;
+        if (row.reviewedAt)
+            record.reviewedAt = row.reviewedAt;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Appeals ──
+    // ══════════════════════════════════════════════════════════
+    async createAppeal(record) {
+        this.db.prepare(`INSERT INTO appeals (id, flagId, appealedBy, reason, status, reviewedBy, reviewNote, createdAt, reviewedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.flagId, record.appealedBy, record.reason, record.status, record.reviewedBy ?? null, record.reviewNote ?? null, record.createdAt, record.reviewedAt ?? null);
+        return record;
+    }
+    async getAppeal(id) {
+        const row = this.db.prepare('SELECT * FROM appeals WHERE id = ?').get(id);
+        return row ? this.deserializeAppeal(row) : null;
+    }
+    async getAppealByFlagId(flagId) {
+        const row = this.db.prepare('SELECT * FROM appeals WHERE flagId = ?').get(flagId);
+        return row ? this.deserializeAppeal(row) : null;
+    }
+    async listAppeals(opts) {
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        let sql = 'SELECT * FROM appeals WHERE 1=1';
+        const params = [];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        sql += ' ORDER BY createdAt DESC LIMIT ? OFFSET ?';
+        params.push(perPage, (page - 1) * perPage);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeAppeal(r));
+    }
+    async updateAppeal(id, updates) {
+        const existing = await this.getAppeal(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, id: existing.id };
+        this.db.prepare(`UPDATE appeals SET flagId = ?, appealedBy = ?, reason = ?, status = ?,
+       reviewedBy = ?, reviewNote = ?, createdAt = ?, reviewedAt = ? WHERE id = ?`).run(updated.flagId, updated.appealedBy, updated.reason, updated.status, updated.reviewedBy ?? null, updated.reviewNote ?? null, updated.createdAt, updated.reviewedAt ?? null, id);
+        return updated;
+    }
+    deserializeAppeal(row) {
+        const record = {
+            id: row.id,
+            flagId: row.flagId,
+            appealedBy: row.appealedBy,
+            reason: row.reason,
+            status: row.status,
+            createdAt: row.createdAt,
+        };
+        if (row.reviewedBy)
+            record.reviewedBy = row.reviewedBy;
+        if (row.reviewNote)
+            record.reviewNote = row.reviewNote;
+        if (row.reviewedAt)
+            record.reviewedAt = row.reviewedAt;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Marketplace ──
+    // ══════════════════════════════════════════════════════════
+    async createListing(record) {
+        this.db.prepare(`INSERT INTO listings (id, ownerName, sellerGhii, title, description, category, priceMorsels,
+       condition, availability, location, tags, images, status, memoryKey, flagCount, createdAt, updatedAt, semantic)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.ownerName, record.sellerGhii, record.title, record.description, record.category, record.priceMorsels, record.condition ?? null, record.availability ?? null, record.location ? JSON.stringify(record.location) : null, record.tags ? JSON.stringify(record.tags) : null, record.images ? JSON.stringify(record.images) : null, record.status, record.memoryKey, record.flagCount, record.createdAt, record.updatedAt, record.semantic ? JSON.stringify(record.semantic) : null);
+        return record;
+    }
+    async getListing(id) {
+        const row = this.db.prepare('SELECT * FROM listings WHERE id = ?').get(id);
+        return row ? this.deserializeListing(row) : null;
+    }
+    async listListings(opts) {
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const rows = this.db.prepare('SELECT * FROM listings ORDER BY createdAt DESC').all();
+        let results = rows.map(r => this.deserializeListing(r));
+        if (opts?.category)
+            results = results.filter(l => l.category === opts.category);
+        if (opts?.city)
+            results = results.filter(l => l.location?.city?.toLowerCase() === opts.city.toLowerCase());
+        if (opts?.minPrice !== undefined)
+            results = results.filter(l => l.priceMorsels >= opts.minPrice);
+        if (opts?.maxPrice !== undefined)
+            results = results.filter(l => l.priceMorsels <= opts.maxPrice);
+        if (opts?.status)
+            results = results.filter(l => l.status === opts.status);
+        if (opts?.sellerOwner)
+            results = results.filter(l => l.ownerName === opts.sellerOwner);
+        const start = (page - 1) * perPage;
+        return results.slice(start, start + perPage);
+    }
+    async updateListing(id, updates) {
+        const existing = await this.getListing(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, id: existing.id };
+        this.db.prepare(`UPDATE listings SET ownerName = ?, sellerGhii = ?, title = ?, description = ?,
+       category = ?, priceMorsels = ?, condition = ?, availability = ?, location = ?,
+       tags = ?, images = ?, status = ?, memoryKey = ?, flagCount = ?,
+       createdAt = ?, updatedAt = ?, semantic = ? WHERE id = ?`).run(updated.ownerName, updated.sellerGhii, updated.title, updated.description, updated.category, updated.priceMorsels, updated.condition ?? null, updated.availability ?? null, updated.location ? JSON.stringify(updated.location) : null, updated.tags ? JSON.stringify(updated.tags) : null, updated.images ? JSON.stringify(updated.images) : null, updated.status, updated.memoryKey, updated.flagCount, updated.createdAt, updated.updatedAt, updated.semantic ? JSON.stringify(updated.semantic) : null, id);
+        return updated;
+    }
+    async deleteListing(id) {
+        const result = this.db.prepare('DELETE FROM listings WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async createPurchase(record) {
+        this.db.prepare(`INSERT INTO purchases (id, listingId, buyerOwner, sellerOwner, priceMorsels,
+       transactionFeeMorsels, totalCostMorsels, status, rating, trackingCode, createdAt, completedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.listingId, record.buyerOwner, record.sellerOwner, record.priceMorsels, record.transactionFeeMorsels, record.totalCostMorsels, record.status, record.rating ? JSON.stringify(record.rating) : null, record.trackingCode, record.createdAt, record.completedAt ?? null);
+        return record;
+    }
+    async getPurchase(id) {
+        const row = this.db.prepare('SELECT * FROM purchases WHERE id = ?').get(id);
+        return row ? this.deserializePurchase(row) : null;
+    }
+    async listPurchasesByBuyer(buyerOwner) {
+        const rows = this.db.prepare('SELECT * FROM purchases WHERE buyerOwner = ? ORDER BY createdAt DESC').all(buyerOwner);
+        return rows.map(r => this.deserializePurchase(r));
+    }
+    async listPurchasesBySeller(sellerOwner) {
+        const rows = this.db.prepare('SELECT * FROM purchases WHERE sellerOwner = ? ORDER BY createdAt DESC').all(sellerOwner);
+        return rows.map(r => this.deserializePurchase(r));
+    }
+    async updatePurchase(id, updates) {
+        const existing = await this.getPurchase(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates, id: existing.id };
+        this.db.prepare(`UPDATE purchases SET listingId = ?, buyerOwner = ?, sellerOwner = ?, priceMorsels = ?,
+       transactionFeeMorsels = ?, totalCostMorsels = ?, status = ?, rating = ?,
+       trackingCode = ?, createdAt = ?, completedAt = ? WHERE id = ?`).run(updated.listingId, updated.buyerOwner, updated.sellerOwner, updated.priceMorsels, updated.transactionFeeMorsels, updated.totalCostMorsels, updated.status, updated.rating ? JSON.stringify(updated.rating) : null, updated.trackingCode, updated.createdAt, updated.completedAt ?? null, id);
+        return updated;
+    }
+    deserializeListing(row) {
+        const record = {
+            id: row.id,
+            ownerName: row.ownerName,
+            sellerGhii: row.sellerGhii,
+            title: row.title,
+            description: row.description,
+            category: row.category,
+            priceMorsels: row.priceMorsels,
+            status: row.status,
+            memoryKey: row.memoryKey,
+            flagCount: row.flagCount,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.condition)
+            record.condition = row.condition;
+        if (row.availability)
+            record.availability = row.availability;
+        if (row.location)
+            record.location = JSON.parse(row.location);
+        if (row.tags)
+            record.tags = JSON.parse(row.tags);
+        if (row.images)
+            record.images = JSON.parse(row.images);
+        if (row.semantic)
+            record.semantic = JSON.parse(row.semantic);
+        return record;
+    }
+    deserializePurchase(row) {
+        const record = {
+            id: row.id,
+            listingId: row.listingId,
+            buyerOwner: row.buyerOwner,
+            sellerOwner: row.sellerOwner,
+            priceMorsels: row.priceMorsels,
+            transactionFeeMorsels: row.transactionFeeMorsels,
+            totalCostMorsels: row.totalCostMorsels,
+            status: row.status,
+            trackingCode: row.trackingCode,
+            createdAt: row.createdAt,
+        };
+        if (row.rating)
+            record.rating = JSON.parse(row.rating);
+        if (row.completedAt)
+            record.completedAt = row.completedAt;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Push Subscriptions ──
+    // ══════════════════════════════════════════════════════════
+    async createPushSubscription(record) {
+        this.db.prepare(`INSERT OR REPLACE INTO push_subscriptions (ownerName, endpoint, keys, createdAt, lastUsedAt)
+       VALUES (?, ?, ?, ?, ?)`).run(record.ownerName, record.endpoint, JSON.stringify(record.keys), record.createdAt, record.lastUsedAt);
+        return record;
+    }
+    async getPushSubscription(ownerName) {
+        const row = this.db.prepare('SELECT * FROM push_subscriptions WHERE ownerName = ?').get(ownerName);
+        if (!row)
+            return null;
+        return {
+            ownerName: row.ownerName,
+            endpoint: row.endpoint,
+            keys: JSON.parse(row.keys),
+            createdAt: row.createdAt,
+            lastUsedAt: row.lastUsedAt,
+        };
+    }
+    async deletePushSubscription(ownerName) {
+        const result = this.db.prepare('DELETE FROM push_subscriptions WHERE ownerName = ?').run(ownerName);
+        return result.changes > 0;
+    }
+    async listPushSubscriptions() {
+        const rows = this.db.prepare('SELECT * FROM push_subscriptions').all();
+        return rows.map(r => ({
+            ownerName: r.ownerName,
+            endpoint: r.endpoint,
+            keys: JSON.parse(r.keys),
+            createdAt: r.createdAt,
+            lastUsedAt: r.lastUsedAt,
+        }));
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Trusted Issuers ──
+    // ══════════════════════════════════════════════════════════
+    async createTrustedIssuer(record) {
+        this.db.prepare(`INSERT INTO trusted_issuers (id, name, url, publicKey, type, trusted, addedBy, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.name, record.url, record.publicKey, record.type, record.trusted ? 1 : 0, record.addedBy, record.createdAt);
+        return record;
+    }
+    async getTrustedIssuer(id) {
+        const row = this.db.prepare('SELECT * FROM trusted_issuers WHERE id = ?').get(id);
+        return row ? this.deserializeTrustedIssuer(row) : null;
+    }
+    async getTrustedIssuerByUrl(url) {
+        const row = this.db.prepare('SELECT * FROM trusted_issuers WHERE url = ?').get(url);
+        return row ? this.deserializeTrustedIssuer(row) : null;
+    }
+    async listTrustedIssuers(opts) {
+        let sql = 'SELECT * FROM trusted_issuers';
+        const params = [];
+        if (opts?.type) {
+            sql += ' WHERE type = ?';
+            params.push(opts.type);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeTrustedIssuer(r));
+    }
+    async deleteTrustedIssuer(id) {
+        const result = this.db.prepare('DELETE FROM trusted_issuers WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deserializeTrustedIssuer(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            url: row.url,
+            publicKey: row.publicKey,
+            type: row.type,
+            trusted: row.trusted === 1,
+            addedBy: row.addedBy,
+            createdAt: row.createdAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Genesis Peers ──
+    // ══════════════════════════════════════════════════════════
+    async createGenesisPeer(record) {
+        this.db.prepare(`INSERT INTO genesis_peers (id, genesisNodeId, genesisUrl, publicKey, status, lastSyncAt, catalogueHash, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.genesisNodeId, record.genesisUrl, record.publicKey, record.status, record.lastSyncAt, record.catalogueHash, record.createdAt, record.updatedAt);
+        return record;
+    }
+    async getGenesisPeer(id) {
+        const row = this.db.prepare('SELECT * FROM genesis_peers WHERE id = ?').get(id);
+        return row ? this.deserializeGenesisPeer(row) : null;
+    }
+    async getGenesisPeerByNodeId(nodeId) {
+        const row = this.db.prepare('SELECT * FROM genesis_peers WHERE genesisNodeId = ?').get(nodeId);
+        return row ? this.deserializeGenesisPeer(row) : null;
+    }
+    async listGenesisPeers(opts) {
+        let sql = 'SELECT * FROM genesis_peers';
+        const params = [];
+        if (opts?.status) {
+            sql += ' WHERE status = ?';
+            params.push(opts.status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeGenesisPeer(r));
+    }
+    async updateGenesisPeer(id, updates) {
+        const existing = await this.getGenesisPeer(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE genesis_peers SET genesisNodeId = ?, genesisUrl = ?, publicKey = ?, status = ?,
+       lastSyncAt = ?, catalogueHash = ?, createdAt = ?, updatedAt = ? WHERE id = ?`).run(updated.genesisNodeId, updated.genesisUrl, updated.publicKey, updated.status, updated.lastSyncAt, updated.catalogueHash, updated.createdAt, updated.updatedAt, id);
+        return updated;
+    }
+    async deleteGenesisPeer(id) {
+        const result = this.db.prepare('DELETE FROM genesis_peers WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deserializeGenesisPeer(row) {
+        return {
+            id: row.id,
+            genesisNodeId: row.genesisNodeId,
+            genesisUrl: row.genesisUrl,
+            publicKey: row.publicKey,
+            status: row.status,
+            lastSyncAt: row.lastSyncAt,
+            catalogueHash: row.catalogueHash,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Organism Reputation ──
+    // ══════════════════════════════════════════════════════════
+    async setOrganismReputation(record) {
+        this.db.prepare(`INSERT OR REPLACE INTO organism_reputations (organismId, score, breakdown, calculatedAt)
+       VALUES (?, ?, ?, ?)`).run(record.organismId, record.score, JSON.stringify(record.breakdown), record.calculatedAt);
+        return record;
+    }
+    async getOrganismReputation(organismId) {
+        const row = this.db.prepare('SELECT * FROM organism_reputations WHERE organismId = ?').get(organismId);
+        if (!row)
+            return null;
+        return {
+            organismId: row.organismId,
+            score: row.score,
+            breakdown: JSON.parse(row.breakdown),
+            calculatedAt: row.calculatedAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Realtime Rooms ──
+    // ══════════════════════════════════════════════════════════
+    async createRealtimeRoom(room) {
+        this.db.prepare(`INSERT INTO realtime_rooms (id, appType, name, createdBy, maxPeers, isPublic, tags, peerCount, createdAt, lastActivityAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(room.id, room.appType, room.name, room.createdBy, room.maxPeers, room.isPublic ? 1 : 0, JSON.stringify(room.tags), room.peerCount, room.createdAt, room.lastActivityAt);
+        return room;
+    }
+    async getRealtimeRoom(id) {
+        const row = this.db.prepare('SELECT * FROM realtime_rooms WHERE id = ?').get(id);
+        return row ? this.deserializeRealtimeRoom(row) : null;
+    }
+    async listRealtimeRooms(filter) {
+        let sql = 'SELECT * FROM realtime_rooms WHERE 1=1';
+        const params = [];
+        if (filter?.appType) {
+            sql += ' AND appType = ?';
+            params.push(filter.appType);
+        }
+        if (filter?.isPublic !== undefined) {
+            sql += ' AND isPublic = ?';
+            params.push(filter.isPublic ? 1 : 0);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeRealtimeRoom(r));
+    }
+    async updateRealtimeRoom(id, updates) {
+        const existing = await this.getRealtimeRoom(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE realtime_rooms SET appType = ?, name = ?, createdBy = ?, maxPeers = ?,
+       isPublic = ?, tags = ?, peerCount = ?, createdAt = ?, lastActivityAt = ? WHERE id = ?`).run(updated.appType, updated.name, updated.createdBy, updated.maxPeers, updated.isPublic ? 1 : 0, JSON.stringify(updated.tags), updated.peerCount, updated.createdAt, updated.lastActivityAt, id);
+        return updated;
+    }
+    async deleteRealtimeRoom(id) {
+        const result = this.db.prepare('DELETE FROM realtime_rooms WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deserializeRealtimeRoom(row) {
+        return {
+            id: row.id,
+            appType: row.appType,
+            name: row.name,
+            createdBy: row.createdBy,
+            maxPeers: row.maxPeers,
+            isPublic: row.isPublic === 1,
+            tags: JSON.parse(row.tags),
+            peerCount: row.peerCount,
+            createdAt: row.createdAt,
+            lastActivityAt: row.lastActivityAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Site Change Log ──
+    // ══════════════════════════════════════════════════════════
+    async addSiteChangeLog(entry) {
+        this.db.prepare(`INSERT INTO site_changelog (id, action, summary, changedBy, changedAt) VALUES (?, ?, ?, ?, ?)`).run(entry.id, entry.action, entry.summary, entry.changedBy, entry.changedAt);
+        // Keep at most 200 entries (delete oldest beyond 200)
+        this.db.prepare(`DELETE FROM site_changelog WHERE id NOT IN (SELECT id FROM site_changelog ORDER BY changedAt DESC LIMIT 200)`).run();
+        return entry;
+    }
+    async listSiteChangeLog(limit, cursor) {
+        const sql = 'SELECT * FROM site_changelog ORDER BY changedAt DESC';
+        const params = [];
+        const allRows = this.db.prepare(sql).all(...params);
+        let entries = allRows.map(r => ({
+            id: r.id,
+            action: r.action,
+            summary: r.summary,
+            changedBy: r.changedBy,
+            changedAt: r.changedAt,
+        }));
+        if (cursor) {
+            const idx = entries.findIndex(e => e.id === cursor);
+            if (idx >= 0)
+                entries = entries.slice(idx + 1);
+        }
+        return entries.slice(0, limit);
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Extensions ──
+    // ══════════════════════════════════════════════════════════
+    async createExtension(record) {
+        try {
+            this.db.prepare(`INSERT INTO extensions (name, version, description, author, status, requiredApis,
+         actions, config, limits, federation, instances, installedBy, installedAt, activatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.name, record.version, record.description, record.author, record.status, JSON.stringify(record.requiredApis), JSON.stringify(record.actions), JSON.stringify(record.config), JSON.stringify(record.limits), JSON.stringify(record.federation), record.instances ? JSON.stringify(record.instances) : null, record.installedBy, record.installedAt, record.activatedAt ?? null);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed')) {
+                throw new Error(`Extension "${record.name}" already exists`, { cause: err });
+            }
+            throw err;
+        }
+    }
+    async getExtension(name) {
+        const row = this.db.prepare('SELECT * FROM extensions WHERE name = ?').get(name);
+        return row ? this.deserializeExtension(row) : null;
+    }
+    async listExtensions(opts) {
+        let sql = 'SELECT * FROM extensions';
+        const params = [];
+        if (opts?.status) {
+            sql += ' WHERE status = ?';
+            params.push(opts.status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeExtension(r));
+    }
+    async updateExtension(name, updates) {
+        const existing = await this.getExtension(name);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE extensions SET version = ?, description = ?, author = ?, status = ?,
+       requiredApis = ?, actions = ?, config = ?, limits = ?, federation = ?,
+       instances = ?, installedBy = ?, installedAt = ?, activatedAt = ? WHERE name = ?`).run(updated.version, updated.description, updated.author, updated.status, JSON.stringify(updated.requiredApis), JSON.stringify(updated.actions), JSON.stringify(updated.config), JSON.stringify(updated.limits), JSON.stringify(updated.federation), updated.instances ? JSON.stringify(updated.instances) : null, updated.installedBy, updated.installedAt, updated.activatedAt ?? null, name);
+        return updated;
+    }
+    async deleteExtension(name) {
+        const result = this.db.prepare('DELETE FROM extensions WHERE name = ?').run(name);
+        return result.changes > 0;
+    }
+    deserializeExtension(row) {
+        const record = {
+            name: row.name,
+            version: row.version,
+            description: row.description,
+            author: row.author,
+            status: row.status,
+            requiredApis: JSON.parse(row.requiredApis),
+            actions: JSON.parse(row.actions),
+            config: JSON.parse(row.config),
+            limits: JSON.parse(row.limits),
+            federation: JSON.parse(row.federation),
+            installedBy: row.installedBy,
+            installedAt: row.installedAt,
+        };
+        if (row.activatedAt)
+            record.activatedAt = row.activatedAt;
+        if (row.instances)
+            record.instances = JSON.parse(row.instances);
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Escrow Holds ──
+    // ══════════════════════════════════════════════════════════
+    async createEscrowHold(record) {
+        this.db.prepare(`INSERT INTO escrow_holds (holdId, fromGaii, amount, reason, status, extensionName, createdAt, releasedAt, releasedTo)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.holdId, record.fromGaii, record.amount, record.reason, record.status, record.extensionName, record.createdAt, record.releasedAt ?? null, record.releasedTo ?? null);
+        return record;
+    }
+    async getEscrowHold(holdId) {
+        const row = this.db.prepare('SELECT * FROM escrow_holds WHERE holdId = ?').get(holdId);
+        return row ? this.deserializeEscrowHold(row) : null;
+    }
+    async listEscrowHolds(fromGaii, opts) {
+        let sql = 'SELECT * FROM escrow_holds WHERE fromGaii = ?';
+        const params = [fromGaii];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeEscrowHold(r));
+    }
+    async releaseEscrowHold(holdId, toGaii) {
+        const hold = await this.getEscrowHold(holdId);
+        if (!hold)
+            return null;
+        if (hold.status !== 'held')
+            return null;
+        const updated = {
+            ...hold,
+            status: 'released',
+            releasedTo: toGaii,
+            releasedAt: new Date().toISOString(),
+        };
+        this.db.prepare('UPDATE escrow_holds SET status = ?, releasedTo = ?, releasedAt = ? WHERE holdId = ?').run(updated.status, updated.releasedTo, updated.releasedAt, holdId);
+        return updated;
+    }
+    async refundEscrowHold(holdId) {
+        const hold = await this.getEscrowHold(holdId);
+        if (!hold)
+            return null;
+        if (hold.status !== 'held')
+            return null;
+        const updated = {
+            ...hold,
+            status: 'refunded',
+            releasedAt: new Date().toISOString(),
+        };
+        this.db.prepare('UPDATE escrow_holds SET status = ?, releasedAt = ? WHERE holdId = ?').run(updated.status, updated.releasedAt, holdId);
+        return updated;
+    }
+    deserializeEscrowHold(row) {
+        const record = {
+            holdId: row.holdId,
+            fromGaii: row.fromGaii,
+            amount: row.amount,
+            reason: row.reason,
+            status: row.status,
+            extensionName: row.extensionName,
+            createdAt: row.createdAt,
+        };
+        if (row.releasedAt)
+            record.releasedAt = row.releasedAt;
+        if (row.releasedTo)
+            record.releasedTo = row.releasedTo;
+        return record;
+    }
+    // ── Cortex Extensions ──────────────────────────────────────────
+    async createCortexExtension(record) {
+        const existing = this.db.prepare('SELECT name FROM cortex_extensions WHERE name = ?').get(record.name);
+        if (existing)
+            throw new Error(`Cortex extension "${record.name}" already exists`);
+        this.db.prepare(`INSERT INTO cortex_extensions (name, namespace, shortName, apiVersion, version, description, author, license, tags, labels, aimeatCompat, status, visibility, installedAt, activatedAt, installedBy, manifest, components, activationArtifacts) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.name, record.namespace, record.shortName, record.apiVersion, record.version, record.description, record.author, record.license ?? null, JSON.stringify(record.tags), JSON.stringify(record.labels), record.aimeatCompat ?? null, record.status, record.visibility ?? 'private', record.installedAt, record.activatedAt ?? null, record.installedBy, record.manifest, JSON.stringify(record.components), JSON.stringify(record.activationArtifacts));
+        return record;
+    }
+    async getCortexExtension(name) {
+        const row = this.db.prepare('SELECT * FROM cortex_extensions WHERE name = ?').get(name);
+        return row ? this.deserializeCortexExtension(row) : null;
+    }
+    async listCortexExtensions(opts) {
+        let sql = 'SELECT * FROM cortex_extensions WHERE 1=1';
+        const params = [];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        if (opts?.namespace) {
+            sql += ' AND namespace = ?';
+            params.push(opts.namespace);
+        }
+        if (opts?.visibility) {
+            sql += ' AND visibility = ?';
+            params.push(opts.visibility);
+        }
+        if (opts?.installedBy) {
+            sql += ' AND installedBy = ?';
+            params.push(opts.installedBy);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeCortexExtension(r));
+    }
+    async updateCortexExtension(name, updates) {
+        const existing = await this.getCortexExtension(name);
+        if (!existing)
+            return null;
+        const merged = { ...existing, ...updates };
+        this.db.prepare(`UPDATE cortex_extensions SET namespace=?, shortName=?, apiVersion=?, version=?, description=?, author=?, license=?, tags=?, labels=?, aimeatCompat=?, status=?, visibility=?, installedAt=?, activatedAt=?, installedBy=?, manifest=?, components=?, activationArtifacts=? WHERE name=?`).run(merged.namespace, merged.shortName, merged.apiVersion, merged.version, merged.description, merged.author, merged.license ?? null, JSON.stringify(merged.tags), JSON.stringify(merged.labels), merged.aimeatCompat ?? null, merged.status, merged.visibility ?? 'private', merged.installedAt, merged.activatedAt ?? null, merged.installedBy, merged.manifest, JSON.stringify(merged.components), JSON.stringify(merged.activationArtifacts), name);
+        return merged;
+    }
+    async deleteCortexExtension(name) {
+        const result = this.db.prepare('DELETE FROM cortex_extensions WHERE name = ?').run(name);
+        if (result.changes > 0) {
+            this.db.prepare('DELETE FROM cortex_lib_files WHERE extName = ?').run(name);
+        }
+        return result.changes > 0;
+    }
+    async setCortexLibFile(extName, libName, content) {
+        this.db.prepare('INSERT OR REPLACE INTO cortex_lib_files (extName, libName, content) VALUES (?, ?, ?)').run(extName, libName, content);
+    }
+    async getCortexLibFile(extName, libName) {
+        const row = this.db.prepare('SELECT content FROM cortex_lib_files WHERE extName = ? AND libName = ?').get(extName, libName);
+        return row?.content ?? null;
+    }
+    async deleteCortexLibFile(extName, libName) {
+        const result = this.db.prepare('DELETE FROM cortex_lib_files WHERE extName = ? AND libName = ?').run(extName, libName);
+        return result.changes > 0;
+    }
+    deserializeCortexExtension(row) {
+        return {
+            name: row.name,
+            namespace: row.namespace,
+            shortName: row.shortName,
+            apiVersion: row.apiVersion,
+            version: row.version,
+            description: row.description,
+            author: row.author,
+            license: row.license,
+            tags: JSON.parse(row.tags || '[]'),
+            labels: JSON.parse(row.labels || '{}'),
+            aimeatCompat: row.aimeatCompat,
+            status: row.status,
+            visibility: row.visibility === 'public' ? 'public' : 'private',
+            installedAt: row.installedAt,
+            activatedAt: row.activatedAt,
+            installedBy: row.installedBy,
+            manifest: row.manifest,
+            components: JSON.parse(row.components || '[]'),
+            activationArtifacts: JSON.parse(row.activationArtifacts || '{}'),
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Personal Push Subscriptions (REQ-007) ──
+    // ══════════════════════════════════════════════════════════
+    async createPersonalPushSubscription(record) {
+        this.db.prepare(`INSERT INTO personal_push_subscriptions (id, personalNodeId, ownerName, endpoint, keys, failureCount, createdAt, lastUsedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.personalNodeId, record.ownerName, record.endpoint, JSON.stringify(record.keys), record.failureCount, record.createdAt, record.lastUsedAt);
+        return record;
+    }
+    async getPersonalPushSubscription(id) {
+        const row = this.db.prepare('SELECT * FROM personal_push_subscriptions WHERE id = ?').get(id);
+        return row ? this.deserializePersonalPushSubscription(row) : null;
+    }
+    async listPersonalPushSubscriptions(personalNodeId) {
+        const rows = this.db.prepare('SELECT * FROM personal_push_subscriptions WHERE personalNodeId = ?').all(personalNodeId);
+        return rows.map(r => this.deserializePersonalPushSubscription(r));
+    }
+    async updatePersonalPushSubscription(id, updates) {
+        const existing = await this.getPersonalPushSubscription(id);
+        if (!existing)
+            return false;
+        const merged = { ...existing, ...updates };
+        this.db.prepare(`UPDATE personal_push_subscriptions
+       SET personalNodeId = ?, ownerName = ?, endpoint = ?, keys = ?, failureCount = ?, createdAt = ?, lastUsedAt = ?
+       WHERE id = ?`).run(merged.personalNodeId, merged.ownerName, merged.endpoint, JSON.stringify(merged.keys), merged.failureCount, merged.createdAt, merged.lastUsedAt, id);
+        return true;
+    }
+    async deletePersonalPushSubscription(id) {
+        const result = this.db.prepare('DELETE FROM personal_push_subscriptions WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async deletePersonalPushSubscriptionsByNode(personalNodeId) {
+        const result = this.db.prepare('DELETE FROM personal_push_subscriptions WHERE personalNodeId = ?').run(personalNodeId);
+        return result.changes;
+    }
+    async countPersonalPushSubscriptions(personalNodeId) {
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM personal_push_subscriptions WHERE personalNodeId = ?').get(personalNodeId);
+        return row.cnt ?? 0;
+    }
+    deserializePersonalPushSubscription(row) {
+        return {
+            id: row.id,
+            personalNodeId: row.personalNodeId,
+            ownerName: row.ownerName,
+            endpoint: row.endpoint,
+            keys: JSON.parse(row.keys),
+            failureCount: row.failureCount,
+            createdAt: row.createdAt,
+            lastUsedAt: row.lastUsedAt ?? null,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Notification Preferences (REQ-007) ──
+    // ══════════════════════════════════════════════════════════
+    async getNotificationPreferences(personalNodeId) {
+        const row = this.db.prepare('SELECT * FROM notification_preferences WHERE personalNodeId = ?').get(personalNodeId);
+        return row ? this.deserializeNotificationPreferences(row) : null;
+    }
+    async upsertNotificationPreferences(prefs) {
+        this.db.prepare(`INSERT INTO notification_preferences (personalNodeId, enabled, channels, notifyTypes, cooldownMinutes, quietHoursUtc, email)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(personalNodeId) DO UPDATE SET
+         enabled = excluded.enabled,
+         channels = excluded.channels,
+         notifyTypes = excluded.notifyTypes,
+         cooldownMinutes = excluded.cooldownMinutes,
+         quietHoursUtc = excluded.quietHoursUtc,
+         email = excluded.email`).run(prefs.personalNodeId, prefs.enabled ? 1 : 0, JSON.stringify(prefs.channels), JSON.stringify(prefs.notifyTypes), prefs.cooldownMinutes, prefs.quietHoursUtc ? JSON.stringify(prefs.quietHoursUtc) : null, prefs.email);
+        return prefs;
+    }
+    async deleteNotificationPreferences(personalNodeId) {
+        const result = this.db.prepare('DELETE FROM notification_preferences WHERE personalNodeId = ?').run(personalNodeId);
+        return result.changes > 0;
+    }
+    deserializeNotificationPreferences(row) {
+        return {
+            personalNodeId: row.personalNodeId,
+            enabled: row.enabled === 1,
+            channels: JSON.parse(row.channels),
+            notifyTypes: JSON.parse(row.notifyTypes),
+            cooldownMinutes: row.cooldownMinutes,
+            quietHoursUtc: row.quietHoursUtc ? JSON.parse(row.quietHoursUtc) : null,
+            email: row.email ?? null,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Notification Templates (Phase 3.2) ──
+    // ══════════════════════════════════════════════════════════
+    async getNotificationTemplate(id, locale) {
+        const row = this.db.prepare('SELECT * FROM notification_templates WHERE id = ? AND locale = ?').get(id, locale);
+        return row ? this.deserializeNotificationTemplate(row) : null;
+    }
+    async upsertNotificationTemplate(record) {
+        this.db.prepare(`
+      INSERT INTO notification_templates (id, locale, fields, placeholders, updatedAt, updatedBy)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id, locale) DO UPDATE SET fields = excluded.fields, placeholders = excluded.placeholders, updatedAt = excluded.updatedAt, updatedBy = excluded.updatedBy
+    `).run(record.id, record.locale, JSON.stringify(record.fields), JSON.stringify(record.placeholders), record.updatedAt, record.updatedBy);
+        return record;
+    }
+    async listNotificationTemplates() {
+        const rows = this.db.prepare('SELECT * FROM notification_templates ORDER BY id, locale').all();
+        return rows.map(r => this.deserializeNotificationTemplate(r));
+    }
+    async deleteAllNotificationTemplates() {
+        this.db.prepare('DELETE FROM notification_templates').run();
+    }
+    deserializeNotificationTemplate(row) {
+        return {
+            id: row.id,
+            locale: row.locale,
+            fields: JSON.parse(row.fields),
+            placeholders: JSON.parse(row.placeholders),
+            updatedAt: row.updatedAt,
+            updatedBy: row.updatedBy,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Sessions (P3-7: Server-Side Session Tracking) ──
+    // ══════════════════════════════════════════════════════════
+    async createSession(session) {
+        this.db.prepare('INSERT INTO sessions (sessionId, gaii, owner, issuedAt, expiresAt, revoked) VALUES (?, ?, ?, ?, ?, 0)').run(session.sessionId, session.gaii, session.owner, session.issuedAt, session.expiresAt);
+    }
+    async listActiveSessions(owner) {
+        return this.db.prepare('SELECT sessionId, gaii, owner, issuedAt, expiresAt, revoked FROM sessions WHERE owner = ? AND revoked = 0 ORDER BY issuedAt DESC').all(owner);
+    }
+    async revokeSession(sessionId) {
+        const result = this.db.prepare('UPDATE sessions SET revoked = 1 WHERE sessionId = ? AND revoked = 0').run(sessionId);
+        return result.changes > 0;
+    }
+    async revokeAllSessions(owner) {
+        const result = this.db.prepare('UPDATE sessions SET revoked = 1 WHERE owner = ? AND revoked = 0').run(owner);
+        return result.changes;
+    }
+    async isSessionRevoked(sessionId) {
+        const row = this.db.prepare('SELECT revoked FROM sessions WHERE sessionId = ?').get(sessionId);
+        if (!row)
+            return false; // session not tracked = not revoked
+        return row.revoked === 1;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Token Revocation ──
+    // ══════════════════════════════════════════════════════════
+    async revokeToken(tokenHash, expiresAt) {
+        this.db.prepare('INSERT OR REPLACE INTO revoked_tokens (token_hash, expires_at) VALUES (?, ?)').run(tokenHash, expiresAt);
+    }
+    async isTokenRevoked(tokenHash) {
+        const row = this.db.prepare('SELECT 1 FROM revoked_tokens WHERE token_hash = ?').get(tokenHash);
+        return !!row;
+    }
+    async cleanExpiredRevocations() {
+        const result = this.db.prepare('DELETE FROM revoked_tokens WHERE expires_at < ?').run(Math.floor(Date.now() / 1000));
+        return result.changes;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── App Catalog ──
+    // ══════════════════════════════════════════════════════════
+    async createApp(record) {
+        this.db.prepare(`INSERT INTO apps (ownerGaii, ownerName, filename, versionNumber, manifest, mimeType, size, data, accessCode, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.ownerGaii, record.ownerName, record.filename, record.versionNumber, JSON.stringify(record.manifest), record.mimeType, record.size, record.data, record.accessCode ?? null, record.createdAt);
+        return record;
+    }
+    async getApp(ownerGaii, filename, version) {
+        let row;
+        if (version !== undefined) {
+            row = this.db.prepare('SELECT * FROM apps WHERE ownerGaii = ? AND filename = ? AND versionNumber = ?')
+                .get(ownerGaii, filename, version);
+        }
+        else {
+            row = this.db.prepare('SELECT * FROM apps WHERE ownerGaii = ? AND filename = ? ORDER BY versionNumber DESC LIMIT 1')
+                .get(ownerGaii, filename);
+        }
+        return row ? this.deserializeApp(row) : null;
+    }
+    async getAppByOwnerName(ownerName, filename, version) {
+        let row;
+        if (version !== undefined) {
+            row = this.db.prepare('SELECT * FROM apps WHERE ownerName = ? AND filename = ? AND versionNumber = ?')
+                .get(ownerName, filename, version);
+        }
+        else {
+            row = this.db.prepare('SELECT * FROM apps WHERE ownerName = ? AND filename = ? ORDER BY versionNumber DESC LIMIT 1')
+                .get(ownerName, filename);
+        }
+        return row ? this.deserializeApp(row) : null;
+    }
+    async listApps(opts) {
+        // Get latest version of each app
+        let query = `SELECT a.* FROM apps a
+      INNER JOIN (SELECT ownerGaii, filename, MAX(versionNumber) as maxVer FROM apps GROUP BY ownerGaii, filename) latest
+      ON a.ownerGaii = latest.ownerGaii AND a.filename = latest.filename AND a.versionNumber = latest.maxVer`;
+        const conditions = [];
+        const params = [];
+        if (opts?.ownerGaii) {
+            conditions.push(`a.ownerGaii = ?`);
+            params.push(opts.ownerGaii);
+        }
+        if (opts?.category) {
+            conditions.push(`json_extract(a.manifest, '$.category') = ?`);
+            params.push(opts.category);
+        }
+        if (opts?.tag) {
+            conditions.push(`a.manifest LIKE ?`);
+            params.push(`%"${opts.tag}"%`);
+        }
+        if (opts?.q) {
+            conditions.push(`(a.filename LIKE ? OR json_extract(a.manifest, '$.name') LIKE ? OR json_extract(a.manifest, '$.description') LIKE ?)`);
+            const like = `%${opts.q}%`;
+            params.push(like, like, like);
+        }
+        if (opts?.freeOnly) {
+            conditions.push(`(json_extract(a.manifest, '$.priceMorsels') IS NULL OR json_extract(a.manifest, '$.priceMorsels') = 0)`);
+        }
+        if (conditions.length > 0) {
+            query += ' WHERE ' + conditions.join(' AND ');
+        }
+        // Count total before pagination
+        const countQuery = query.replace('SELECT a.*', 'SELECT COUNT(*) as cnt');
+        const countRow = this.db.prepare(countQuery).get(...params);
+        const total = countRow.cnt;
+        // Sort
+        if (opts?.sort === 'popular') {
+            query += ` ORDER BY (SELECT COALESCE(d.downloads, 0) FROM app_downloads d WHERE d.ownerGaii = a.ownerGaii AND d.filename = a.filename) DESC, a.createdAt DESC`;
+        }
+        else {
+            query += ' ORDER BY a.createdAt DESC';
+        }
+        // Pagination
+        const limit = opts?.limit ?? 50;
+        const offset = opts?.offset ?? 0;
+        query += ' LIMIT ? OFFSET ?';
+        params.push(limit, offset);
+        const rows = this.db.prepare(query).all(...params);
+        return { apps: rows.map(r => this.deserializeApp(r)), total };
+    }
+    async listAppVersions(ownerGaii, filename) {
+        const rows = this.db.prepare('SELECT * FROM apps WHERE ownerGaii = ? AND filename = ? ORDER BY versionNumber DESC')
+            .all(ownerGaii, filename);
+        return rows.map(r => this.deserializeApp(r));
+    }
+    async getLatestVersionNumber(ownerGaii, filename) {
+        const row = this.db.prepare('SELECT MAX(versionNumber) as maxVer FROM apps WHERE ownerGaii = ? AND filename = ?')
+            .get(ownerGaii, filename);
+        return row?.maxVer ?? 0;
+    }
+    async deleteApp(ownerGaii, filename, version) {
+        if (version !== undefined) {
+            const result = this.db.prepare('DELETE FROM apps WHERE ownerGaii = ? AND filename = ? AND versionNumber = ?')
+                .run(ownerGaii, filename, version);
+            return result.changes > 0;
+        }
+        // Delete all versions
+        const result = this.db.prepare('DELETE FROM apps WHERE ownerGaii = ? AND filename = ?')
+            .run(ownerGaii, filename);
+        // Also delete download counter
+        this.db.prepare('DELETE FROM app_downloads WHERE ownerGaii = ? AND filename = ?')
+            .run(ownerGaii, filename);
+        return result.changes > 0;
+    }
+    async updateAppAccessCode(ownerGaii, filename, accessCode) {
+        // Update access code on all versions
+        const result = this.db.prepare('UPDATE apps SET accessCode = ? WHERE ownerGaii = ? AND filename = ?')
+            .run(accessCode ?? null, ownerGaii, filename);
+        return result.changes > 0;
+    }
+    async getAppDownloads(ownerGaii, filename) {
+        const row = this.db.prepare('SELECT downloads FROM app_downloads WHERE ownerGaii = ? AND filename = ?')
+            .get(ownerGaii, filename);
+        return row?.downloads ?? 0;
+    }
+    async incrementAppDownloads(ownerGaii, filename) {
+        this.db.prepare(`INSERT INTO app_downloads (ownerGaii, filename, downloads) VALUES (?, ?, 1)
+       ON CONFLICT(ownerGaii, filename) DO UPDATE SET downloads = downloads + 1`).run(ownerGaii, filename);
+    }
+    deserializeApp(row) {
+        const record = {
+            ownerGaii: row.ownerGaii,
+            ownerName: row.ownerName,
+            filename: row.filename,
+            versionNumber: row.versionNumber,
+            manifest: JSON.parse(row.manifest || '{}'),
+            mimeType: row.mimeType,
+            size: row.size,
+            data: row.data,
+            createdAt: row.createdAt,
+        };
+        if (row.accessCode)
+            record.accessCode = row.accessCode;
+        return record;
+    }
+    // ── App Marketplace (purchase receipts) ──
+    async createAppPurchase(record) {
+        this.db.prepare(`INSERT INTO app_purchases (transactionId, buyerGaii, buyerOwner, sellerGaii, sellerOwner, appFilename, appName, appVersionNumber, licenseType, priceMorsels, transactionFeeMorsels, purchasedAt, appContent, appManifest, appScreenshot, signature, nodeId, nodePublicKey) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.transactionId, record.buyerGaii, record.buyerOwner, record.sellerGaii, record.sellerOwner, record.appFilename, record.appName, record.appVersionNumber, record.licenseType, record.priceMorsels, record.transactionFeeMorsels, record.purchasedAt, record.appContent, JSON.stringify(record.appManifest), record.appScreenshot ?? null, record.signature, record.nodeId, record.nodePublicKey);
+        return record;
+    }
+    async getAppPurchase(transactionId) {
+        const row = this.db.prepare('SELECT * FROM app_purchases WHERE transactionId = ?').get(transactionId);
+        return row ? this.deserializeAppPurchase(row) : null;
+    }
+    async listAppPurchasesByBuyer(buyerGaii) {
+        const rows = this.db.prepare('SELECT * FROM app_purchases WHERE buyerGaii = ? ORDER BY purchasedAt DESC').all(buyerGaii);
+        return rows.map(r => this.deserializeAppPurchase(r));
+    }
+    async listAppPurchasesBySeller(sellerGaii) {
+        const rows = this.db.prepare('SELECT * FROM app_purchases WHERE sellerGaii = ? ORDER BY purchasedAt DESC').all(sellerGaii);
+        return rows.map(r => this.deserializeAppPurchase(r));
+    }
+    async hasValidLicense(buyerGaii, sellerGaii, filename, licenseType) {
+        // Lifetime license: any purchase of this app grants access to all versions
+        const lifetime = this.db.prepare('SELECT 1 FROM app_purchases WHERE buyerGaii = ? AND sellerGaii = ? AND appFilename = ? AND licenseType = ? LIMIT 1').get(buyerGaii, sellerGaii, filename, 'lifetime');
+        if (lifetime)
+            return true;
+        // Single license: buyer has at least one purchase of this app (version-specific check done at download)
+        if (!licenseType || licenseType === 'single') {
+            const single = this.db.prepare('SELECT 1 FROM app_purchases WHERE buyerGaii = ? AND sellerGaii = ? AND appFilename = ? LIMIT 1').get(buyerGaii, sellerGaii, filename);
+            return !!single;
+        }
+        return false;
+    }
+    deserializeAppPurchase(row) {
+        const record = {
+            transactionId: row.transactionId,
+            buyerGaii: row.buyerGaii,
+            buyerOwner: row.buyerOwner,
+            sellerGaii: row.sellerGaii,
+            sellerOwner: row.sellerOwner,
+            appFilename: row.appFilename,
+            appName: row.appName,
+            appVersionNumber: row.appVersionNumber,
+            licenseType: row.licenseType,
+            priceMorsels: row.priceMorsels,
+            transactionFeeMorsels: row.transactionFeeMorsels,
+            purchasedAt: row.purchasedAt,
+            appContent: row.appContent,
+            appManifest: JSON.parse(row.appManifest || '{}'),
+            signature: row.signature,
+            nodeId: row.nodeId,
+            nodePublicKey: row.nodePublicKey,
+        };
+        if (row.appScreenshot)
+            record.appScreenshot = row.appScreenshot;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Config Persistence ──
+    // ══════════════════════════════════════════════════════════
+    supportsConfigPersistence() {
+        // In-memory SQLite (:memory:) does not persist across restarts
+        return this.db.name !== ':memory:';
+    }
+    async getConfigValue(key) {
+        const row = this.db.prepare('SELECT value FROM system_settings WHERE key = ?').get(`config:${key}`);
+        return row?.value ?? null;
+    }
+    async setConfigValue(key, value) {
+        this.db.prepare(`
+      INSERT INTO system_settings (key, value, updatedAt) VALUES (?, ?, datetime('now'))
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updatedAt = datetime('now')
+    `).run(`config:${key}`, value);
+    }
+    async deleteConfigValue(key) {
+        this.db.prepare('DELETE FROM system_settings WHERE key = ?').run(`config:${key}`);
+    }
+    async getAllConfigValues() {
+        const rows = this.db.prepare("SELECT key, value FROM system_settings WHERE key LIKE 'config:%'").all();
+        const result = {};
+        for (const r of rows)
+            result[r.key.replace('config:', '')] = r.value;
+        return result;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Knowledge: Memory Links ──
+    // ══════════════════════════════════════════════════════════
+    async createLink(record) {
+        this.db.prepare(`
+      INSERT INTO knowledge_links (source, target, relation, description, linked_at, linked_by)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source, target) DO UPDATE SET
+        relation = excluded.relation, description = excluded.description,
+        linked_at = excluded.linked_at, linked_by = excluded.linked_by
+    `).run(record.source, record.target, record.relation, record.description, record.linked_at, record.linked_by);
+        return record;
+    }
+    async getLink(source, target) {
+        const row = this.db.prepare('SELECT * FROM knowledge_links WHERE source = ? AND target = ?').get(source, target);
+        return row ?? null;
+    }
+    async listLinks(key, opts) {
+        const dir = opts?.direction ?? 'both';
+        let sql;
+        const params = [];
+        if (dir === 'outgoing') {
+            sql = 'SELECT * FROM knowledge_links WHERE source = ?';
+            params.push(key);
+        }
+        else if (dir === 'incoming') {
+            sql = 'SELECT * FROM knowledge_links WHERE target = ?';
+            params.push(key);
+        }
+        else {
+            sql = 'SELECT * FROM knowledge_links WHERE source = ? OR target = ?';
+            params.push(key, key);
+        }
+        if (opts?.relation) {
+            sql += ' AND relation = ?';
+            params.push(opts.relation);
+        }
+        return this.db.prepare(sql).all(...params);
+    }
+    async deleteLink(source, target) {
+        const result = this.db.prepare('DELETE FROM knowledge_links WHERE source = ? AND target = ?').run(source, target);
+        return result.changes > 0;
+    }
+    async findBrokenLinks(ownerGaii) {
+        const links = this.db.prepare('SELECT * FROM knowledge_links WHERE linked_by = ?').all(ownerGaii);
+        const broken = [];
+        for (const link of links) {
+            const sourceExists = await this.getMemory(ownerGaii, link.source);
+            const targetExists = await this.getMemory(ownerGaii, link.target);
+            if (!sourceExists || !targetExists)
+                broken.push(link);
+        }
+        return broken;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Knowledge: Operator Reviews ──
+    // ══════════════════════════════════════════════════════════
+    async createReview(record) {
+        this.db.prepare(`
+      INSERT INTO knowledge_reviews (id, packageId, operatorGaii, reason, customText, action, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(record.id, record.packageId, record.operatorGaii, record.reason, record.customText ?? null, record.action, record.timestamp);
+        return record;
+    }
+    async listReviews(packageId) {
+        return this.db.prepare('SELECT * FROM knowledge_reviews WHERE packageId = ? ORDER BY timestamp ASC').all(packageId);
+    }
+    async listAllReviews(opts) {
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const offset = (page - 1) * perPage;
+        return this.db.prepare('SELECT * FROM knowledge_reviews ORDER BY timestamp DESC LIMIT ? OFFSET ?').all(perPage, offset);
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Scheduled Jobs ──
+    // ══════════════════════════════════════════════════════════
+    async createScheduledJob(record) {
+        try {
+            this.db.prepare(`INSERT INTO scheduled_jobs (id, name, type, extensionName, instanceId, actionId,
+         coreHandler, cron, enabled, input, lastRunAt, lastRunResult, lastRunError,
+         lastRunDurationMs, nextRunAt, createdBy, createdAt, updatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.name, record.type, record.extensionName ?? null, record.instanceId ?? null, record.actionId ?? null, record.coreHandler ?? null, record.cron, record.enabled ? 1 : 0, record.input ? JSON.stringify(record.input) : null, record.lastRunAt ?? null, record.lastRunResult ?? null, record.lastRunError ?? null, record.lastRunDurationMs ?? null, record.nextRunAt ?? null, record.createdBy, record.createdAt, record.updatedAt);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed')) {
+                throw new Error(`Scheduled job "${record.id}" already exists`, { cause: err });
+            }
+            throw err;
+        }
+    }
+    async getScheduledJob(id) {
+        const row = this.db.prepare('SELECT * FROM scheduled_jobs WHERE id = ?').get(id);
+        return row ? this.deserializeScheduledJob(row) : null;
+    }
+    async listScheduledJobs(filter) {
+        let sql = 'SELECT * FROM scheduled_jobs';
+        const conditions = [];
+        const params = [];
+        if (filter?.type) {
+            conditions.push('type = ?');
+            params.push(filter.type);
+        }
+        if (filter?.extensionName) {
+            conditions.push('extensionName = ?');
+            params.push(filter.extensionName);
+        }
+        if (filter?.enabled !== undefined) {
+            conditions.push('enabled = ?');
+            params.push(filter.enabled ? 1 : 0);
+        }
+        if (conditions.length > 0)
+            sql += ' WHERE ' + conditions.join(' AND ');
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeScheduledJob(r));
+    }
+    async updateScheduledJob(id, updates) {
+        const existing = await this.getScheduledJob(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE scheduled_jobs SET name = ?, type = ?, extensionName = ?, instanceId = ?,
+       actionId = ?, coreHandler = ?, cron = ?, enabled = ?, input = ?,
+       lastRunAt = ?, lastRunResult = ?, lastRunError = ?, lastRunDurationMs = ?,
+       nextRunAt = ?, createdBy = ?, createdAt = ?, updatedAt = ? WHERE id = ?`).run(updated.name, updated.type, updated.extensionName ?? null, updated.instanceId ?? null, updated.actionId ?? null, updated.coreHandler ?? null, updated.cron, updated.enabled ? 1 : 0, updated.input ? JSON.stringify(updated.input) : null, updated.lastRunAt ?? null, updated.lastRunResult ?? null, updated.lastRunError ?? null, updated.lastRunDurationMs ?? null, updated.nextRunAt ?? null, updated.createdBy, updated.createdAt, updated.updatedAt, id);
+        return updated;
+    }
+    async deleteScheduledJob(id) {
+        const result = this.db.prepare('DELETE FROM scheduled_jobs WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deserializeScheduledJob(row) {
+        const record = {
+            id: row.id,
+            name: row.name,
+            type: row.type,
+            cron: row.cron,
+            enabled: row.enabled === 1,
+            createdBy: row.createdBy,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        if (row.extensionName)
+            record.extensionName = row.extensionName;
+        if (row.instanceId)
+            record.instanceId = row.instanceId;
+        if (row.actionId)
+            record.actionId = row.actionId;
+        if (row.coreHandler)
+            record.coreHandler = row.coreHandler;
+        if (row.input)
+            record.input = JSON.parse(row.input);
+        if (row.lastRunAt)
+            record.lastRunAt = row.lastRunAt;
+        if (row.lastRunResult)
+            record.lastRunResult = row.lastRunResult;
+        if (row.lastRunError)
+            record.lastRunError = row.lastRunError;
+        if (row.lastRunDurationMs !== null && row.lastRunDurationMs !== undefined)
+            record.lastRunDurationMs = row.lastRunDurationMs;
+        if (row.nextRunAt)
+            record.nextRunAt = row.nextRunAt;
+        return record;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Execution Log ──
+    // ══════════════════════════════════════════════════════════
+    async createExecutionLog(entry) {
+        this.db.prepare(`INSERT INTO execution_log (id, jobId, jobName, type, extensionName, actionId,
+       "trigger", result, errorMessage, durationMs, memoryReads, memoryWrites, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(entry.id, entry.jobId, entry.jobName, entry.type, entry.extensionName ?? null, entry.actionId ?? null, entry.trigger, entry.result, entry.errorMessage ?? null, entry.durationMs, JSON.stringify(entry.memoryReads), JSON.stringify(entry.memoryWrites), entry.createdAt);
+        return entry;
+    }
+    async listExecutionLogs(filter) {
+        let sql = 'SELECT * FROM execution_log';
+        const conditions = [];
+        const params = [];
+        if (filter?.jobId) {
+            conditions.push('jobId = ?');
+            params.push(filter.jobId);
+        }
+        if (filter?.extensionName) {
+            conditions.push('extensionName = ?');
+            params.push(filter.extensionName);
+        }
+        if (filter?.trigger) {
+            conditions.push('"trigger" = ?');
+            params.push(filter.trigger);
+        }
+        if (filter?.result) {
+            conditions.push('result = ?');
+            params.push(filter.result);
+        }
+        if (conditions.length > 0)
+            sql += ' WHERE ' + conditions.join(' AND ');
+        sql += ' ORDER BY createdAt DESC';
+        if (filter?.limit) {
+            sql += ' LIMIT ?';
+            params.push(filter.limit);
+        }
+        if (filter?.offset) {
+            sql += ' OFFSET ?';
+            params.push(filter.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.deserializeExecutionLog(r));
+    }
+    async countExecutionLogs(filter) {
+        let sql = 'SELECT COUNT(*) as cnt FROM execution_log';
+        const conditions = [];
+        const params = [];
+        if (filter?.jobId) {
+            conditions.push('jobId = ?');
+            params.push(filter.jobId);
+        }
+        if (filter?.extensionName) {
+            conditions.push('extensionName = ?');
+            params.push(filter.extensionName);
+        }
+        if (filter?.trigger) {
+            conditions.push('"trigger" = ?');
+            params.push(filter.trigger);
+        }
+        if (filter?.result) {
+            conditions.push('result = ?');
+            params.push(filter.result);
+        }
+        if (conditions.length > 0)
+            sql += ' WHERE ' + conditions.join(' AND ');
+        const row = this.db.prepare(sql).get(...params);
+        return row.cnt ?? 0;
+    }
+    async pruneExecutionLogs(beforeDate) {
+        const result = this.db.prepare('DELETE FROM execution_log WHERE createdAt < ?').run(beforeDate);
+        return result.changes;
+    }
+    deserializeExecutionLog(row) {
+        return {
+            id: row.id,
+            jobId: row.jobId,
+            jobName: row.jobName,
+            type: row.type,
+            extensionName: row.extensionName || undefined,
+            actionId: row.actionId || undefined,
+            trigger: row.trigger,
+            result: row.result,
+            errorMessage: row.errorMessage || undefined,
+            durationMs: row.durationMs,
+            memoryReads: JSON.parse(row.memoryReads || '[]'),
+            memoryWrites: JSON.parse(row.memoryWrites || '[]'),
+            createdAt: row.createdAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Extension Instances ──
+    // ══════════════════════════════════════════════════════════
+    async createExtensionInstance(record) {
+        try {
+            this.db.prepare(`INSERT INTO extension_instances (id, extensionName, config, status, createdBy, createdAt, updatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.extensionName, JSON.stringify(record.config), record.status, record.createdBy, record.createdAt, record.updatedAt);
+            return record;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message?.includes('UNIQUE constraint failed')) {
+                throw new Error(`Extension instance "${record.id}" already exists for "${record.extensionName}"`, { cause: err });
+            }
+            throw err;
+        }
+    }
+    async getExtensionInstance(extensionName, instanceId) {
+        const row = this.db.prepare('SELECT * FROM extension_instances WHERE extensionName = ? AND id = ?').get(extensionName, instanceId);
+        return row ? this.deserializeExtensionInstance(row) : null;
+    }
+    async listExtensionInstances(extensionName) {
+        const rows = this.db.prepare('SELECT * FROM extension_instances WHERE extensionName = ?').all(extensionName);
+        return rows.map(r => this.deserializeExtensionInstance(r));
+    }
+    async updateExtensionInstance(extensionName, instanceId, updates) {
+        const existing = await this.getExtensionInstance(extensionName, instanceId);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...updates };
+        this.db.prepare(`UPDATE extension_instances SET config = ?, status = ?, createdBy = ?, createdAt = ?, updatedAt = ?
+       WHERE extensionName = ? AND id = ?`).run(JSON.stringify(updated.config), updated.status, updated.createdBy, updated.createdAt, updated.updatedAt, extensionName, instanceId);
+        return updated;
+    }
+    async deleteExtensionInstance(extensionName, instanceId) {
+        const result = this.db.prepare('DELETE FROM extension_instances WHERE extensionName = ? AND id = ?').run(extensionName, instanceId);
+        return result.changes > 0;
+    }
+    deserializeExtensionInstance(row) {
+        return {
+            id: row.id,
+            extensionName: row.extensionName,
+            config: JSON.parse(row.config),
+            status: row.status,
+            createdBy: row.createdBy,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Replication Queue (B.1) ──
+    // ══════════════════════════════════════════════════════════
+    async enqueueReplication(entry) {
+        const id = randomUUID();
+        this.db.prepare(`INSERT INTO replication_queue (id, type, targetPeers, payload, createdAt, attempts, lastAttemptAt, status)
+       VALUES (?, ?, ?, ?, ?, 0, NULL, 'pending')`).run(id, entry.type, JSON.stringify(entry.targetPeers), JSON.stringify(entry.payload), entry.createdAt);
+        return id;
+    }
+    async dequeueReplication(peerId, limit) {
+        // Fetch all pending entries ordered by creation time
+        const rows = this.db.prepare(`SELECT * FROM replication_queue WHERE status = 'pending' ORDER BY createdAt ASC`).all();
+        const results = [];
+        for (const row of rows) {
+            const peers = JSON.parse(row.targetPeers);
+            if (peers.includes(peerId)) {
+                results.push(this.deserializeReplicationEntry(row));
+                if (results.length >= limit)
+                    break;
+            }
+        }
+        return results;
+    }
+    async markReplicationSent(ids) {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(',');
+        this.db.prepare(`UPDATE replication_queue SET status = 'sent' WHERE id IN (${placeholders})`).run(...ids);
+    }
+    async markReplicationFailed(ids) {
+        if (ids.length === 0)
+            return;
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`UPDATE replication_queue SET status = 'failed', attempts = attempts + 1, lastAttemptAt = ? WHERE id = ?`);
+        for (const id of ids) {
+            stmt.run(now, id);
+        }
+    }
+    async pruneReplicationQueue(maxAge) {
+        const maxAgeIso = maxAge.toISOString();
+        const result = this.db.prepare(`DELETE FROM replication_queue WHERE createdAt < ? OR status = 'sent'`).run(maxAgeIso);
+        return result.changes;
+    }
+    async replicationQueueSize() {
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM replication_queue').get();
+        return row.cnt;
+    }
+    deserializeReplicationEntry(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            targetPeers: JSON.parse(row.targetPeers),
+            payload: row.payload ? JSON.parse(row.payload) : null,
+            createdAt: row.createdAt,
+            attempts: row.attempts,
+            lastAttemptAt: row.lastAttemptAt || null,
+            status: row.status,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Device Authorization (RFC 8628) ──
+    // ══════════════════════════════════════════════════════════
+    async createDeviceAuth(req) {
+        this.db.prepare(`INSERT INTO device_auth (deviceCode, userCode, ownerName, agentName, displayName, description, status, scopes, createdAt, expiresAt, lastPolledAt, pollInterval, approvedBy, agentCredentials)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(req.deviceCode, req.userCode, req.ownerName, req.agentName, req.displayName ?? null, req.description ?? null, req.status, req.scopes ? JSON.stringify(req.scopes) : null, req.createdAt, req.expiresAt, req.lastPolledAt ?? null, req.pollInterval, req.approvedBy ?? null, req.agentCredentials ? JSON.stringify(req.agentCredentials) : null);
+    }
+    async getDeviceAuthByDeviceCode(deviceCode) {
+        const row = this.db.prepare('SELECT * FROM device_auth WHERE deviceCode = ?').get(deviceCode);
+        return row ? this.deserializeDeviceAuth(row) : null;
+    }
+    async getDeviceAuthByUserCode(userCode) {
+        const row = this.db.prepare('SELECT * FROM device_auth WHERE userCode = ?').get(userCode);
+        return row ? this.deserializeDeviceAuth(row) : null;
+    }
+    async updateDeviceAuth(deviceCode, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.status !== undefined) {
+            fields.push('status = ?');
+            values.push(updates.status);
+        }
+        if (updates.scopes !== undefined) {
+            fields.push('scopes = ?');
+            values.push(JSON.stringify(updates.scopes));
+        }
+        if (updates.lastPolledAt !== undefined) {
+            fields.push('lastPolledAt = ?');
+            values.push(updates.lastPolledAt);
+        }
+        if (updates.pollInterval !== undefined) {
+            fields.push('pollInterval = ?');
+            values.push(updates.pollInterval);
+        }
+        if (updates.approvedBy !== undefined) {
+            fields.push('approvedBy = ?');
+            values.push(updates.approvedBy);
+        }
+        if ('agentCredentials' in updates) {
+            fields.push('agentCredentials = ?');
+            values.push(updates.agentCredentials ? JSON.stringify(updates.agentCredentials) : null);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(deviceCode);
+        this.db.prepare(`UPDATE device_auth SET ${fields.join(', ')} WHERE deviceCode = ?`).run(...values);
+    }
+    async countPendingDeviceAuthByOwner(ownerName) {
+        const row = this.db.prepare(`SELECT COUNT(*) as cnt FROM device_auth WHERE ownerName = ? AND status = 'pending' AND expiresAt > ?`).get(ownerName, new Date().toISOString());
+        return row.cnt;
+    }
+    async listPendingDeviceAuthByOwner(ownerName) {
+        const rows = this.db.prepare(`SELECT * FROM device_auth WHERE ownerName = ? AND status = 'pending' AND expiresAt > ? ORDER BY createdAt DESC`).all(ownerName, new Date().toISOString());
+        return rows.map(row => this.deserializeDeviceAuth(row));
+    }
+    async cleanupExpiredDeviceAuth() {
+        const result = this.db.prepare(`DELETE FROM device_auth WHERE status = 'pending' AND expiresAt <= ?`).run(new Date().toISOString());
+        return result.changes;
+    }
+    deserializeDeviceAuth(row) {
+        return {
+            deviceCode: row.deviceCode,
+            userCode: row.userCode,
+            ownerName: row.ownerName,
+            agentName: row.agentName,
+            displayName: row.displayName,
+            description: row.description,
+            status: row.status,
+            scopes: row.scopes ? JSON.parse(row.scopes) : undefined,
+            createdAt: row.createdAt,
+            expiresAt: row.expiresAt,
+            lastPolledAt: row.lastPolledAt,
+            pollInterval: row.pollInterval,
+            approvedBy: row.approvedBy,
+            agentCredentials: row.agentCredentials ? JSON.parse(row.agentCredentials) : undefined,
+        };
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── OAuth 2.1 Persistent State ──
+    // ══════════════════════════════════════════════════════════
+    // ── Clients ──
+    async createOAuthClient(client) {
+        this.db.prepare(`INSERT INTO oauth_clients (clientId, clientSecret, clientName, redirectUris, createdAt)
+       VALUES (?, ?, ?, ?, ?)`).run(client.clientId, client.clientSecret, client.clientName, JSON.stringify(client.redirectUris), client.createdAt);
+    }
+    async getOAuthClient(clientId) {
+        const row = this.db.prepare('SELECT * FROM oauth_clients WHERE clientId = ?').get(clientId);
+        if (!row)
+            return null;
+        return {
+            clientId: row.clientId,
+            clientSecret: row.clientSecret,
+            clientName: row.clientName,
+            redirectUris: JSON.parse(row.redirectUris),
+            createdAt: row.createdAt,
+        };
+    }
+    async deleteOAuthClient(clientId) {
+        const txn = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM oauth_refresh_tokens WHERE clientId = ?').run(clientId);
+            this.db.prepare('DELETE FROM oauth_approvals WHERE clientId = ?').run(clientId);
+            const result = this.db.prepare('DELETE FROM oauth_clients WHERE clientId = ?').run(clientId);
+            return result.changes > 0;
+        });
+        return txn();
+    }
+    async listOAuthClients() {
+        const rows = this.db.prepare('SELECT * FROM oauth_clients ORDER BY createdAt DESC').all();
+        return rows.map(row => ({
+            clientId: row.clientId,
+            clientSecret: row.clientSecret,
+            clientName: row.clientName,
+            redirectUris: JSON.parse(row.redirectUris),
+            createdAt: row.createdAt,
+        }));
+    }
+    // ── Refresh Tokens ──
+    async createOAuthRefreshToken(token) {
+        this.db.prepare(`INSERT INTO oauth_refresh_tokens (tokenHash, clientId, gaii, owner, roles, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(token.tokenHash, token.clientId, token.gaii, token.owner, JSON.stringify(token.roles), token.createdAt);
+    }
+    async getOAuthRefreshToken(tokenHash) {
+        const row = this.db.prepare('SELECT * FROM oauth_refresh_tokens WHERE tokenHash = ?').get(tokenHash);
+        if (!row)
+            return null;
+        return {
+            tokenHash: row.tokenHash,
+            clientId: row.clientId,
+            gaii: row.gaii,
+            owner: row.owner,
+            roles: JSON.parse(row.roles),
+            createdAt: row.createdAt,
+        };
+    }
+    async deleteOAuthRefreshToken(tokenHash) {
+        const result = this.db.prepare('DELETE FROM oauth_refresh_tokens WHERE tokenHash = ?').run(tokenHash);
+        return result.changes > 0;
+    }
+    async deleteOAuthRefreshTokensByClient(clientId) {
+        const result = this.db.prepare('DELETE FROM oauth_refresh_tokens WHERE clientId = ?').run(clientId);
+        return result.changes;
+    }
+    async deleteOAuthRefreshTokensByGaii(gaii) {
+        const result = this.db.prepare('DELETE FROM oauth_refresh_tokens WHERE gaii = ?').run(gaii);
+        return result.changes;
+    }
+    // ── Approvals ──
+    async createOAuthApproval(approval) {
+        this.db.prepare(`INSERT OR REPLACE INTO oauth_approvals (clientId, gaii, owner, scope, approvedAt)
+       VALUES (?, ?, ?, ?, ?)`).run(approval.clientId, approval.gaii, approval.owner, approval.scope, approval.approvedAt);
+    }
+    async getOAuthApproval(clientId, gaii) {
+        const row = this.db.prepare('SELECT * FROM oauth_approvals WHERE clientId = ? AND gaii = ?').get(clientId, gaii);
+        if (!row)
+            return null;
+        return {
+            clientId: row.clientId,
+            gaii: row.gaii,
+            owner: row.owner,
+            scope: row.scope,
+            approvedAt: row.approvedAt,
+        };
+    }
+    async deleteOAuthApproval(clientId, gaii) {
+        const result = this.db.prepare('DELETE FROM oauth_approvals WHERE clientId = ? AND gaii = ?').run(clientId, gaii);
+        return result.changes > 0;
+    }
+    async deleteOAuthApprovalsByClient(clientId) {
+        const result = this.db.prepare('DELETE FROM oauth_approvals WHERE clientId = ?').run(clientId);
+        return result.changes;
+    }
+    async deleteOAuthApprovalsByGaii(gaii) {
+        const result = this.db.prepare('DELETE FROM oauth_approvals WHERE gaii = ?').run(gaii);
+        return result.changes;
+    }
+    async listOAuthApprovalsByOwner(owner) {
+        const rows = this.db.prepare('SELECT * FROM oauth_approvals WHERE owner = ? ORDER BY approvedAt DESC').all(owner);
+        return rows.map(row => ({
+            clientId: row.clientId,
+            gaii: row.gaii,
+            owner: row.owner,
+            scope: row.scope,
+            approvedAt: row.approvedAt,
+        }));
+    }
+    // ── System Prompts ────────────────────────────────────────────────
+    deserializeSystemPrompt(row) {
+        return {
+            id: row.id,
+            group: row.grp,
+            name: row.name,
+            description: row.description,
+            content: row.content,
+            locales: row.locales ? JSON.parse(row.locales) : undefined,
+            active: row.active === 1,
+            variables: JSON.parse(row.variables),
+            usedIn: JSON.parse(row.usedIn),
+            version: row.version,
+            updatedAt: row.updatedAt,
+            updatedBy: row.updatedBy,
+        };
+    }
+    deserializeSystemPromptVersion(row) {
+        return {
+            promptId: row.promptId,
+            version: row.version,
+            content: row.content,
+            locales: row.locales ? JSON.parse(row.locales) : undefined,
+            changedBy: row.changedBy,
+            changedAt: row.changedAt,
+            changeNote: row.changeNote,
+        };
+    }
+    async listSystemPrompts(opts) {
+        const sql = opts?.group
+            ? 'SELECT * FROM system_prompts WHERE grp = ? ORDER BY grp, name'
+            : 'SELECT * FROM system_prompts ORDER BY grp, name';
+        const rows = (opts?.group
+            ? this.db.prepare(sql).all(opts.group)
+            : this.db.prepare(sql).all());
+        return rows.map(r => this.deserializeSystemPrompt(r));
+    }
+    async getSystemPrompt(id) {
+        const row = this.db.prepare('SELECT * FROM system_prompts WHERE id = ?').get(id);
+        return row ? this.deserializeSystemPrompt(row) : null;
+    }
+    async upsertSystemPrompt(record) {
+        this.db.prepare(`INSERT INTO system_prompts (id, grp, name, description, content, locales, active, variables, usedIn, version, updatedAt, updatedBy)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         grp = excluded.grp, name = excluded.name, description = excluded.description,
+         content = excluded.content, locales = excluded.locales, active = excluded.active,
+         variables = excluded.variables, usedIn = excluded.usedIn, version = excluded.version,
+         updatedAt = excluded.updatedAt, updatedBy = excluded.updatedBy`).run(record.id, record.group, record.name, record.description, record.content, record.locales ? JSON.stringify(record.locales) : null, record.active ? 1 : 0, JSON.stringify(record.variables), JSON.stringify(record.usedIn), record.version, record.updatedAt, record.updatedBy);
+        return record;
+    }
+    async getSystemPromptVersions(promptId) {
+        const rows = this.db.prepare('SELECT * FROM system_prompt_versions WHERE promptId = ? ORDER BY version DESC').all(promptId);
+        return rows.map(r => this.deserializeSystemPromptVersion(r));
+    }
+    async getSystemPromptVersion(promptId, version) {
+        const row = this.db.prepare('SELECT * FROM system_prompt_versions WHERE promptId = ? AND version = ?').get(promptId, version);
+        return row ? this.deserializeSystemPromptVersion(row) : null;
+    }
+    async createSystemPromptVersion(record) {
+        this.db.prepare(`INSERT INTO system_prompt_versions (promptId, version, content, locales, changedBy, changedAt, changeNote)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(record.promptId, record.version, record.content, record.locales ? JSON.stringify(record.locales) : null, record.changedBy, record.changedAt, record.changeNote ?? null);
+        return record;
+    }
+    async pruneSystemPromptVersions(promptId, keepCount) {
+        const result = this.db.prepare(`DELETE FROM system_prompt_versions WHERE promptId = ? AND version NOT IN (
+         SELECT version FROM system_prompt_versions WHERE promptId = ? ORDER BY version DESC LIMIT ?
+       )`).run(promptId, promptId, keepCount);
+        return result.changes;
+    }
+    async deleteAllSystemPrompts() {
+        this.db.prepare('DELETE FROM system_prompt_versions').run();
+        this.db.prepare('DELETE FROM system_prompts').run();
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Packages ──
+    // ══════════════════════════════════════════════════════════
+    deserializePackage(row) {
+        return {
+            id: row.id,
+            packageGroupId: row.packageGroupId,
+            name: row.name,
+            author: row.author,
+            authorGhii: row.authorGhii,
+            version: row.version,
+            changelog: row.changelog,
+            description: row.description,
+            category: row.category,
+            tags: JSON.parse(row.tags),
+            visibility: row.visibility,
+            status: row.status,
+            components: JSON.parse(row.components),
+            manifest: row.manifest,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    async createPackage(record) {
+        try {
+            this.db.prepare(`INSERT INTO packages (id, packageGroupId, name, author, authorGhii, version, changelog, description, category, tags, visibility, status, components, manifest, createdAt, updatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.packageGroupId, record.name, record.author, record.authorGhii, record.version, record.changelog, record.description, record.category, JSON.stringify(record.tags), record.visibility, record.status, JSON.stringify(record.components), record.manifest, record.createdAt, record.updatedAt);
+        }
+        catch (e) {
+            if (e.message?.includes('UNIQUE constraint failed')) {
+                throw new Error('PACKAGE_EXISTS', { cause: e });
+            }
+            throw e;
+        }
+        return record;
+    }
+    async getPackage(id) {
+        const row = this.db.prepare('SELECT * FROM packages WHERE id = ?').get(id);
+        return row ? this.deserializePackage(row) : null;
+    }
+    async getPackageByGroupAndVersion(groupId, version) {
+        const row = this.db.prepare('SELECT * FROM packages WHERE packageGroupId = ? AND version = ?').get(groupId, version);
+        return row ? this.deserializePackage(row) : null;
+    }
+    async getLatestPublished(groupId) {
+        const row = this.db.prepare(`SELECT * FROM packages WHERE packageGroupId = ? AND status = 'published' ORDER BY version DESC LIMIT 1`).get(groupId);
+        return row ? this.deserializePackage(row) : null;
+    }
+    async listPackages(filter) {
+        const conditions = [];
+        const params = [];
+        if (filter.author) {
+            conditions.push('author = ?');
+            params.push(filter.author);
+        }
+        if (filter.category) {
+            conditions.push('category = ?');
+            params.push(filter.category);
+        }
+        if (filter.status) {
+            conditions.push('status = ?');
+            params.push(filter.status);
+        }
+        if (filter.visibility) {
+            conditions.push('visibility = ?');
+            params.push(filter.visibility);
+        }
+        if (filter.search) {
+            conditions.push('(name LIKE ? OR description LIKE ? OR tags LIKE ?)');
+            const s = `%${filter.search}%`;
+            params.push(s, s, s);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = filter.limit ?? 50;
+        const offset = filter.offset ?? 0;
+        const total = this.db.prepare(`SELECT COUNT(*) as c FROM packages ${where}`).get(...params).c;
+        const rows = this.db.prepare(`SELECT * FROM packages ${where} ORDER BY createdAt DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        return { packages: rows.map(r => this.deserializePackage(r)), total };
+    }
+    async listVersions(groupId, limit, offset) {
+        const lim = limit ?? 50;
+        const off = offset ?? 0;
+        const total = this.db.prepare('SELECT COUNT(*) as c FROM packages WHERE packageGroupId = ?').get(groupId).c;
+        const rows = this.db.prepare('SELECT * FROM packages WHERE packageGroupId = ? ORDER BY version DESC LIMIT ? OFFSET ?').all(groupId, lim, off);
+        return { versions: rows.map(r => this.deserializePackage(r)), total };
+    }
+    async updatePackage(id, updates) {
+        const existing = await this.getPackage(id);
+        if (!existing)
+            return null;
+        const merged = { ...existing, ...updates, id };
+        this.db.prepare(`UPDATE packages SET packageGroupId = ?, name = ?, author = ?, authorGhii = ?, version = ?,
+       changelog = ?, description = ?, category = ?, tags = ?, visibility = ?, status = ?,
+       components = ?, manifest = ?, updatedAt = ? WHERE id = ?`).run(merged.packageGroupId, merged.name, merged.author, merged.authorGhii, merged.version, merged.changelog, merged.description, merged.category, JSON.stringify(merged.tags), merged.visibility, merged.status, JSON.stringify(merged.components), merged.manifest, merged.updatedAt, id);
+        return merged;
+    }
+    async archivePackage(id) {
+        const result = this.db.prepare(`UPDATE packages SET status = 'archived', updatedAt = ? WHERE id = ?`).run(new Date().toISOString(), id);
+        return result.changes > 0;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Template Listings ──
+    // ══════════════════════════════════════════════════════════
+    deserializeTemplateListing(row) {
+        return {
+            id: row.id,
+            packageGroupId: row.packageGroupId,
+            packageName: row.packageName,
+            packageAuthor: row.packageAuthor,
+            publishedBy: row.publishedBy,
+            publishedByGhii: row.publishedByGhii,
+            title: row.title,
+            description: row.description,
+            screenshots: JSON.parse(row.screenshots),
+            category: row.category,
+            tags: JSON.parse(row.tags),
+            featured: !!row.featured,
+            installCount: row.installCount,
+            rating: row.rating,
+            reviewCount: row.reviewCount,
+            status: row.status,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+            ...(row.rejectionReason ? { rejectionReason: row.rejectionReason } : {}),
+            ...(row.reviewedBy ? { reviewedBy: row.reviewedBy } : {}),
+            ...(row.reviewedAt ? { reviewedAt: row.reviewedAt } : {}),
+            ...(row.reviewComment ? { reviewComment: row.reviewComment } : {}),
+            ...(row.proposedAt ? { proposedAt: row.proposedAt } : {}),
+            ...(row.proposedBy ? { proposedBy: row.proposedBy } : {}),
+        };
+    }
+    deserializeReview(row) {
+        return {
+            id: row.id,
+            listingId: row.listingId,
+            authorGhii: row.authorGhii,
+            authorName: row.authorName,
+            rating: row.rating,
+            comment: row.comment,
+            createdAt: row.createdAt,
+        };
+    }
+    deserializeDiscussion(row) {
+        return {
+            id: row.id,
+            listingId: row.listingId,
+            authorGhii: row.authorGhii,
+            authorName: row.authorName,
+            message: row.message,
+            parentId: row.parentId,
+            createdAt: row.createdAt,
+        };
+    }
+    async createTemplateListing(record) {
+        this.db.prepare(`INSERT INTO template_listings (id, packageGroupId, packageName, packageAuthor, publishedBy, publishedByGhii, title, description, screenshots, category, tags, featured, installCount, rating, reviewCount, status, createdAt, updatedAt, rejectionReason, reviewedBy, reviewedAt, reviewComment, proposedAt, proposedBy)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.packageGroupId, record.packageName, record.packageAuthor, record.publishedBy, record.publishedByGhii, record.title, record.description, JSON.stringify(record.screenshots), record.category, JSON.stringify(record.tags), record.featured ? 1 : 0, record.installCount, record.rating, record.reviewCount, record.status, record.createdAt, record.updatedAt, record.rejectionReason ?? null, record.reviewedBy ?? null, record.reviewedAt ?? null, record.reviewComment ?? null, record.proposedAt ?? null, record.proposedBy ?? null);
+        return record;
+    }
+    async getTemplateListing(id) {
+        const row = this.db.prepare('SELECT * FROM template_listings WHERE id = ?').get(id);
+        return row ? this.deserializeTemplateListing(row) : null;
+    }
+    async getListingByPackage(packageGroupId) {
+        const row = this.db.prepare('SELECT * FROM template_listings WHERE packageGroupId = ?').get(packageGroupId);
+        return row ? this.deserializeTemplateListing(row) : null;
+    }
+    async listTemplateListings(filter) {
+        const conditions = [];
+        const params = [];
+        if (filter.category) {
+            conditions.push('category = ?');
+            params.push(filter.category);
+        }
+        if (filter.tags && filter.tags.length > 0) {
+            const tagConditions = filter.tags.map(() => 'tags LIKE ?');
+            conditions.push(`(${tagConditions.join(' AND ')})`);
+            for (const tag of filter.tags)
+                params.push(`%${tag}%`);
+        }
+        if (filter.featured !== undefined) {
+            conditions.push('featured = ?');
+            params.push(filter.featured ? 1 : 0);
+        }
+        if (filter.status) {
+            conditions.push('status = ?');
+            params.push(filter.status);
+        }
+        if (filter.search) {
+            conditions.push('(title LIKE ? OR description LIKE ? OR tags LIKE ?)');
+            const s = `%${filter.search}%`;
+            params.push(s, s, s);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = filter.limit ?? 50;
+        const offset = filter.offset ?? 0;
+        let orderBy;
+        switch (filter.sort) {
+            case 'rating':
+                orderBy = 'rating DESC';
+                break;
+            case 'installs':
+                orderBy = 'installCount DESC';
+                break;
+            case 'newest':
+                orderBy = 'createdAt DESC';
+                break;
+            default: orderBy = 'createdAt DESC';
+        }
+        const total = this.db.prepare(`SELECT COUNT(*) as c FROM template_listings ${where}`).get(...params).c;
+        const rows = this.db.prepare(`SELECT * FROM template_listings ${where} ORDER BY ${orderBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        return { listings: rows.map(r => this.deserializeTemplateListing(r)), total };
+    }
+    async updateTemplateListing(id, updates) {
+        const existing = await this.getTemplateListing(id);
+        if (!existing)
+            return null;
+        const merged = { ...existing, ...updates, id };
+        this.db.prepare(`UPDATE template_listings SET packageGroupId = ?, packageName = ?, packageAuthor = ?,
+       publishedBy = ?, publishedByGhii = ?, title = ?, description = ?, screenshots = ?,
+       category = ?, tags = ?, featured = ?, installCount = ?, rating = ?, reviewCount = ?,
+       status = ?, updatedAt = ?, rejectionReason = ?, reviewedBy = ?, reviewedAt = ?,
+       reviewComment = ?, proposedAt = ?, proposedBy = ? WHERE id = ?`).run(merged.packageGroupId, merged.packageName, merged.packageAuthor, merged.publishedBy, merged.publishedByGhii, merged.title, merged.description, JSON.stringify(merged.screenshots), merged.category, JSON.stringify(merged.tags), merged.featured ? 1 : 0, merged.installCount, merged.rating, merged.reviewCount, merged.status, merged.updatedAt, merged.rejectionReason ?? null, merged.reviewedBy ?? null, merged.reviewedAt ?? null, merged.reviewComment ?? null, merged.proposedAt ?? null, merged.proposedBy ?? null, id);
+        return merged;
+    }
+    async deleteTemplateListing(id) {
+        this.db.prepare('DELETE FROM template_reviews WHERE listingId = ?').run(id);
+        this.db.prepare('DELETE FROM template_discussions WHERE listingId = ?').run(id);
+        const result = this.db.prepare('DELETE FROM template_listings WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async incrementInstallCount(listingId) {
+        this.db.prepare('UPDATE template_listings SET installCount = installCount + 1 WHERE id = ?').run(listingId);
+    }
+    async listPendingTemplates(limit = 20, offset = 0) {
+        const rows = this.db.prepare('SELECT * FROM template_listings WHERE status = ? ORDER BY createdAt ASC LIMIT ? OFFSET ?').all('pending_review', limit, offset);
+        return rows.map(r => this.deserializeTemplateListing(r));
+    }
+    async addReview(review) {
+        this.db.prepare(`INSERT OR REPLACE INTO template_reviews (id, listingId, authorGhii, authorName, rating, comment, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(review.id, review.listingId, review.authorGhii, review.authorName, review.rating, review.comment, review.createdAt);
+        await this.recalculateRating(review.listingId);
+        return review;
+    }
+    async getReviewsByListing(listingId, limit, offset) {
+        const lim = limit ?? 50;
+        const off = offset ?? 0;
+        const total = this.db.prepare('SELECT COUNT(*) as c FROM template_reviews WHERE listingId = ?').get(listingId).c;
+        const rows = this.db.prepare('SELECT * FROM template_reviews WHERE listingId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?').all(listingId, lim, off);
+        return { reviews: rows.map(r => this.deserializeReview(r)), total };
+    }
+    async getReviewByAuthor(listingId, authorGhii) {
+        const row = this.db.prepare('SELECT * FROM template_reviews WHERE listingId = ? AND authorGhii = ?').get(listingId, authorGhii);
+        return row ? this.deserializeReview(row) : null;
+    }
+    async updateReview(id, updates) {
+        const row = this.db.prepare('SELECT * FROM template_reviews WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        const existing = this.deserializeReview(row);
+        const merged = { ...existing, ...updates, id };
+        this.db.prepare('UPDATE template_reviews SET rating = ?, comment = ? WHERE id = ?').run(merged.rating, merged.comment, id);
+        await this.recalculateRating(merged.listingId);
+        return merged;
+    }
+    async deleteReview(id) {
+        const row = this.db.prepare('SELECT * FROM template_reviews WHERE id = ?').get(id);
+        if (!row)
+            return false;
+        const listingId = row.listingId;
+        const result = this.db.prepare('DELETE FROM template_reviews WHERE id = ?').run(id);
+        if (result.changes > 0) {
+            await this.recalculateRating(listingId);
+            return true;
+        }
+        return false;
+    }
+    async recalculateRating(listingId) {
+        const stats = this.db.prepare('SELECT AVG(rating) as avg, COUNT(*) as cnt FROM template_reviews WHERE listingId = ?').get(listingId);
+        const rating = stats.avg ?? 0;
+        const reviewCount = stats.cnt;
+        this.db.prepare('UPDATE template_listings SET rating = ?, reviewCount = ? WHERE id = ?').run(rating, reviewCount, listingId);
+        return { rating, reviewCount };
+    }
+    async addDiscussion(discussion) {
+        this.db.prepare(`INSERT INTO template_discussions (id, listingId, authorGhii, authorName, message, parentId, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(discussion.id, discussion.listingId, discussion.authorGhii, discussion.authorName, discussion.message, discussion.parentId ?? null, discussion.createdAt);
+        return discussion;
+    }
+    async getDiscussionsByListing(listingId, limit, offset) {
+        const lim = limit ?? 50;
+        const off = offset ?? 0;
+        const total = this.db.prepare('SELECT COUNT(*) as c FROM template_discussions WHERE listingId = ?').get(listingId).c;
+        const rows = this.db.prepare('SELECT * FROM template_discussions WHERE listingId = ? ORDER BY createdAt ASC LIMIT ? OFFSET ?').all(listingId, lim, off);
+        return { discussions: rows.map(r => this.deserializeDiscussion(r)), total };
+    }
+    async deleteDiscussion(id) {
+        const result = this.db.prepare('DELETE FROM template_discussions WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // ══════════════════════════════════════════════════════════
+    // ── Package Instances ──
+    // ══════════════════════════════════════════════════════════
+    deserializeInstance(row) {
+        return {
+            id: row.id,
+            packageGroupId: row.packageGroupId,
+            packageVersion: row.packageVersion,
+            packageRecordId: row.packageRecordId,
+            owner: row.owner,
+            ownerGhii: row.ownerGhii,
+            label: row.label,
+            installedComponents: JSON.parse(row.installedComponents),
+            status: row.status,
+            installedAt: row.installedAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    async createInstance(record) {
+        this.db.prepare(`INSERT INTO package_instances (id, packageGroupId, packageVersion, packageRecordId, owner, ownerGhii, label, installedComponents, status, installedAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.packageGroupId, record.packageVersion, record.packageRecordId, record.owner, record.ownerGhii, record.label, JSON.stringify(record.installedComponents), record.status, record.installedAt, record.updatedAt);
+        return record;
+    }
+    async getInstance(id) {
+        const row = this.db.prepare('SELECT * FROM package_instances WHERE id = ?').get(id);
+        return row ? this.deserializeInstance(row) : null;
+    }
+    async listInstances(filter) {
+        const conditions = [];
+        const params = [];
+        if (filter.owner) {
+            conditions.push('owner = ?');
+            params.push(filter.owner);
+        }
+        if (filter.ownerGhii) {
+            conditions.push('ownerGhii = ?');
+            params.push(filter.ownerGhii);
+        }
+        if (filter.packageGroupId) {
+            conditions.push('packageGroupId = ?');
+            params.push(filter.packageGroupId);
+        }
+        if (filter.status) {
+            conditions.push('status = ?');
+            params.push(filter.status);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = filter.limit ?? 50;
+        const offset = filter.offset ?? 0;
+        const total = this.db.prepare(`SELECT COUNT(*) as c FROM package_instances ${where}`).get(...params).c;
+        const rows = this.db.prepare(`SELECT * FROM package_instances ${where} ORDER BY installedAt DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        return { instances: rows.map(r => this.deserializeInstance(r)), total };
+    }
+    async updateInstance(id, updates) {
+        const existing = await this.getInstance(id);
+        if (!existing)
+            return null;
+        const merged = { ...existing, ...updates, id };
+        this.db.prepare(`UPDATE package_instances SET packageGroupId = ?, packageVersion = ?, packageRecordId = ?,
+       owner = ?, ownerGhii = ?, label = ?, installedComponents = ?, status = ?, updatedAt = ?
+       WHERE id = ?`).run(merged.packageGroupId, merged.packageVersion, merged.packageRecordId, merged.owner, merged.ownerGhii, merged.label, JSON.stringify(merged.installedComponents), merged.status, merged.updatedAt, id);
+        return merged;
+    }
+    async deleteInstance(id) {
+        const result = this.db.prepare('DELETE FROM package_instances WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    async listInstancesByPackage(packageGroupId) {
+        const total = this.db.prepare('SELECT COUNT(*) as c FROM package_instances WHERE packageGroupId = ?').get(packageGroupId).c;
+        const rows = this.db.prepare('SELECT * FROM package_instances WHERE packageGroupId = ? ORDER BY installedAt DESC').all(packageGroupId);
+        return { instances: rows.map(r => this.deserializeInstance(r)), total };
+    }
+}
+//# sourceMappingURL=index.js.map