aimeat 1.5.0 → 1.7.0

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

@@ -1,13 +1,24 @@
 /**
- * MongoDB Storage Implementation using Prisma Client.
+ * @file mongodb/index.ts
+ * @description MongoDB Storage Implementation using Prisma Client.
+ *   Auto-syncs collections & indexes on startup via `prisma db push`.
  *
  * To use:
  *   1. pnpm add @prisma/client prisma
  *   2. npx prisma generate
  *   3. Set DATABASE_URL environment variable
  *   4. Start with: aimeat --db mongodb://localhost:27017/aimeat
+ *
+ * @version-history
+ *   v1.0.0 — 2025-01-15 — Initial MongoDB storage implementation
+ *   v1.1.0 — 2026-05-21 — Auto-sync Prisma schema on startup (prisma db push)
  */
+import { execSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { logger } from '../../../utils/logger.js';
 import { matchesRecipient } from '../../../services/consent.js';
 import { parseGaiiLoose } from '../../../utils/gaii.js';
 // Prisma client will be imported dynamically at runtime
@@ -22,10 +33,49 @@ export class MongoStorage {
         this.ready = this.init(databaseUrl);
     }
     async init(databaseUrl) {
+        this.syncSchema(databaseUrl);
         const { PrismaClient } = await import('@prisma/client');
         this.prisma = new PrismaClient({ datasourceUrl: databaseUrl });
         await this.prisma.$connect();
     }
+    /**
+     * Run `prisma db push --skip-generate` to create any missing
+     * MongoDB collections & indexes. Safe and idempotent — never drops data.
+     * Skips silently if the prisma CLI is not available.
+     */
+    syncSchema(databaseUrl) {
+        const schemaPath = this.findPrismaSchema();
+        if (!schemaPath) {
+            logger.warn('prisma/schema.prisma not found — skipping auto schema sync');
+            return;
+        }
+        try {
+            execSync(`npx prisma db push --skip-generate --schema "${schemaPath}"`, {
+                stdio: 'pipe',
+                env: { ...process.env, DATABASE_URL: databaseUrl },
+                timeout: 30_000,
+            });
+            logger.info('MongoDB schema synced');
+        }
+        catch (err) {
+            const stderr = err.stderr?.toString() ?? '';
+            logger.warn(`Auto schema sync skipped — run "pnpm db:push" manually if needed. ${stderr || err.message}`);
+        }
+    }
+    /** Walk up from this file to find the nearest prisma/schema.prisma */
+    findPrismaSchema() {
+        let dir = dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 10; i++) {
+            const candidate = resolve(dir, 'prisma', 'schema.prisma');
+            if (existsSync(candidate))
+                return candidate;
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return null;
+    }
     ensureReady() {
         if (!this.prisma)
             throw new Error('MongoDB storage not yet initialized');
@@ -98,6 +148,16 @@ export class MongoStorage {
             await this.prisma.chatInstance.deleteMany({ where: { ownerName: name } });
             // 10. Delete email verifications for this owner (Prisma)
             await this.prisma.emailVerification.deleteMany({ where: { ownerName: name } });
+            // 10b. Delete owner-level agent dashboard data
+            const ghiiRows = await this.prisma.ghii.findMany({ where: { ownerName: name }, select: { ghii: true } });
+            for (const g of ghiiRows) {
+                await this.prisma.agentTask.deleteMany({ where: { ownerGaii: g.ghii } });
+                await this.prisma.sharingGroup.deleteMany({ where: { ownerGaii: g.ghii } });
+                try {
+                    await this.prisma.ownerAgentDefault.delete({ where: { ownerGaii: g.ghii } });
+                }
+                catch { /* not found */ }
+            }
             // 11. Delete the owner record
             await this.prisma.owner.delete({ where: { name } });
             return true;
@@ -123,6 +183,9 @@ export class MongoStorage {
                 allowedOrigins: agent.allowedOrigins ?? [],
                 defaultScopes: agent.defaultScopes ?? ['*'],
                 federate: agent.federate ?? false,
+                technicalCapabilities: agent.technicalCapabilities ?? null,
+                domainCapabilities: agent.domainCapabilities ?? null,
+                activityStats: agent.activityStats ?? null,
                 createdAt: new Date(agent.createdAt),
                 lastSeen: new Date(agent.lastSeen),
             },
@@ -218,6 +281,19 @@ export class MongoStorage {
         // OAuth refresh tokens and approvals for this agent
         await this.prisma.oAuthRefreshToken.deleteMany({ where: { gaii } });
         await this.prisma.oAuthApproval.deleteMany({ where: { gaii } });
+        // Agent tasks and events
+        const tasks = await this.prisma.agentTask.findMany({ where: { agentGaii: gaii }, select: { id: true } });
+        for (const t of tasks) {
+            await this.prisma.agentTaskEvent.deleteMany({ where: { taskId: t.id } });
+        }
+        await this.prisma.agentTask.deleteMany({ where: { agentGaii: gaii } });
+        // Agent directives
+        try {
+            await this.prisma.agentDirective.delete({ where: { agentGaii: gaii } });
+        }
+        catch { /* not found */ }
+        // Agent activity
+        await this.prisma.agentActivity.deleteMany({ where: { agentGaii: gaii } });
     }
     async listAgents() {
         this.ensureReady();
@@ -342,6 +418,7 @@ export class MongoStorage {
                 ownerGaii: record.ownerGaii,
                 value: record.value,
                 visibility: record.visibility,
+                groupId: record.groupId ?? null,
                 tags: record.tags,
                 ttlHours: record.ttlHours,
                 version: record.version,
@@ -353,6 +430,7 @@ export class MongoStorage {
             update: {
                 value: record.value,
                 visibility: record.visibility,
+                groupId: record.groupId ?? null,
                 tags: record.tags,
                 ttlHours: record.ttlHours,
                 version: record.version,
@@ -375,6 +453,7 @@ export class MongoStorage {
             data: {
                 value: record.value,
                 visibility: record.visibility,
+                groupId: record.groupId ?? null,
                 tags: record.tags,
                 ttlHours: record.ttlHours,
                 version: record.version,
@@ -1150,6 +1229,7 @@ export class MongoStorage {
                 data: file.data,
                 tags: file.tags || [],
                 federate: file.federate ?? false,
+                groupId: file.groupId ?? null,
                 createdAt: new Date(file.createdAt),
             },
         });
@@ -1162,16 +1242,16 @@ export class MongoStorage {
         });
         if (!row)
             return null;
-        return { key: row.key, ownerGaii: row.ownerGaii, visibility: row.visibility, mimeType: row.mimeType, size: row.size, data: Buffer.from(row.data), tags: row.tags || [], federate: row.federate ?? false, createdAt: row.createdAt.toISOString() };
+        return { key: row.key, ownerGaii: row.ownerGaii, visibility: row.visibility, groupId: row.groupId ?? undefined, mimeType: row.mimeType, size: row.size, data: Buffer.from(row.data), tags: row.tags || [], federate: row.federate ?? false, createdAt: row.createdAt.toISOString() };
     }
     async listStorageFiles(ownerGaii) {
         this.ensureReady();
         const rows = await this.prisma.storageFile.findMany({
             where: { ownerGaii },
-            select: { key: true, ownerGaii: true, visibility: true, mimeType: true, size: true, tags: true, federate: true, createdAt: true },
+            select: { key: true, ownerGaii: true, visibility: true, groupId: true, mimeType: true, size: true, tags: true, federate: true, createdAt: true },
         });
         return rows.map((r) => ({
-            key: r.key, ownerGaii: r.ownerGaii, visibility: r.visibility, mimeType: r.mimeType, size: r.size, data: Buffer.alloc(0), tags: r.tags || [], federate: r.federate ?? false, createdAt: r.createdAt.toISOString(),
+            key: r.key, ownerGaii: r.ownerGaii, visibility: r.visibility, groupId: r.groupId ?? undefined, mimeType: r.mimeType, size: r.size, data: Buffer.alloc(0), tags: r.tags || [], federate: r.federate ?? false, createdAt: r.createdAt.toISOString(),
         }));
     }
     async deleteStorageFile(ownerGaii, key) {
@@ -1300,10 +1380,10 @@ export class MongoStorage {
         return { name: row.name, displayName: row.displayName ?? undefined, publicKey: row.publicKey, roles: row.roles, createdAt: row.createdAt.toISOString() };
     }
     toAgentRecord(row) {
-        return { name: row.name, owner: row.owner, gaii: row.gaii, displayName: row.displayName ?? undefined, description: row.description ?? undefined, capabilities: row.capabilities, publicKey: row.publicKey, trustScore: row.trustScore, morselBalance: row.morselBalance, defaultScopes: row.defaultScopes?.length ? row.defaultScopes : undefined, allowedOrigins: row.allowedOrigins?.length ? row.allowedOrigins : undefined, federate: row.federate ?? false, createdAt: row.createdAt.toISOString(), lastSeen: row.lastSeen.toISOString() };
+        return { name: row.name, owner: row.owner, gaii: row.gaii, displayName: row.displayName ?? undefined, description: row.description ?? undefined, capabilities: row.capabilities, publicKey: row.publicKey, trustScore: row.trustScore, morselBalance: row.morselBalance, defaultScopes: row.defaultScopes?.length ? row.defaultScopes : undefined, allowedOrigins: row.allowedOrigins?.length ? row.allowedOrigins : undefined, federate: row.federate ?? false, technicalCapabilities: row.technicalCapabilities ?? undefined, domainCapabilities: row.domainCapabilities ?? undefined, activityStats: row.activityStats ?? undefined, createdAt: row.createdAt.toISOString(), lastSeen: row.lastSeen.toISOString() };
     }
     toMemoryRecord(row) {
-        return { key: row.key, ownerGaii: row.ownerGaii, value: row.value, visibility: row.visibility, tags: row.tags, ttlHours: row.ttlHours, version: row.version, createdAt: row.createdAt.toISOString(), updatedAt: row.updatedAt.toISOString(), flagCount: row.flagCount ?? undefined, allowedOrigins: row.allowedOrigins?.length ? row.allowedOrigins : undefined };
+        return { key: row.key, ownerGaii: row.ownerGaii, value: row.value, visibility: row.visibility, groupId: row.groupId ?? undefined, tags: row.tags, ttlHours: row.ttlHours, version: row.version, createdAt: row.createdAt.toISOString(), updatedAt: row.updatedAt.toISOString(), flagCount: row.flagCount ?? undefined, allowedOrigins: row.allowedOrigins?.length ? row.allowedOrigins : undefined };
     }
     toActionRecord(row) {
         return { id: row.actionId, providerGaii: row.providerGaii, displayName: row.displayName, description: row.description, category: row.category ?? undefined, inputSchema: row.inputSchema, outputSchema: row.outputSchema, pricing: { baseMorsels: row.pricingBaseMorsels, perUnit: row.pricingPerUnit }, estimatedTimeSeconds: row.estimatedTimeSeconds ?? undefined, maxInputSizeBytes: row.maxInputSizeBytes ?? undefined, tags: row.tags, webhookUrl: row.webhookUrl ?? undefined, semantic: row.semantic ?? undefined, federate: row.federate ?? false, createdAt: row.createdAt.toISOString(), updatedAt: row.updatedAt.toISOString() };
@@ -1845,6 +1925,14 @@ export class MongoStorage {
         }
         return results;
     }
+    async expireStaleConsents(before) {
+        this.ensureReady();
+        const result = await this.prisma.consent.updateMany({
+            where: { status: 'active', expires: { not: null, lt: new Date(before) } },
+            data: { status: 'expired' },
+        });
+        return result.count;
+    }
     // Consent Audit
     async addConsentAuditEntry(entry) {
         this.ensureReady();
@@ -2145,6 +2233,11 @@ export class MongoStorage {
         const result = await this.prisma.match.deleteMany({ where: { expiresAt: { lt: new Date() }, status: { not: 'accepted' } } });
         return result.count;
     }
+    async deleteMatchesByProfile(profile) {
+        this.ensureReady();
+        const result = await this.prisma.match.deleteMany({ where: { OR: [{ profileA: profile }, { profileB: profile }] } });
+        return result.count;
+    }
     async listAllMatches(limit = 10000) {
         this.ensureReady();
         const rows = await this.prisma.match.findMany({ take: Math.min(limit, 10000) });
@@ -3620,6 +3713,11 @@ export class MongoStorage {
         }
         return broken;
     }
+    async deleteLinksByContributor(gaii) {
+        this.ensureReady();
+        const result = await this.prisma.knowledgeLink.deleteMany({ where: { linkedBy: gaii } });
+        return result.count;
+    }
     // ══════════════════════════════════════════════════════════
     // ── Knowledge: Operator Reviews (Prisma-persisted) ──
     // ══════════════════════════════════════════════════════════
@@ -3665,6 +3763,11 @@ export class MongoStorage {
         });
         return rows.map((r) => this.toOperatorReviewRecord(r));
     }
+    async deleteReviewsByOperator(gaii) {
+        this.ensureReady();
+        const result = await this.prisma.knowledgeReview.deleteMany({ where: { operatorGaii: gaii } });
+        return result.count;
+    }
     // ══════════════════════════════════════════════════════════
     // ── Scheduler: Scheduled Jobs ──
     // ══════════════════════════════════════════════════════════
@@ -3866,6 +3969,7 @@ export class MongoStorage {
             status: row.status,
             translations: row.translations,
             createdBy: row.createdBy,
+            createdByAgent: row.createdByAgent ?? undefined,
             createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : row.createdAt,
             updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedAt,
         };
@@ -3880,6 +3984,7 @@ export class MongoStorage {
                 status: record.status,
                 translations: record.translations ? record.translations : undefined,
                 createdBy: record.createdBy,
+                createdByAgent: record.createdByAgent ?? null,
                 createdAt: new Date(record.createdAt),
             },
         });
@@ -3932,6 +4037,11 @@ export class MongoStorage {
             return false;
         }
     }
+    async deleteExtensionInstancesByOwner(ownerIdentity) {
+        this.ensureReady();
+        const result = await this.prisma.extensionInstance.deleteMany({ where: { createdBy: ownerIdentity } });
+        return result.count;
+    }
     // ══════════════════════════════════════════════════════════
     // ── Federation Peers (persisted active peer connections) ──
     // ══════════════════════════════════════════════════════════
@@ -3939,8 +4049,8 @@ export class MongoStorage {
         this.ensureReady();
         await this.prisma.federationPeer.upsert({
             where: { nodeId: peer.nodeId },
-            create: { nodeId: peer.nodeId, url: peer.url, publicKey: peer.publicKey, status: peer.status, addedAt: new Date(peer.addedAt), lastSeen: new Date(peer.lastSeen), shareCatalogue: peer.shareCatalogue, replicateMemory: peer.replicateMemory, allowRouting: peer.allowRouting, peerMode: peer.peerMode || 'federation' },
-            update: { url: peer.url, publicKey: peer.publicKey, status: peer.status, lastSeen: new Date(peer.lastSeen), shareCatalogue: peer.shareCatalogue, replicateMemory: peer.replicateMemory, allowRouting: peer.allowRouting, peerMode: peer.peerMode || 'federation' },
+            create: { nodeId: peer.nodeId, url: peer.url, publicKey: peer.publicKey, status: peer.status, addedAt: new Date(peer.addedAt), lastSeen: new Date(peer.lastSeen), shareCatalogue: peer.shareCatalogue, replicateMemory: peer.replicateMemory, allowRouting: peer.allowRouting, peerMode: peer.peerMode || 'federation', allowFederatedAuth: peer.allowFederatedAuth ?? false, federationAuthScopes: peer.federationAuthScopes ?? [] },
+            update: { url: peer.url, publicKey: peer.publicKey, status: peer.status, lastSeen: new Date(peer.lastSeen), shareCatalogue: peer.shareCatalogue, replicateMemory: peer.replicateMemory, allowRouting: peer.allowRouting, peerMode: peer.peerMode || 'federation', allowFederatedAuth: peer.allowFederatedAuth ?? false, federationAuthScopes: peer.federationAuthScopes ?? [] },
         });
     }
     async listFederationPeers() {
@@ -3957,6 +4067,8 @@ export class MongoStorage {
             replicateMemory: r.replicateMemory ?? true,
             allowRouting: r.allowRouting ?? true,
             peerMode: r.peerMode || 'federation',
+            allowFederatedAuth: r.allowFederatedAuth ?? false,
+            federationAuthScopes: r.federationAuthScopes ?? [],
         }));
     }
     async deleteFederationPeer(nodeId) {
@@ -4104,6 +4216,11 @@ export class MongoStorage {
         });
         return result.count;
     }
+    async deleteDeviceAuthByOwner(ownerName) {
+        this.ensureReady();
+        const result = await this.prisma.deviceAuth.deleteMany({ where: { ownerName } });
+        return result.count;
+    }
     toDeviceAuthRecord(row) {
         return {
             deviceCode: row.deviceCode,
@@ -5217,6 +5334,619 @@ export class MongoStorage {
         const trust = { ...cap.trust, vouchCount: Math.max(0, cap.trust.vouchCount - 1) };
         await this.prisma.capability.update({ where: { id }, data: { trust: trust } });
     }
+    // ── Stats Persistence ──
+    async flushStats(counters) {
+        const ops = Object.entries(counters).map(([key, value]) => this.prisma.statsCounter.upsert({
+            where: { id: key },
+            create: { id: key, value },
+            update: { value },
+        }));
+        await Promise.all(ops);
+    }
+    async loadStats() {
+        const rows = await this.prisma.statsCounter.findMany();
+        const result = {};
+        for (const row of rows) {
+            result[row.id] = row.value;
+        }
+        return result;
+    }
+    async flushDailyHistory(history) {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - 90);
+        const cutoffStr = cutoff.toISOString().split('T')[0];
+        const ops = [];
+        for (const [date, counters] of Object.entries(history)) {
+            for (const [key, value] of Object.entries(counters)) {
+                ops.push(this.prisma.statsDailyHistory.upsert({
+                    where: { date_key: { date, key } },
+                    create: { date, key, value },
+                    update: { value },
+                }));
+            }
+        }
+        ops.push(this.prisma.statsDailyHistory.deleteMany({ where: { date: { lt: cutoffStr } } }));
+        await Promise.all(ops);
+    }
+    async loadDailyHistory() {
+        const rows = await this.prisma.statsDailyHistory.findMany({ orderBy: { date: 'asc' } });
+        const result = {};
+        for (const row of rows) {
+            if (!result[row.date])
+                result[row.date] = {};
+            result[row.date][row.key] = row.value;
+        }
+        return result;
+    }
+    // ── Agent Tasks ──
+    toTaskRecord(row) {
+        return {
+            id: row.id,
+            agentGaii: row.agentGaii,
+            ownerGaii: row.ownerGaii,
+            title: row.title,
+            description: row.description,
+            scope: row.scope,
+            rules: row.rules,
+            verification: row.verification,
+            resources: row.resources ?? undefined,
+            todos: row.todos,
+            status: row.status,
+            parentTaskId: row.parentTaskId ?? undefined,
+            workTrackingCode: row.workTrackingCode ?? undefined,
+            telemetry: row.telemetry ?? undefined,
+            lastEventAt: row.lastEventAt ? (row.lastEventAt instanceof Date ? row.lastEventAt.toISOString() : row.lastEventAt) : undefined,
+            createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : row.createdAt,
+            updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedAt,
+            completedAt: row.completedAt ? (row.completedAt instanceof Date ? row.completedAt.toISOString() : row.completedAt) : undefined,
+        };
+    }
+    toTaskEventRecord(row) {
+        return {
+            id: row.id,
+            taskId: row.taskId,
+            type: row.type,
+            message: row.message,
+            details: row.details ?? undefined,
+            timestamp: row.timestamp instanceof Date ? row.timestamp.toISOString() : row.timestamp,
+        };
+    }
+    async createAgentTask(record) {
+        this.ensureReady();
+        await this.prisma.agentTask.create({
+            data: {
+                id: record.id,
+                agentGaii: record.agentGaii,
+                ownerGaii: record.ownerGaii,
+                title: record.title,
+                description: record.description,
+                scope: record.scope,
+                rules: record.rules,
+                verification: record.verification,
+                resources: record.resources ?? null,
+                todos: record.todos,
+                status: record.status,
+                parentTaskId: record.parentTaskId ?? null,
+                workTrackingCode: record.workTrackingCode ?? null,
+                telemetry: record.telemetry ?? null,
+                lastEventAt: record.lastEventAt ? new Date(record.lastEventAt) : null,
+                createdAt: new Date(record.createdAt),
+                completedAt: record.completedAt ? new Date(record.completedAt) : null,
+            },
+        });
+        return record;
+    }
+    async getAgentTask(id) {
+        this.ensureReady();
+        const row = await this.prisma.agentTask.findUnique({ where: { id } });
+        return row ? this.toTaskRecord(row) : null;
+    }
+    async listAgentTasks(agentGaii, opts) {
+        this.ensureReady();
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const where = { agentGaii };
+        if (opts?.status)
+            where.status = opts.status;
+        const [rows, total] = await Promise.all([
+            this.prisma.agentTask.findMany({
+                where,
+                orderBy: { updatedAt: 'desc' },
+                skip: (page - 1) * perPage,
+                take: perPage,
+            }),
+            this.prisma.agentTask.count({ where }),
+        ]);
+        return { tasks: rows.map((r) => this.toTaskRecord(r)), total };
+    }
+    async listAgentTasksByOwner(ownerGaii, opts) {
+        this.ensureReady();
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const where = { ownerGaii };
+        if (opts?.agentGaii)
+            where.agentGaii = opts.agentGaii;
+        if (opts?.status)
+            where.status = opts.status;
+        const [rows, total] = await Promise.all([
+            this.prisma.agentTask.findMany({
+                where,
+                orderBy: { updatedAt: 'desc' },
+                skip: (page - 1) * perPage,
+                take: perPage,
+            }),
+            this.prisma.agentTask.count({ where }),
+        ]);
+        return { tasks: rows.map((r) => this.toTaskRecord(r)), total };
+    }
+    async updateAgentTask(id, updates) {
+        this.ensureReady();
+        const existing = await this.getAgentTask(id);
+        if (!existing)
+            return null;
+        const merged = {
+            ...existing,
+            ...updates,
+            id: existing.id,
+            agentGaii: existing.agentGaii,
+            ownerGaii: existing.ownerGaii,
+            createdAt: existing.createdAt,
+        };
+        try {
+            const row = await this.prisma.agentTask.update({
+                where: { id },
+                data: {
+                    title: merged.title,
+                    description: merged.description,
+                    scope: merged.scope,
+                    rules: merged.rules,
+                    verification: merged.verification,
+                    resources: merged.resources ?? null,
+                    todos: merged.todos,
+                    status: merged.status,
+                    parentTaskId: merged.parentTaskId ?? null,
+                    workTrackingCode: merged.workTrackingCode ?? null,
+                    telemetry: merged.telemetry ?? null,
+                    lastEventAt: merged.lastEventAt ? new Date(merged.lastEventAt) : null,
+                    completedAt: merged.completedAt ? new Date(merged.completedAt) : null,
+                },
+            });
+            return this.toTaskRecord(row);
+        }
+        catch {
+            return null;
+        }
+    }
+    async deleteAgentTask(id) {
+        this.ensureReady();
+        try {
+            const result = await this.prisma.agentTask.deleteMany({
+                where: { id, status: { in: ['draft', 'queued'] } },
+            });
+            if (result.count > 0) {
+                await this.prisma.agentTaskEvent.deleteMany({ where: { taskId: id } });
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async appendTaskEvent(event) {
+        this.ensureReady();
+        const row = await this.prisma.agentTaskEvent.create({
+            data: {
+                taskId: event.taskId,
+                type: event.type,
+                message: event.message,
+                details: event.details ?? null,
+                timestamp: new Date(event.timestamp),
+            },
+        });
+        return this.toTaskEventRecord(row);
+    }
+    async listTaskEvents(taskId, opts) {
+        this.ensureReady();
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const where = { taskId };
+        const [rows, total] = await Promise.all([
+            this.prisma.agentTaskEvent.findMany({
+                where,
+                orderBy: { timestamp: 'asc' },
+                skip: (page - 1) * perPage,
+                take: perPage,
+            }),
+            this.prisma.agentTaskEvent.count({ where }),
+        ]);
+        return { events: rows.map((r) => this.toTaskEventRecord(r)), total };
+    }
+    async countTasksByAgent(agentGaii) {
+        this.ensureReady();
+        const rows = await this.prisma.agentTask.groupBy({
+            by: ['status'],
+            where: { agentGaii },
+            _count: true,
+        });
+        const counts = { queued: 0, active: 0, done: 0, failed: 0 };
+        for (const row of rows) {
+            if (row.status in counts) {
+                counts[row.status] = row._count;
+            }
+        }
+        return counts;
+    }
+    async findStalledTasks(thresholdMinutes) {
+        this.ensureReady();
+        const threshold = new Date(Date.now() - thresholdMinutes * 60 * 1000);
+        const rows = await this.prisma.agentTask.findMany({
+            where: {
+                status: 'active',
+                lastEventAt: { not: null, lt: threshold },
+            },
+        });
+        return rows.map((r) => this.toTaskRecord(r));
+    }
+    // ── Sharing Groups ──
+    toSharingGroupRecord(row) {
+        const record = {
+            id: row.id,
+            name: row.name,
+            ownerGaii: row.ownerGaii,
+            members: row.members,
+            defaultPermissions: row.defaultPermissions,
+            createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : row.createdAt,
+            updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedAt,
+        };
+        if (row.description)
+            record.description = row.description;
+        return record;
+    }
+    async createSharingGroup(record) {
+        this.ensureReady();
+        await this.prisma.sharingGroup.create({
+            data: {
+                id: record.id,
+                name: record.name,
+                description: record.description ?? null,
+                ownerGaii: record.ownerGaii,
+                members: record.members,
+                defaultPermissions: record.defaultPermissions,
+                createdAt: new Date(record.createdAt),
+            },
+        });
+        return record;
+    }
+    async getSharingGroup(id) {
+        this.ensureReady();
+        const row = await this.prisma.sharingGroup.findUnique({ where: { id } });
+        return row ? this.toSharingGroupRecord(row) : null;
+    }
+    async listSharingGroups(ownerGaii) {
+        this.ensureReady();
+        const rows = await this.prisma.sharingGroup.findMany({
+            where: { ownerGaii },
+            orderBy: { createdAt: 'desc' },
+        });
+        return rows.map((r) => this.toSharingGroupRecord(r));
+    }
+    async listSharingGroupsByMember(identifier) {
+        this.ensureReady();
+        // MongoDB JSON arrays can't be queried with SQL json_each; filter in memory
+        const allGroups = await this.prisma.sharingGroup.findMany();
+        return allGroups
+            .filter((g) => {
+            const members = g.members;
+            return Array.isArray(members) && members.some(m => m.identifier === identifier);
+        })
+            .map((r) => this.toSharingGroupRecord(r));
+    }
+    async updateSharingGroup(id, updates) {
+        this.ensureReady();
+        const existing = await this.getSharingGroup(id);
+        if (!existing)
+            return null;
+        const merged = {
+            ...existing,
+            ...updates,
+            id: existing.id,
+            ownerGaii: existing.ownerGaii,
+            createdAt: existing.createdAt,
+        };
+        try {
+            const row = await this.prisma.sharingGroup.update({
+                where: { id },
+                data: {
+                    name: merged.name,
+                    description: merged.description ?? null,
+                    members: merged.members,
+                    defaultPermissions: merged.defaultPermissions,
+                },
+            });
+            return this.toSharingGroupRecord(row);
+        }
+        catch {
+            return null;
+        }
+    }
+    async deleteSharingGroup(id) {
+        this.ensureReady();
+        try {
+            await this.prisma.sharingGroup.delete({ where: { id } });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async countEntriesReferencingGroup(groupId) {
+        this.ensureReady();
+        const [memoryCount, fileCount] = await Promise.all([
+            this.prisma.memory.count({ where: { groupId } }),
+            this.prisma.storageFile.count({ where: { groupId } }),
+        ]);
+        return memoryCount + fileCount;
+    }
+    // ── Agent Directives ──
+    toDirectivesRecord(row) {
+        return {
+            agentGaii: row.agentGaii,
+            purpose: row.purpose,
+            rules: row.rules,
+            memoryAreas: row.memoryAreas,
+            resources: row.resources,
+            updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedAt,
+        };
+    }
+    toOwnerDefaultsRecord(row) {
+        const record = {
+            ownerGaii: row.ownerGaii,
+            rules: row.rules,
+            updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedAt,
+        };
+        if (row.defaultTokenBudget != null)
+            record.defaultTokenBudget = row.defaultTokenBudget;
+        if (row.defaultMemoryAreas)
+            record.defaultMemoryAreas = row.defaultMemoryAreas;
+        return record;
+    }
+    async getAgentDirectives(agentGaii) {
+        this.ensureReady();
+        const row = await this.prisma.agentDirective.findUnique({ where: { agentGaii } });
+        return row ? this.toDirectivesRecord(row) : null;
+    }
+    async upsertAgentDirectives(record) {
+        this.ensureReady();
+        const row = await this.prisma.agentDirective.upsert({
+            where: { agentGaii: record.agentGaii },
+            create: {
+                id: `dir-${record.agentGaii}`,
+                agentGaii: record.agentGaii,
+                purpose: record.purpose,
+                rules: record.rules,
+                memoryAreas: record.memoryAreas,
+                resources: record.resources,
+            },
+            update: {
+                purpose: record.purpose,
+                rules: record.rules,
+                memoryAreas: record.memoryAreas,
+                resources: record.resources,
+            },
+        });
+        return this.toDirectivesRecord(row);
+    }
+    async deleteAgentDirectives(agentGaii) {
+        this.ensureReady();
+        try {
+            await this.prisma.agentDirective.delete({ where: { agentGaii } });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getOwnerAgentDefaults(ownerGaii) {
+        this.ensureReady();
+        const row = await this.prisma.ownerAgentDefault.findUnique({ where: { ownerGaii } });
+        return row ? this.toOwnerDefaultsRecord(row) : null;
+    }
+    async upsertOwnerAgentDefaults(record) {
+        this.ensureReady();
+        const row = await this.prisma.ownerAgentDefault.upsert({
+            where: { ownerGaii: record.ownerGaii },
+            create: {
+                id: `owd-${record.ownerGaii}`,
+                ownerGaii: record.ownerGaii,
+                rules: record.rules,
+                defaultTokenBudget: record.defaultTokenBudget ?? null,
+                defaultMemoryAreas: record.defaultMemoryAreas ?? [],
+            },
+            update: {
+                rules: record.rules,
+                defaultTokenBudget: record.defaultTokenBudget ?? null,
+                defaultMemoryAreas: record.defaultMemoryAreas ?? [],
+            },
+        });
+        return this.toOwnerDefaultsRecord(row);
+    }
+    // ── Agent Activity ──
+    toActivityRecord(row) {
+        return {
+            agentGaii: row.agentGaii,
+            date: row.date,
+            hour: row.hour,
+            metric: row.metric,
+            value: row.value,
+        };
+    }
+    async recordActivity(record) {
+        this.ensureReady();
+        await this.prisma.agentActivity.upsert({
+            where: {
+                agentGaii_date_hour_metric: {
+                    agentGaii: record.agentGaii,
+                    date: record.date,
+                    hour: record.hour,
+                    metric: record.metric,
+                },
+            },
+            create: {
+                agentGaii: record.agentGaii,
+                date: record.date,
+                hour: record.hour,
+                metric: record.metric,
+                value: record.value,
+            },
+            update: {
+                value: { increment: record.value },
+            },
+        });
+    }
+    async getActivityHistory(agentGaii, opts) {
+        this.ensureReady();
+        const days = opts?.days ?? 30;
+        const granularity = opts?.granularity ?? 'daily';
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - days);
+        const cutoffStr = cutoff.toISOString().split('T')[0];
+        if (granularity === 'daily') {
+            const rows = await this.prisma.agentActivity.groupBy({
+                by: ['agentGaii', 'date', 'metric'],
+                where: { agentGaii, date: { gte: cutoffStr } },
+                _sum: { value: true },
+                orderBy: { date: 'asc' },
+            });
+            return rows.map((r) => ({
+                agentGaii: r.agentGaii,
+                date: r.date,
+                hour: 0,
+                metric: r.metric,
+                value: r._sum.value ?? 0,
+            }));
+        }
+        // hourly granularity
+        const rows = await this.prisma.agentActivity.findMany({
+            where: { agentGaii, date: { gte: cutoffStr } },
+            orderBy: [{ date: 'asc' }, { hour: 'asc' }],
+        });
+        return rows.map((r) => this.toActivityRecord(r));
+    }
+    // ── Agent Messages ──
+    toMessageRecord(row) {
+        const record = {
+            id: row.id,
+            agentGaii: row.agentGaii,
+            threadId: row.threadId,
+            direction: row.direction,
+            senderGaii: row.senderGaii,
+            content: row.content,
+            status: row.status,
+            createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : row.createdAt,
+        };
+        if (row.linkedTaskId)
+            record.linkedTaskId = row.linkedTaskId;
+        if (row.metadata)
+            record.metadata = row.metadata;
+        if (row.processedAt)
+            record.processedAt = row.processedAt instanceof Date ? row.processedAt.toISOString() : row.processedAt;
+        return record;
+    }
+    async createMessage(record) {
+        this.ensureReady();
+        await this.prisma.agentMessage.create({
+            data: {
+                id: record.id,
+                agentGaii: record.agentGaii,
+                threadId: record.threadId,
+                direction: record.direction,
+                senderGaii: record.senderGaii,
+                content: record.content,
+                status: record.status,
+                linkedTaskId: record.linkedTaskId ?? null,
+                metadata: record.metadata ?? null,
+                createdAt: new Date(record.createdAt),
+                processedAt: record.processedAt ? new Date(record.processedAt) : null,
+            },
+        });
+        return record;
+    }
+    async getMessage(id) {
+        this.ensureReady();
+        const row = await this.prisma.agentMessage.findUnique({ where: { id } });
+        return row ? this.toMessageRecord(row) : null;
+    }
+    async listMessages(agentGaii, opts) {
+        this.ensureReady();
+        const page = opts?.page ?? 1;
+        const perPage = opts?.perPage ?? 20;
+        const where = { agentGaii };
+        if (opts?.direction)
+            where.direction = opts.direction;
+        if (opts?.threadId)
+            where.threadId = opts.threadId;
+        const [rows, total] = await Promise.all([
+            this.prisma.agentMessage.findMany({
+                where,
+                orderBy: { createdAt: 'desc' },
+                skip: (page - 1) * perPage,
+                take: perPage,
+            }),
+            this.prisma.agentMessage.count({ where }),
+        ]);
+        return { messages: rows.map((r) => this.toMessageRecord(r)), total };
+    }
+    async listPendingMessages(agentGaii) {
+        this.ensureReady();
+        const rows = await this.prisma.agentMessage.findMany({
+            where: { agentGaii, status: 'pending', direction: 'inbound' },
+            orderBy: { createdAt: 'asc' },
+        });
+        return rows.map((r) => this.toMessageRecord(r));
+    }
+    async updateMessageStatus(id, status, processedAt) {
+        this.ensureReady();
+        try {
+            const data = { status };
+            if (processedAt)
+                data.processedAt = new Date(processedAt);
+            const row = await this.prisma.agentMessage.update({
+                where: { id },
+                data,
+            });
+            return this.toMessageRecord(row);
+        }
+        catch {
+            return null;
+        }
+    }
+    async listThreads(agentGaii) {
+        this.ensureReady();
+        const groups = await this.prisma.agentMessage.groupBy({
+            by: ['threadId'],
+            where: { agentGaii },
+            _count: { _all: true },
+            _max: { createdAt: true },
+        });
+        const results = [];
+        for (const g of groups) {
+            const lastMsg = await this.prisma.agentMessage.findFirst({
+                where: { agentGaii, threadId: g.threadId },
+                orderBy: { createdAt: 'desc' },
+                select: { content: true },
+            });
+            results.push({
+                threadId: g.threadId,
+                lastMessage: lastMsg?.content ?? '',
+                messageCount: g._count._all,
+                updatedAt: g._max.createdAt instanceof Date ? g._max.createdAt.toISOString() : (g._max.createdAt ?? ''),
+            });
+        }
+        // Sort by updatedAt descending
+        results.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return results;
+    }
 }
 /**
  * Wildcard pattern matching: supports '*' (one segment) and '**' (multiple segments)