libre-webui 0.24.1 → 0.26.0

package/backend/dist/persistence/postgresResourceRepositories.js

@@ -34,9 +34,168 @@ const namedResource = (row) => ({
 });
 const note = (row) => ({
     ...row,
+    pinned: number(row.pinned ?? 0, 'note pinned'),
     created_at: number(row.created_at, 'note created_at'),
     updated_at: number(row.updated_at, 'note updated_at'),
 });
+const noteRevision = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'note revision created_at'),
+});
+const noteAttachment = (row) => ({
+    ...row,
+    size: number(row.size, 'note attachment size'),
+    created_at: number(row.created_at, 'note attachment created_at'),
+});
+const calendarEvent = (row) => ({
+    ...row,
+    start_at: number(row.start_at, 'calendar event start_at'),
+    end_at: row.end_at === null ? null : number(row.end_at, 'calendar event end_at'),
+    all_day: number(row.all_day, 'calendar event all_day'),
+    reminder_minutes: row.reminder_minutes === null
+        ? null
+        : number(row.reminder_minutes, 'calendar event reminder_minutes'),
+    last_reminded_occurrence: row.last_reminded_occurrence === null
+        ? null
+        : number(row.last_reminded_occurrence, 'calendar event last_reminded_occurrence'),
+    created_at: number(row.created_at, 'calendar event created_at'),
+    updated_at: number(row.updated_at, 'calendar event updated_at'),
+});
+const calendar = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'calendar created_at'),
+    updated_at: number(row.updated_at, 'calendar updated_at'),
+});
+const channel = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'channel created_at'),
+    updated_at: number(row.updated_at, 'channel updated_at'),
+    archived_at: row.archived_at === null
+        ? null
+        : number(row.archived_at, 'channel archived_at'),
+});
+const channelMember = (row) => ({
+    ...row,
+    joined_at: number(row.joined_at, 'channel member joined_at'),
+    last_read_at: number(row.last_read_at, 'channel member last_read_at'),
+});
+const channelMessage = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'channel message created_at'),
+    updated_at: number(row.updated_at, 'channel message updated_at'),
+    edited_at: row.edited_at === null
+        ? null
+        : number(row.edited_at, 'channel message edited_at'),
+    deleted_at: row.deleted_at === null
+        ? null
+        : number(row.deleted_at, 'channel message deleted_at'),
+    pinned_at: row.pinned_at === null
+        ? null
+        : number(row.pinned_at, 'channel message pinned_at'),
+});
+const channelReaction = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'channel reaction created_at'),
+});
+const channelAttachment = (row) => ({
+    ...row,
+    size: number(row.size, 'channel attachment size'),
+    created_at: number(row.created_at, 'channel attachment created_at'),
+});
+const notification = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'notification created_at'),
+    read_at: row.read_at === null ? null : number(row.read_at, 'notification read_at'),
+});
+const webhookTarget = (row) => ({
+    ...row,
+    enabled: number(row.enabled, 'webhook target enabled'),
+    created_at: number(row.created_at, 'webhook target created_at'),
+    updated_at: number(row.updated_at, 'webhook target updated_at'),
+});
+const automation = (row) => ({
+    ...row,
+    next_run_at: row.next_run_at === null
+        ? null
+        : number(row.next_run_at, 'automation next_run_at'),
+    last_run_at: row.last_run_at === null
+        ? null
+        : number(row.last_run_at, 'automation last_run_at'),
+    created_at: number(row.created_at, 'automation created_at'),
+    updated_at: number(row.updated_at, 'automation updated_at'),
+});
+const automationRun = (row) => ({
+    ...row,
+    scheduled_for: number(row.scheduled_for, 'automation run scheduled_for'),
+    started_at: row.started_at === null
+        ? null
+        : number(row.started_at, 'automation run started_at'),
+    finished_at: row.finished_at === null
+        ? null
+        : number(row.finished_at, 'automation run finished_at'),
+    seen_at: row.seen_at === null ? null : number(row.seen_at, 'automation run seen_at'),
+    created_at: number(row.created_at, 'automation run created_at'),
+});
+const toolServer = (row) => ({
+    ...row,
+    spec_revision: number(row.spec_revision, 'tool server spec_revision'),
+    enabled: number(row.enabled, 'tool server enabled'),
+    timeout_ms: number(row.timeout_ms, 'tool server timeout_ms'),
+    max_response_bytes: number(row.max_response_bytes, 'tool server max_response_bytes'),
+    created_at: number(row.created_at, 'tool server created_at'),
+    updated_at: number(row.updated_at, 'tool server updated_at'),
+});
+const toolServerTool = (row) => ({
+    ...row,
+    side_effect: number(row.side_effect, 'tool side_effect'),
+    enabled: number(row.enabled, 'tool enabled'),
+    created_at: number(row.created_at, 'tool created_at'),
+    updated_at: number(row.updated_at, 'tool updated_at'),
+});
+const toolServerCredential = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'tool credential created_at'),
+    updated_at: number(row.updated_at, 'tool credential updated_at'),
+});
+const toolApproval = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'tool approval created_at'),
+    resolved_at: row.resolved_at === null
+        ? null
+        : number(row.resolved_at, 'tool approval resolved_at'),
+    expires_at: row.expires_at === null
+        ? null
+        : number(row.expires_at, 'tool approval expires_at'),
+});
+const prompt = (row) => ({
+    ...row,
+    version: number(row.version, 'prompt version'),
+    created_at: number(row.created_at, 'prompt created_at'),
+    updated_at: number(row.updated_at, 'prompt updated_at'),
+});
+const promptVersion = (row) => ({
+    ...row,
+    version: number(row.version, 'prompt revision version'),
+    created_at: number(row.created_at, 'prompt revision created_at'),
+});
+const skill = (row) => ({
+    ...row,
+    enabled: number(row.enabled, 'skill enabled'),
+    version: number(row.version, 'skill version'),
+    created_at: number(row.created_at, 'skill created_at'),
+    updated_at: number(row.updated_at, 'skill updated_at'),
+});
+const skillVersion = (row) => ({
+    ...row,
+    version: number(row.version, 'skill revision version'),
+    created_at: number(row.created_at, 'skill revision created_at'),
+});
+const skillFile = (row) => ({
+    ...row,
+    size: number(row.size, 'skill file size'),
+    created_at: number(row.created_at, 'skill file created_at'),
+    updated_at: number(row.updated_at, 'skill file updated_at'),
+});
 const changes = (rowCount) => rowCount ?? 0;
 const lockOwner = async (client, userId) => {
     const result = await client.query('SELECT id FROM users WHERE id = $1 FOR UPDATE', [userId]);
@@ -198,118 +357,1541 @@ class PostgresChatSessionRepository {
                   AND (id = $3 OR parent_id = $3)`, [previousActiveMessageId, sessionId, row.parent_id]);
                 }
             }
-            return changes(deleted.rowCount) > 0;
-        }, { isolationLevel: 'serializable' });
+            return changes(deleted.rowCount) > 0;
+        }, { isolationLevel: 'serializable' });
+    }
+    async deleteByOwner(sessionId, userId, beforeCommit) {
+        return this.database.transaction(async (client) => changes((await client.query('DELETE FROM sessions WHERE id = $1 AND user_id = $2', [sessionId, userId])).rowCount) > 0, { isolationLevel: 'serializable', beforeCommit });
+    }
+    async deleteAllByOwner(userId) {
+        return changes((await this.database.query('DELETE FROM sessions WHERE user_id = $1', [
+            userId,
+        ])).rowCount);
+    }
+}
+class PostgresKnowledgeCollectionRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId) {
+        const result = await this.database.query(`SELECT * FROM knowledge_collections
+        WHERE user_id = $1
+        ORDER BY lower(name), name`, [userId]);
+        return result.rows.map(namedResource);
+    }
+    async findById(collectionId) {
+        const result = await this.database.query('SELECT * FROM knowledge_collections WHERE id = $1', [collectionId]);
+        return result.rows[0] ? namedResource(result.rows[0]) : null;
+    }
+    async replace(collection) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, collection.user_id);
+            const result = await client.query(`INSERT INTO knowledge_collections
+           (id, user_id, name, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           updated_at = EXCLUDED.updated_at
+         WHERE knowledge_collections.user_id = EXCLUDED.user_id`, [
+                collection.id,
+                collection.user_id,
+                collection.name,
+                collection.created_at,
+                collection.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async deleteAndDetach(collectionId, userId) {
+        return (changes((await this.database.query('DELETE FROM knowledge_collections WHERE id = $1 AND user_id = $2', [collectionId, userId])).rowCount) > 0);
+    }
+}
+class PostgresNoteRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM notes
+        WHERE user_id = $1
+        ORDER BY pinned DESC, updated_at DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(note);
+    }
+    async findByOwner(noteId, userId) {
+        const result = await this.database.query('SELECT * FROM notes WHERE id = $1 AND user_id = $2', [noteId, userId]);
+        return result.rows[0] ? note(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM notes WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM notes WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('note', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO notes (id, user_id, title, content, pinned, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (id) DO UPDATE SET
+           title = EXCLUDED.title,
+           content = EXCLUDED.content,
+           pinned = EXCLUDED.pinned,
+           updated_at = EXCLUDED.updated_at
+         WHERE notes.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.title,
+                value.content,
+                value.pinned,
+                value.created_at,
+                value.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async patchByOwner(noteId, userId, patch) {
+        const assignments = [];
+        const values = [];
+        const assign = (column, value) => {
+            values.push(value);
+            assignments.push(`${column} = $${values.length}`);
+        };
+        if (patch.title !== undefined)
+            assign('title', patch.title);
+        if (patch.content !== undefined)
+            assign('content', patch.content);
+        if (patch.pinned !== undefined)
+            assign('pinned', patch.pinned);
+        assign('updated_at', patch.updated_at);
+        values.push(noteId, userId);
+        const result = await this.database.query(`UPDATE notes SET ${assignments.join(', ')}
+        WHERE id = $${values.length - 1} AND user_id = $${values.length}
+        RETURNING *`, values);
+        return result.rows[0] ? note(result.rows[0]) : null;
+    }
+    async deleteByOwner(noteId, userId) {
+        return (changes((await this.database.query('DELETE FROM notes WHERE id = $1 AND user_id = $2', [noteId, userId])).rowCount) > 0);
+    }
+    async findById(noteId) {
+        const result = await this.database.query('SELECT * FROM notes WHERE id = $1', [noteId]);
+        return result.rows[0] ? note(result.rows[0]) : null;
+    }
+    async patchById(noteId, patch) {
+        const assignments = [];
+        const values = [];
+        const assign = (column, value) => {
+            values.push(value);
+            assignments.push(`${column} = $${values.length}`);
+        };
+        if (patch.title !== undefined)
+            assign('title', patch.title);
+        if (patch.content !== undefined)
+            assign('content', patch.content);
+        if (patch.pinned !== undefined)
+            assign('pinned', patch.pinned);
+        assign('updated_at', patch.updated_at);
+        values.push(noteId);
+        const result = await this.database.query(`UPDATE notes SET ${assignments.join(', ')}
+        WHERE id = $${values.length}
+        RETURNING *`, values);
+        return result.rows[0] ? note(result.rows[0]) : null;
+    }
+    async listRevisions(noteId, maximum) {
+        const result = await this.database.query(`SELECT * FROM note_revisions
+        WHERE note_id = $1
+        ORDER BY created_at DESC, id DESC
+        LIMIT $2`, [noteId, maximum]);
+        return result.rows.map(noteRevision);
+    }
+    async findRevision(revisionId) {
+        const result = await this.database.query('SELECT * FROM note_revisions WHERE id = $1', [revisionId]);
+        return result.rows[0] ? noteRevision(result.rows[0]) : null;
+    }
+    async insertRevision(revision, maximum) {
+        await this.database.transaction(async (client) => {
+            // Strictly increasing per note so same-millisecond snapshots keep a
+            // deterministic order for listing, restore, and pruning.
+            await client.query(`INSERT INTO note_revisions (id, note_id, title, content, created_at)
+         SELECT $1, $2, $3, $4,
+                GREATEST($5::bigint, COALESCE(MAX(created_at), 0) + 1)
+           FROM note_revisions WHERE note_id = $2`, [
+                revision.id,
+                revision.note_id,
+                revision.title,
+                revision.content,
+                revision.created_at,
+            ]);
+            await client.query(`DELETE FROM note_revisions
+          WHERE note_id = $1
+            AND id NOT IN (
+              SELECT id FROM note_revisions
+               WHERE note_id = $1
+               ORDER BY created_at DESC, id DESC
+               LIMIT $2
+            )`, [revision.note_id, maximum]);
+        });
+    }
+    async listAttachments(noteId) {
+        const result = await this.database.query(`SELECT * FROM note_attachments
+        WHERE note_id = $1
+        ORDER BY created_at ASC, id ASC`, [noteId]);
+        return result.rows.map(noteAttachment);
+    }
+    async findAttachment(attachmentId) {
+        const result = await this.database.query('SELECT * FROM note_attachments WHERE id = $1', [attachmentId]);
+        return result.rows[0] ? noteAttachment(result.rows[0]) : null;
+    }
+    async insertAttachmentWithLimit(attachment, maximum) {
+        await this.database.transaction(async (client) => {
+            await client.query('SELECT id FROM notes WHERE id = $1 FOR UPDATE', [
+                attachment.note_id,
+            ]);
+            const count = await client.query('SELECT COUNT(*)::text AS count FROM note_attachments WHERE note_id = $1', [attachment.note_id]);
+            if (Number(count.rows[0]?.count || 0) >= maximum) {
+                throw new PersistenceResourceLimitError('note-attachment', maximum);
+            }
+            await client.query(`INSERT INTO note_attachments
+           (id, note_id, blob_id, filename, content_type, size, created_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
+                attachment.id,
+                attachment.note_id,
+                attachment.blob_id,
+                attachment.filename,
+                attachment.content_type,
+                attachment.size,
+                attachment.created_at,
+            ]);
+        });
+    }
+    async deleteAttachment(attachmentId) {
+        return (changes((await this.database.query('DELETE FROM note_attachments WHERE id = $1', [attachmentId])).rowCount) > 0);
+    }
+}
+class PostgresCalendarEventRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwnerBetween(userId, from, to, maximum) {
+        const result = await this.database.query(`SELECT * FROM calendar_events
+        WHERE user_id = $1 AND start_at >= $2 AND start_at < $3
+        ORDER BY start_at ASC
+        LIMIT $4`, [userId, from, to, maximum]);
+        return result.rows.map(calendarEvent);
+    }
+    async listRecurringByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM calendar_events
+        WHERE user_id = $1 AND recurrence IS NOT NULL
+        ORDER BY start_at ASC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(calendarEvent);
+    }
+    async listByCalendarsBetween(calendarIds, from, to, maximum) {
+        if (calendarIds.length === 0)
+            return [];
+        const result = await this.database.query(`SELECT * FROM calendar_events
+        WHERE calendar_id = ANY($1::text[])
+          AND start_at >= $2 AND start_at < $3
+        ORDER BY start_at ASC
+        LIMIT $4`, [[...calendarIds], from, to, maximum]);
+        return result.rows.map(calendarEvent);
+    }
+    async listRecurringByCalendars(calendarIds, maximum) {
+        if (calendarIds.length === 0)
+            return [];
+        const result = await this.database.query(`SELECT * FROM calendar_events
+        WHERE calendar_id = ANY($1::text[])
+          AND recurrence IS NOT NULL
+        ORDER BY start_at ASC
+        LIMIT $2`, [[...calendarIds], maximum]);
+        return result.rows.map(calendarEvent);
+    }
+    async findByOwner(eventId, userId) {
+        const result = await this.database.query('SELECT * FROM calendar_events WHERE id = $1 AND user_id = $2', [eventId, userId]);
+        return result.rows[0] ? calendarEvent(result.rows[0]) : null;
+    }
+    async findById(eventId) {
+        const result = await this.database.query('SELECT * FROM calendar_events WHERE id = $1', [eventId]);
+        return result.rows[0] ? calendarEvent(result.rows[0]) : null;
+    }
+    async listWithReminders(maximum) {
+        const result = await this.database.query(`SELECT * FROM calendar_events
+        WHERE reminder_minutes IS NOT NULL
+        ORDER BY start_at ASC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(calendarEvent);
+    }
+    async markReminded(eventId, occurrenceStart) {
+        return (changes((await this.database.query(`UPDATE calendar_events
+              SET last_reminded_occurrence = $1
+              WHERE id = $2
+                AND (last_reminded_occurrence IS NULL
+                  OR last_reminded_occurrence < $1)`, [occurrenceStart, eventId])).rowCount) > 0);
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM calendar_events WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM calendar_events WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('calendar-event', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO calendar_events
+           (id, user_id, title, notes, start_at, end_at, all_day,
+            recurrence, calendar_id, reminder_minutes,
+            last_reminded_occurrence, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+         ON CONFLICT (id) DO UPDATE SET
+           title = EXCLUDED.title,
+           notes = EXCLUDED.notes,
+           start_at = EXCLUDED.start_at,
+           end_at = EXCLUDED.end_at,
+           all_day = EXCLUDED.all_day,
+           recurrence = EXCLUDED.recurrence,
+           calendar_id = EXCLUDED.calendar_id,
+           reminder_minutes = EXCLUDED.reminder_minutes,
+           last_reminded_occurrence = EXCLUDED.last_reminded_occurrence,
+           updated_at = EXCLUDED.updated_at
+         WHERE calendar_events.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.title,
+                value.notes,
+                value.start_at,
+                value.end_at,
+                value.all_day,
+                value.recurrence,
+                value.calendar_id,
+                value.reminder_minutes,
+                value.last_reminded_occurrence,
+                value.created_at,
+                value.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async deleteByOwner(eventId, userId) {
+        return (changes((await this.database.query('DELETE FROM calendar_events WHERE id = $1 AND user_id = $2', [eventId, userId])).rowCount) > 0);
+    }
+}
+class PostgresCalendarRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM calendars
+        WHERE user_id = $1
+        ORDER BY created_at ASC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(calendar);
+    }
+    async findByOwner(calendarId, userId) {
+        const result = await this.database.query('SELECT * FROM calendars WHERE id = $1 AND user_id = $2', [calendarId, userId]);
+        return result.rows[0] ? calendar(result.rows[0]) : null;
+    }
+    async findById(calendarId) {
+        const result = await this.database.query('SELECT * FROM calendars WHERE id = $1', [calendarId]);
+        return result.rows[0] ? calendar(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM calendars WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM calendars WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('calendar', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO calendars
+           (id, user_id, name, color, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           color = EXCLUDED.color,
+           updated_at = EXCLUDED.updated_at
+         WHERE calendars.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.name,
+                value.color,
+                value.created_at,
+                value.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async deleteAndDetach(calendarId, userId) {
+        return this.database.transaction(async (client) => {
+            const deleted = changes((await client.query('DELETE FROM calendars WHERE id = $1 AND user_id = $2', [calendarId, userId])).rowCount) > 0;
+            if (deleted) {
+                await client.query(`UPDATE calendar_events
+            SET calendar_id = NULL
+            WHERE calendar_id = $1 AND user_id = $2`, [calendarId, userId]);
+            }
+            return deleted;
+        });
+    }
+}
+class PostgresChannelRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertWithOwner(value, owner, maximumPerUser) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, owner.user_id);
+            const count = await client.query('SELECT COUNT(*)::text AS count FROM channels WHERE created_by = $1', [owner.user_id]);
+            if (Number(count.rows[0]?.count || 0) >= maximumPerUser) {
+                throw new PersistenceResourceLimitError('channel', maximumPerUser);
+            }
+            await client.query(`INSERT INTO channels
+           (id, type, name, description, dm_key, created_by,
+            created_at, updated_at, archived_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [
+                value.id,
+                value.type,
+                value.name,
+                value.description,
+                value.dm_key,
+                value.created_by,
+                value.created_at,
+                value.updated_at,
+                value.archived_at,
+            ]);
+            await client.query(`INSERT INTO channel_members
+           (channel_id, user_id, role, joined_at, last_read_at)
+         VALUES ($1, $2, $3, $4, $5)`, [
+                owner.channel_id,
+                owner.user_id,
+                owner.role,
+                owner.joined_at,
+                owner.last_read_at,
+            ]);
+        });
+    }
+    async findById(channelId) {
+        const result = await this.database.query('SELECT * FROM channels WHERE id = $1', [channelId]);
+        return result.rows[0] ? channel(result.rows[0]) : null;
+    }
+    async findByDmKey(dmKey) {
+        const result = await this.database.query('SELECT * FROM channels WHERE dm_key = $1', [dmKey]);
+        return result.rows[0] ? channel(result.rows[0]) : null;
+    }
+    async listForUser(userId, maximum) {
+        const result = await this.database.query(`SELECT
+         c.id, c.type, c.name, c.description, c.dm_key, c.created_by,
+         c.created_at, c.updated_at, c.archived_at,
+         m.channel_id AS member_channel_id, m.user_id AS member_user_id,
+         m.role AS member_role, m.joined_at AS member_joined_at,
+         m.last_read_at AS member_last_read_at
+       FROM channel_members m
+       JOIN channels c ON c.id = m.channel_id
+       WHERE m.user_id = $1
+       ORDER BY c.updated_at DESC
+       LIMIT $2`, [userId, maximum]);
+        return result.rows.map(row => ({
+            channel: channel(row),
+            member: channelMember({
+                channel_id: row.member_channel_id,
+                user_id: row.member_user_id,
+                role: row.member_role,
+                joined_at: row.member_joined_at,
+                last_read_at: row.member_last_read_at,
+            }),
+        }));
+    }
+    async listPublic(maximum) {
+        const result = await this.database.query(`SELECT * FROM channels
+        WHERE type = 'public' AND archived_at IS NULL
+        ORDER BY updated_at DESC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(channel);
+    }
+    async update(value) {
+        await this.database.query(`UPDATE channels SET
+         name = $1,
+         description = $2,
+         updated_at = $3,
+         archived_at = $4
+       WHERE id = $5`, [
+            value.name,
+            value.description,
+            value.updated_at,
+            value.archived_at,
+            value.id,
+        ]);
+    }
+    async delete(channelId) {
+        return (changes((await this.database.query('DELETE FROM channels WHERE id = $1', [
+            channelId,
+        ])).rowCount) > 0);
+    }
+    async upsertMember(member, maximumMembers) {
+        await this.database.transaction(async (client) => {
+            const existing = await client.query(`SELECT 1 FROM channel_members
+          WHERE channel_id = $1 AND user_id = $2
+          FOR UPDATE`, [member.channel_id, member.user_id]);
+            if (!existing.rows[0]) {
+                const count = await client.query(`SELECT COUNT(*)::text AS count FROM channel_members
+            WHERE channel_id = $1`, [member.channel_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximumMembers) {
+                    throw new PersistenceResourceLimitError('channel-member', maximumMembers);
+                }
+            }
+            await client.query(`INSERT INTO channel_members
+           (channel_id, user_id, role, joined_at, last_read_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (channel_id, user_id) DO UPDATE SET
+           role = EXCLUDED.role`, [
+                member.channel_id,
+                member.user_id,
+                member.role,
+                member.joined_at,
+                member.last_read_at,
+            ]);
+        });
+    }
+    async findMember(channelId, userId) {
+        const result = await this.database.query('SELECT * FROM channel_members WHERE channel_id = $1 AND user_id = $2', [channelId, userId]);
+        return result.rows[0] ? channelMember(result.rows[0]) : null;
+    }
+    async listMembers(channelId, maximum) {
+        const result = await this.database.query(`SELECT * FROM channel_members
+        WHERE channel_id = $1
+        ORDER BY joined_at ASC
+        LIMIT $2`, [channelId, maximum]);
+        return result.rows.map(channelMember);
+    }
+    async removeMember(channelId, userId) {
+        return (changes((await this.database.query('DELETE FROM channel_members WHERE channel_id = $1 AND user_id = $2', [channelId, userId])).rowCount) > 0);
+    }
+    async advanceLastRead(channelId, userId, lastReadAt) {
+        return (changes((await this.database.query(`UPDATE channel_members
+              SET last_read_at = $1
+              WHERE channel_id = $2 AND user_id = $3 AND last_read_at < $1`, [lastReadAt, channelId, userId])).rowCount) > 0);
+    }
+    async unreadSummaryForUser(userId) {
+        const result = await this.database.query(`SELECT
+         m.channel_id,
+         COUNT(msg.id)::text AS unread_count,
+         MAX(msg.created_at) AS latest_message_at
+       FROM channel_members m
+       LEFT JOIN channel_messages msg
+         ON msg.channel_id = m.channel_id
+        AND msg.created_at > m.last_read_at
+        AND msg.deleted_at IS NULL
+        AND (msg.user_id IS NULL OR msg.user_id != m.user_id
+             OR msg.author_kind != 'user')
+       WHERE m.user_id = $1
+       GROUP BY m.channel_id`, [userId]);
+        return result.rows.map(row => ({
+            channel_id: row.channel_id,
+            unread_count: number(row.unread_count, 'channel unread_count'),
+            latest_message_at: row.latest_message_at === null
+                ? null
+                : number(row.latest_message_at, 'channel latest_message_at'),
+        }));
+    }
+}
+class PostgresChannelMessageRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertIfAbsent(message, attachments, maximumPerChannel) {
+        return this.database.transaction(async (client) => {
+            const existing = await client.query('SELECT * FROM channel_messages WHERE id = $1', [message.id]);
+            if (existing.rows[0]) {
+                return { stored: channelMessage(existing.rows[0]), inserted: false };
+            }
+            const count = await client.query(`SELECT COUNT(*)::text AS count FROM channel_messages
+          WHERE channel_id = $1`, [message.channel_id]);
+            if (Number(count.rows[0]?.count || 0) >= maximumPerChannel) {
+                throw new PersistenceResourceLimitError('channel-message', maximumPerChannel);
+            }
+            await client.query(`INSERT INTO channel_messages
+           (id, channel_id, user_id, parent_id, author_kind, model, content,
+            metadata, created_at, updated_at, edited_at, deleted_at,
+            pinned_at, pinned_by)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)`, [
+                message.id,
+                message.channel_id,
+                message.user_id,
+                message.parent_id,
+                message.author_kind,
+                message.model,
+                message.content,
+                message.metadata,
+                message.created_at,
+                message.updated_at,
+                message.edited_at,
+                message.deleted_at,
+                message.pinned_at,
+                message.pinned_by,
+            ]);
+            for (const attachment of attachments) {
+                if (attachment.message_id !== message.id) {
+                    throw new Error('A channel attachment does not belong to its message');
+                }
+                await client.query(`INSERT INTO channel_attachments
+             (id, message_id, channel_id, blob_id, filename, content_type,
+              size, created_by, created_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [
+                    attachment.id,
+                    attachment.message_id,
+                    attachment.channel_id,
+                    attachment.blob_id,
+                    attachment.filename,
+                    attachment.content_type,
+                    attachment.size,
+                    attachment.created_by,
+                    attachment.created_at,
+                ]);
+            }
+            await client.query('UPDATE channels SET updated_at = $1 WHERE id = $2', [
+                message.created_at,
+                message.channel_id,
+            ]);
+            return { stored: message, inserted: true };
+        });
+    }
+    async findById(messageId) {
+        const result = await this.database.query('SELECT * FROM channel_messages WHERE id = $1', [messageId]);
+        return result.rows[0] ? channelMessage(result.rows[0]) : null;
+    }
+    async listPage(channelId, options) {
+        const clauses = ['channel_id = $1'];
+        const parameters = [channelId];
+        if (options.parentId === null) {
+            clauses.push('parent_id IS NULL');
+        }
+        else if (options.parentId !== undefined) {
+            parameters.push(options.parentId);
+            clauses.push(`parent_id = $${parameters.length}`);
+        }
+        if (options.before) {
+            parameters.push(options.before.created_at);
+            const createdIndex = parameters.length;
+            parameters.push(options.before.id);
+            clauses.push(`(created_at < $${createdIndex} OR ` +
+                `(created_at = $${createdIndex} AND id < $${parameters.length}))`);
+        }
+        if (options.after) {
+            parameters.push(options.after.created_at);
+            const createdIndex = parameters.length;
+            parameters.push(options.after.id);
+            clauses.push(`(created_at > $${createdIndex} OR ` +
+                `(created_at = $${createdIndex} AND id > $${parameters.length}))`);
+        }
+        const direction = options.after ? 'ASC' : 'DESC';
+        parameters.push(options.limit);
+        const result = await this.database.query(`SELECT * FROM channel_messages
+        WHERE ${clauses.join(' AND ')}
+        ORDER BY created_at ${direction}, id ${direction}
+        LIMIT $${parameters.length}`, parameters);
+        return result.rows.map(channelMessage);
+    }
+    async listThread(parentId, maximum) {
+        const result = await this.database.query(`SELECT * FROM channel_messages
+        WHERE parent_id = $1
+        ORDER BY created_at ASC, id ASC
+        LIMIT $2`, [parentId, maximum]);
+        return result.rows.map(channelMessage);
+    }
+    async countThreadReplies(parentIds) {
+        if (parentIds.length === 0)
+            return {};
+        const result = await this.database.query(`SELECT parent_id, COUNT(*)::text AS count
+        FROM channel_messages
+        WHERE parent_id = ANY($1::text[]) AND deleted_at IS NULL
+        GROUP BY parent_id`, [[...parentIds]]);
+        const counts = {};
+        for (const row of result.rows) {
+            counts[row.parent_id] = number(row.count, 'channel thread reply count');
+        }
+        return counts;
+    }
+    async update(message) {
+        await this.database.query(`UPDATE channel_messages SET
+         content = $1,
+         metadata = $2,
+         updated_at = $3,
+         edited_at = $4,
+         deleted_at = $5,
+         pinned_at = $6,
+         pinned_by = $7
+       WHERE id = $8`, [
+            message.content,
+            message.metadata,
+            message.updated_at,
+            message.edited_at,
+            message.deleted_at,
+            message.pinned_at,
+            message.pinned_by,
+            message.id,
+        ]);
+    }
+    async listPinned(channelId, maximum) {
+        const result = await this.database.query(`SELECT * FROM channel_messages
+        WHERE channel_id = $1 AND pinned_at IS NOT NULL
+          AND deleted_at IS NULL
+        ORDER BY pinned_at DESC
+        LIMIT $2`, [channelId, maximum]);
+        return result.rows.map(channelMessage);
+    }
+    async listRecentForChannels(channelIds, maximum) {
+        if (channelIds.length === 0)
+            return [];
+        const result = await this.database.query(`SELECT * FROM channel_messages
+        WHERE channel_id = ANY($1::text[]) AND deleted_at IS NULL
+        ORDER BY created_at DESC
+        LIMIT $2`, [[...channelIds], maximum]);
+        return result.rows.map(channelMessage);
+    }
+    async addReaction(reaction, maximumPerMessage) {
+        return this.database.transaction(async (client) => {
+            const existing = await client.query(`SELECT 1 FROM channel_reactions
+          WHERE message_id = $1 AND user_id = $2 AND emoji = $3`, [reaction.message_id, reaction.user_id, reaction.emoji]);
+            if (existing.rows[0])
+                return false;
+            const count = await client.query(`SELECT COUNT(*)::text AS count FROM channel_reactions
+          WHERE message_id = $1`, [reaction.message_id]);
+            if (Number(count.rows[0]?.count || 0) >= maximumPerMessage) {
+                throw new PersistenceResourceLimitError('channel-reaction', maximumPerMessage);
+            }
+            const result = await client.query(`INSERT INTO channel_reactions
+           (id, message_id, user_id, emoji, created_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (message_id, user_id, emoji) DO NOTHING`, [
+                reaction.id,
+                reaction.message_id,
+                reaction.user_id,
+                reaction.emoji,
+                reaction.created_at,
+            ]);
+            return changes(result.rowCount) > 0;
+        });
+    }
+    async removeReaction(messageId, userId, emoji) {
+        return (changes((await this.database.query(`DELETE FROM channel_reactions
+              WHERE message_id = $1 AND user_id = $2 AND emoji = $3`, [messageId, userId, emoji])).rowCount) > 0);
+    }
+    async listReactionsForMessages(messageIds) {
+        if (messageIds.length === 0)
+            return [];
+        const result = await this.database.query(`SELECT * FROM channel_reactions
+        WHERE message_id = ANY($1::text[])
+        ORDER BY created_at ASC`, [[...messageIds]]);
+        return result.rows.map(channelReaction);
+    }
+    async findAttachment(attachmentId) {
+        const result = await this.database.query('SELECT * FROM channel_attachments WHERE id = $1', [attachmentId]);
+        return result.rows[0] ? channelAttachment(result.rows[0]) : null;
+    }
+    async listAttachmentsForMessages(messageIds) {
+        if (messageIds.length === 0)
+            return [];
+        const result = await this.database.query(`SELECT * FROM channel_attachments
+        WHERE message_id = ANY($1::text[])
+        ORDER BY created_at ASC`, [[...messageIds]]);
+        return result.rows.map(channelAttachment);
+    }
+    async listAttachmentBlobIds(channelId) {
+        const result = await this.database.query('SELECT blob_id, created_by FROM channel_attachments WHERE channel_id = $1', [channelId]);
+        return result.rows;
+    }
+}
+class PostgresNotificationRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertWithLimit(value, maximumPerUser) {
+        return this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const result = await client.query(`INSERT INTO notifications
+           (id, user_id, type, title, body, href, source_key,
+            created_at, read_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+         ON CONFLICT (user_id, source_key) DO NOTHING`, [
+                value.id,
+                value.user_id,
+                value.type,
+                value.title,
+                value.body,
+                value.href,
+                value.source_key,
+                value.created_at,
+                value.read_at,
+            ]);
+            if (changes(result.rowCount) === 0)
+                return false;
+            await client.query(`DELETE FROM notifications
+          WHERE user_id = $1
+            AND id NOT IN (
+              SELECT id FROM notifications
+              WHERE user_id = $1
+              ORDER BY created_at DESC, id DESC
+              LIMIT $2
+            )`, [value.user_id, maximumPerUser]);
+            return true;
+        });
+    }
+    async listByOwner(userId, options) {
+        const clauses = ['user_id = $1'];
+        const parameters = [userId];
+        if (options.before !== undefined) {
+            parameters.push(options.before);
+            clauses.push(`created_at < $${parameters.length}`);
+        }
+        if (options.unreadOnly) {
+            clauses.push('read_at IS NULL');
+        }
+        parameters.push(options.limit);
+        const result = await this.database.query(`SELECT * FROM notifications
+        WHERE ${clauses.join(' AND ')}
+        ORDER BY created_at DESC, id DESC
+        LIMIT $${parameters.length}`, parameters);
+        return result.rows.map(notification);
+    }
+    async countUnread(userId) {
+        const result = await this.database.query(`SELECT COUNT(*)::text AS count FROM notifications
+        WHERE user_id = $1 AND read_at IS NULL`, [userId]);
+        return Number(result.rows[0]?.count || 0);
+    }
+    async markRead(notificationId, userId, readAt) {
+        return (changes((await this.database.query(`UPDATE notifications SET read_at = $1
+              WHERE id = $2 AND user_id = $3 AND read_at IS NULL`, [readAt, notificationId, userId])).rowCount) > 0);
+    }
+    async markAllRead(userId, readAt) {
+        return changes((await this.database.query(`UPDATE notifications SET read_at = $1
+            WHERE user_id = $2 AND read_at IS NULL`, [readAt, userId])).rowCount);
+    }
+    async deleteByOwner(notificationId, userId) {
+        return (changes((await this.database.query('DELETE FROM notifications WHERE id = $1 AND user_id = $2', [notificationId, userId])).rowCount) > 0);
+    }
+}
+class PostgresWebhookTargetRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async list(maximum) {
+        const result = await this.database.query('SELECT * FROM webhook_targets ORDER BY created_at ASC LIMIT $1', [maximum]);
+        return result.rows.map(webhookTarget);
+    }
+    async findById(targetId) {
+        const result = await this.database.query('SELECT * FROM webhook_targets WHERE id = $1', [targetId]);
+        return result.rows[0] ? webhookTarget(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            const existing = await client.query('SELECT 1 FROM webhook_targets WHERE id = $1 FOR UPDATE', [value.id]);
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM webhook_targets');
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('webhook-target', maximum);
+                }
+            }
+            await client.query(`INSERT INTO webhook_targets
+           (id, name, url, secret, events, enabled, created_by,
+            created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           url = EXCLUDED.url,
+           secret = EXCLUDED.secret,
+           events = EXCLUDED.events,
+           enabled = EXCLUDED.enabled,
+           updated_at = EXCLUDED.updated_at`, [
+                value.id,
+                value.name,
+                value.url,
+                value.secret,
+                value.events,
+                value.enabled,
+                value.created_by,
+                value.created_at,
+                value.updated_at,
+            ]);
+        });
+    }
+    async delete(targetId) {
+        return (changes((await this.database.query('DELETE FROM webhook_targets WHERE id = $1', [targetId])).rowCount) > 0);
+    }
+}
+class PostgresAutomationRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM automations
+        WHERE user_id = $1
+        ORDER BY updated_at DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(automation);
+    }
+    async findByOwner(automationId, userId) {
+        const result = await this.database.query('SELECT * FROM automations WHERE id = $1 AND user_id = $2', [automationId, userId]);
+        return result.rows[0] ? automation(result.rows[0]) : null;
+    }
+    async findById(automationId) {
+        const result = await this.database.query('SELECT * FROM automations WHERE id = $1', [automationId]);
+        return result.rows[0] ? automation(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM automations WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM automations WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('automation', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO automations
+           (id, user_id, name, instructions, triggers, provider, model,
+            notify, status, next_run_at, last_run_at, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           instructions = EXCLUDED.instructions,
+           triggers = EXCLUDED.triggers,
+           provider = EXCLUDED.provider,
+           model = EXCLUDED.model,
+           notify = EXCLUDED.notify,
+           status = EXCLUDED.status,
+           next_run_at = EXCLUDED.next_run_at,
+           last_run_at = EXCLUDED.last_run_at,
+           updated_at = EXCLUDED.updated_at
+         WHERE automations.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.name,
+                value.instructions,
+                value.triggers,
+                value.provider,
+                value.model,
+                value.notify,
+                value.status,
+                value.next_run_at,
+                value.last_run_at,
+                value.created_at,
+                value.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async listDue(now, maximum) {
+        const result = await this.database.query(`SELECT * FROM automations
+        WHERE status = 'active'
+          AND next_run_at IS NOT NULL
+          AND next_run_at <= $1
+        ORDER BY next_run_at ASC
+        LIMIT $2`, [now, maximum]);
+        return result.rows.map(automation);
+    }
+    async advanceNextRun(automationId, observedNextRunAt, nextRunAt, lastRunAt) {
+        return (changes((await this.database.query(`UPDATE automations
+              SET next_run_at = $1, last_run_at = $2
+              WHERE id = $3 AND next_run_at = $4`, [nextRunAt, lastRunAt, automationId, observedNextRunAt])).rowCount) > 0);
+    }
+    async setStatus(automationId, userId, status, nextRunAt, updatedAt) {
+        return (changes((await this.database.query(`UPDATE automations
+              SET status = $1, next_run_at = $2, updated_at = $3
+              WHERE id = $4 AND user_id = $5`, [status, nextRunAt, updatedAt, automationId, userId])).rowCount) > 0);
+    }
+    async deleteByOwner(automationId, userId) {
+        return (changes((await this.database.query('DELETE FROM automations WHERE id = $1 AND user_id = $2', [automationId, userId])).rowCount) > 0);
+    }
+}
+class PostgresAutomationRunRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insert(run) {
+        await this.database.query(`INSERT INTO automation_runs
+         (id, automation_id, user_id, scheduled_for, started_at, finished_at,
+          status, session_id, assistant_message_id, error, seen_at, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+            run.id,
+            run.automation_id,
+            run.user_id,
+            run.scheduled_for,
+            run.started_at,
+            run.finished_at,
+            run.status,
+            run.session_id,
+            run.assistant_message_id,
+            run.error,
+            run.seen_at,
+            run.created_at,
+        ]);
+    }
+    async findByOwner(runId, userId) {
+        const result = await this.database.query('SELECT * FROM automation_runs WHERE id = $1 AND user_id = $2', [runId, userId]);
+        return result.rows[0] ? automationRun(result.rows[0]) : null;
+    }
+    async listByOwner(userId, options) {
+        const clauses = ['user_id = $1'];
+        const values = [userId];
+        if (options.automationId !== undefined) {
+            values.push(options.automationId);
+            clauses.push(`automation_id = $${values.length}`);
+        }
+        if (options.from !== undefined) {
+            values.push(options.from);
+            clauses.push(`scheduled_for >= $${values.length}`);
+        }
+        if (options.to !== undefined) {
+            values.push(options.to);
+            clauses.push(`scheduled_for < $${values.length}`);
+        }
+        values.push(options.maximum);
+        const result = await this.database.query(`SELECT * FROM automation_runs
+        WHERE ${clauses.join(' AND ')}
+        ORDER BY scheduled_for DESC
+        LIMIT $${values.length}`, values);
+        return result.rows.map(automationRun);
+    }
+    async listUnfinished(maximum) {
+        const result = await this.database.query(`SELECT * FROM automation_runs
+        WHERE status IN ('queued', 'running')
+        ORDER BY scheduled_for ASC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(automationRun);
+    }
+    async markStarted(runId, sessionId, assistantMessageId, startedAt) {
+        return (changes((await this.database.query(`UPDATE automation_runs
+              SET session_id = $1, assistant_message_id = $2, started_at = $3,
+                  status = 'running'
+              WHERE id = $4 AND status = 'queued'`, [sessionId, assistantMessageId, startedAt, runId])).rowCount) > 0);
+    }
+    async finalize(runId, status, finishedAt, error) {
+        return (changes((await this.database.query(`UPDATE automation_runs
+              SET status = $1, finished_at = $2, error = $3
+              WHERE id = $4 AND status IN ('queued', 'running')`, [status, finishedAt, error, runId])).rowCount) > 0);
+    }
+    async countUnseenFinished(userId) {
+        const result = await this.database.query(`SELECT COUNT(*)::text AS count FROM automation_runs
+        WHERE user_id = $1
+          AND status IN ('succeeded', 'failed')
+          AND seen_at IS NULL`, [userId]);
+        return Number(result.rows[0]?.count || 0);
+    }
+    async markSeenBefore(userId, seenAt) {
+        return changes((await this.database.query(`UPDATE automation_runs
+            SET seen_at = $1
+            WHERE user_id = $2
+              AND status IN ('succeeded', 'failed')
+              AND seen_at IS NULL
+              AND finished_at IS NOT NULL
+              AND finished_at <= $3`, [seenAt, userId, seenAt])).rowCount);
+    }
+}
+class PostgresToolServerRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async list(maximum) {
+        const result = await this.database.query(`SELECT * FROM tool_servers
+        ORDER BY updated_at DESC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(toolServer);
+    }
+    async findById(serverId) {
+        const result = await this.database.query('SELECT * FROM tool_servers WHERE id = $1', [serverId]);
+        return result.rows[0] ? toolServer(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT id FROM tool_servers WHERE id = $1 FOR UPDATE', [value.id]);
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM tool_servers');
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('tool-server', maximum);
+                }
+            }
+            await client.query(`INSERT INTO tool_servers
+           (id, user_id, name, description, kind, base_url, spec, spec_digest,
+            spec_revision, auth_mode, auth_header, access_mode, enabled,
+            timeout_ms, max_response_bytes, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14,
+                 $15, $16, $17)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           description = EXCLUDED.description,
+           base_url = EXCLUDED.base_url,
+           spec = EXCLUDED.spec,
+           spec_digest = EXCLUDED.spec_digest,
+           spec_revision = EXCLUDED.spec_revision,
+           auth_mode = EXCLUDED.auth_mode,
+           auth_header = EXCLUDED.auth_header,
+           access_mode = EXCLUDED.access_mode,
+           enabled = EXCLUDED.enabled,
+           timeout_ms = EXCLUDED.timeout_ms,
+           max_response_bytes = EXCLUDED.max_response_bytes,
+           updated_at = EXCLUDED.updated_at`, [
+                value.id,
+                value.user_id,
+                value.name,
+                value.description,
+                value.kind,
+                value.base_url,
+                value.spec,
+                value.spec_digest,
+                value.spec_revision,
+                value.auth_mode,
+                value.auth_header,
+                value.access_mode,
+                value.enabled,
+                value.timeout_ms,
+                value.max_response_bytes,
+                value.created_at,
+                value.updated_at,
+            ]);
+        });
+    }
+    async delete(serverId) {
+        return (changes((await this.database.query('DELETE FROM tool_servers WHERE id = $1', [
+            serverId,
+        ])).rowCount) > 0);
+    }
+}
+class PostgresToolServerToolRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByServer(serverId) {
+        const result = await this.database.query(`SELECT * FROM tool_server_tools
+        WHERE server_id = $1
+        ORDER BY name ASC`, [serverId]);
+        return result.rows.map(toolServerTool);
+    }
+    async replaceAllForServer(serverId, tools) {
+        await this.database.transaction(async (client) => {
+            const previousResult = await client.query(`SELECT name, enabled, side_effect FROM tool_server_tools
+          WHERE server_id = $1 FOR UPDATE`, [serverId]);
+            const previous = new Map(previousResult.rows.map(row => [
+                row.name,
+                {
+                    enabled: number(row.enabled, 'tool enabled'),
+                    side_effect: number(row.side_effect, 'tool side_effect'),
+                },
+            ]));
+            await client.query('DELETE FROM tool_server_tools WHERE server_id = $1', [
+                serverId,
+            ]);
+            for (const tool of tools) {
+                if (tool.server_id !== serverId) {
+                    throw new Error('A tool row does not belong to its server');
+                }
+                const kept = previous.get(tool.name);
+                await client.query(`INSERT INTO tool_server_tools
+             (id, server_id, name, description, params_schema, detail,
+              side_effect, enabled, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`, [
+                    tool.id,
+                    tool.server_id,
+                    tool.name,
+                    tool.description,
+                    tool.params_schema,
+                    tool.detail,
+                    kept ? kept.side_effect : tool.side_effect,
+                    kept ? kept.enabled : tool.enabled,
+                    tool.created_at,
+                    tool.updated_at,
+                ]);
+            }
+        });
     }
-    async deleteByOwner(sessionId, userId, beforeCommit) {
-        return this.database.transaction(async (client) => changes((await client.query('DELETE FROM sessions WHERE id = $1 AND user_id = $2', [sessionId, userId])).rowCount) > 0, { isolationLevel: 'serializable', beforeCommit });
+    async updateOverrides(serverId, toolName, overrides, updatedAt) {
+        const assignments = ['updated_at = $1'];
+        const values = [updatedAt];
+        if (overrides.enabled !== undefined) {
+            values.push(overrides.enabled);
+            assignments.push(`enabled = $${values.length}`);
+        }
+        if (overrides.side_effect !== undefined) {
+            values.push(overrides.side_effect);
+            assignments.push(`side_effect = $${values.length}`);
+        }
+        values.push(serverId, toolName);
+        const result = await this.database.query(`UPDATE tool_server_tools
+        SET ${assignments.join(', ')}
+        WHERE server_id = $${values.length - 1} AND name = $${values.length}
+        RETURNING *`, values);
+        return result.rows[0] ? toolServerTool(result.rows[0]) : null;
     }
-    async deleteAllByOwner(userId) {
-        return changes((await this.database.query('DELETE FROM sessions WHERE user_id = $1', [
-            userId,
-        ])).rowCount);
+}
+class PostgresToolServerCredentialRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async find(serverId, userId) {
+        const result = await this.database.query(`SELECT * FROM tool_server_credentials
+        WHERE server_id = $1 AND user_id = $2`, [serverId, userId]);
+        return result.rows[0] ? toolServerCredential(result.rows[0]) : null;
+    }
+    async upsert(credential) {
+        await this.database.query(`INSERT INTO tool_server_credentials
+         (id, server_id, user_id, secret, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (server_id, user_id) DO UPDATE SET
+         secret = EXCLUDED.secret,
+         updated_at = EXCLUDED.updated_at`, [
+            credential.id,
+            credential.server_id,
+            credential.user_id,
+            credential.secret,
+            credential.created_at,
+            credential.updated_at,
+        ]);
+    }
+    async delete(serverId, userId) {
+        return (changes((await this.database.query(`DELETE FROM tool_server_credentials
+              WHERE server_id = $1 AND user_id = $2`, [serverId, userId])).rowCount) > 0);
     }
 }
-class PostgresKnowledgeCollectionRepository {
+class PostgresToolApprovalRepository {
     constructor(database) {
         this.database = database;
     }
-    async listByOwner(userId) {
-        const result = await this.database.query(`SELECT * FROM knowledge_collections
+    async insert(approval) {
+        await this.database.query(`INSERT INTO tool_approvals
+         (id, user_id, session_id, server_id, tool_name, call_id,
+          arguments_digest, scope, status, created_at, resolved_at, expires_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+            approval.id,
+            approval.user_id,
+            approval.session_id,
+            approval.server_id,
+            approval.tool_name,
+            approval.call_id,
+            approval.arguments_digest,
+            approval.scope,
+            approval.status,
+            approval.created_at,
+            approval.resolved_at,
+            approval.expires_at,
+        ]);
+    }
+    async findByOwner(approvalId, userId) {
+        const result = await this.database.query('SELECT * FROM tool_approvals WHERE id = $1 AND user_id = $2', [approvalId, userId]);
+        return result.rows[0] ? toolApproval(result.rows[0]) : null;
+    }
+    async findStanding(userId, serverId, toolName, sessionId) {
+        const result = await this.database.query(`SELECT * FROM tool_approvals
         WHERE user_id = $1
-        ORDER BY lower(name), name`, [userId]);
-        return result.rows.map(namedResource);
+          AND status = 'approved'
+          AND tool_name = $2
+          AND ((server_id IS NULL AND $3::text IS NULL) OR server_id = $3)
+          AND (scope = 'always'
+               OR (scope = 'session' AND session_id IS NOT NULL AND session_id = $4))
+        ORDER BY resolved_at DESC
+        LIMIT 1`, [userId, toolName, serverId, sessionId]);
+        return result.rows[0] ? toolApproval(result.rows[0]) : null;
     }
-    async replace(collection) {
+    async resolvePending(approvalId, userId, status, scope, resolvedAt) {
+        const result = await this.database.query(`UPDATE tool_approvals
+        SET status = $1, scope = $2, resolved_at = $3
+        WHERE id = $4 AND user_id = $5 AND status = 'pending'
+          AND (expires_at IS NULL OR expires_at > $3)
+        RETURNING *`, [status, scope, resolvedAt, approvalId, userId]);
+        return result.rows[0] ? toolApproval(result.rows[0]) : null;
+    }
+    async listPendingByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM tool_approvals
+        WHERE user_id = $1 AND status = 'pending'
+        ORDER BY created_at ASC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(toolApproval);
+    }
+    async listStandingByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM tool_approvals
+        WHERE user_id = $1 AND status = 'approved'
+          AND scope IN ('session', 'always')
+        ORDER BY resolved_at DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(toolApproval);
+    }
+    async expirePending(now) {
+        return changes((await this.database.query(`UPDATE tool_approvals
+            SET status = 'expired', resolved_at = $1
+            WHERE status = 'pending' AND expires_at IS NOT NULL
+              AND expires_at <= $1`, [now])).rowCount);
+    }
+    async deleteByOwner(approvalId, userId) {
+        return (changes((await this.database.query('DELETE FROM tool_approvals WHERE id = $1 AND user_id = $2', [approvalId, userId])).rowCount) > 0);
+    }
+}
+class PostgresPromptRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM prompts
+        WHERE user_id = $1
+        ORDER BY updated_at DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(prompt);
+    }
+    async findByOwner(promptId, userId) {
+        const result = await this.database.query('SELECT * FROM prompts WHERE id = $1 AND user_id = $2', [promptId, userId]);
+        return result.rows[0] ? prompt(result.rows[0]) : null;
+    }
+    async findById(promptId) {
+        const result = await this.database.query('SELECT * FROM prompts WHERE id = $1', [promptId]);
+        return result.rows[0] ? prompt(result.rows[0]) : null;
+    }
+    async findBySlug(userId, slug) {
+        const result = await this.database.query('SELECT * FROM prompts WHERE user_id = $1 AND slug = $2', [userId, slug]);
+        return result.rows[0] ? prompt(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum, archivedVersion) {
         await this.database.transaction(async (client) => {
-            await lockOwner(client, collection.user_id);
-            const result = await client.query(`INSERT INTO knowledge_collections
-           (id, user_id, name, created_at, updated_at)
-         VALUES ($1, $2, $3, $4, $5)
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM prompts WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM prompts WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('prompt', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO prompts
+           (id, user_id, slug, title, description, content, variables, tags,
+            version, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
          ON CONFLICT (id) DO UPDATE SET
-           name = EXCLUDED.name,
+           slug = EXCLUDED.slug,
+           title = EXCLUDED.title,
+           description = EXCLUDED.description,
+           content = EXCLUDED.content,
+           variables = EXCLUDED.variables,
+           tags = EXCLUDED.tags,
+           version = EXCLUDED.version,
            updated_at = EXCLUDED.updated_at
-         WHERE knowledge_collections.user_id = EXCLUDED.user_id`, [
-                collection.id,
-                collection.user_id,
-                collection.name,
-                collection.created_at,
-                collection.updated_at,
+         WHERE prompts.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.slug,
+                value.title,
+                value.description,
+                value.content,
+                value.variables,
+                value.tags,
+                value.version,
+                value.created_at,
+                value.updated_at,
             ]);
             if (result.rowCount !== 1)
                 throw new PersistenceResourceConflictError();
+            if (archivedVersion) {
+                await client.query(`INSERT INTO prompt_versions
+             (id, prompt_id, version, content, variables, created_at)
+           VALUES ($1, $2, $3, $4, $5, $6)
+           ON CONFLICT (prompt_id, version) DO NOTHING`, [
+                    archivedVersion.id,
+                    archivedVersion.prompt_id,
+                    archivedVersion.version,
+                    archivedVersion.content,
+                    archivedVersion.variables,
+                    archivedVersion.created_at,
+                ]);
+            }
         });
     }
-    async deleteAndDetach(collectionId, userId) {
-        return (changes((await this.database.query('DELETE FROM knowledge_collections WHERE id = $1 AND user_id = $2', [collectionId, userId])).rowCount) > 0);
+    async listVersions(promptId, maximum) {
+        const result = await this.database.query(`SELECT * FROM prompt_versions
+        WHERE prompt_id = $1
+        ORDER BY version DESC
+        LIMIT $2`, [promptId, maximum]);
+        return result.rows.map(promptVersion);
+    }
+    async findVersion(promptId, version) {
+        const result = await this.database.query('SELECT * FROM prompt_versions WHERE prompt_id = $1 AND version = $2', [promptId, version]);
+        return result.rows[0] ? promptVersion(result.rows[0]) : null;
+    }
+    async deleteByOwner(promptId, userId) {
+        return (changes((await this.database.query('DELETE FROM prompts WHERE id = $1 AND user_id = $2', [promptId, userId])).rowCount) > 0);
     }
 }
-class PostgresNoteRepository {
+class PostgresSkillRepository {
     constructor(database) {
         this.database = database;
     }
     async listByOwner(userId, maximum) {
-        const result = await this.database.query(`SELECT * FROM notes
+        const result = await this.database.query(`SELECT * FROM skills
         WHERE user_id = $1
         ORDER BY updated_at DESC
         LIMIT $2`, [userId, maximum]);
-        return result.rows.map(note);
+        return result.rows.map(skill);
     }
-    async findByOwner(noteId, userId) {
-        const result = await this.database.query('SELECT * FROM notes WHERE id = $1 AND user_id = $2', [noteId, userId]);
-        return result.rows[0] ? note(result.rows[0]) : null;
+    async findByOwner(skillId, userId) {
+        const result = await this.database.query('SELECT * FROM skills WHERE id = $1 AND user_id = $2', [skillId, userId]);
+        return result.rows[0] ? skill(result.rows[0]) : null;
     }
-    async replaceWithLimit(value, maximum) {
+    async findById(skillId) {
+        const result = await this.database.query('SELECT * FROM skills WHERE id = $1', [skillId]);
+        return result.rows[0] ? skill(result.rows[0]) : null;
+    }
+    async findBySlug(userId, slug) {
+        const result = await this.database.query('SELECT * FROM skills WHERE user_id = $1 AND slug = $2', [userId, slug]);
+        return result.rows[0] ? skill(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum, archivedVersion) {
         await this.database.transaction(async (client) => {
             await lockOwner(client, value.user_id);
-            const existing = await client.query('SELECT user_id FROM notes WHERE id = $1 FOR UPDATE', [value.id]);
+            const existing = await client.query('SELECT user_id FROM skills WHERE id = $1 FOR UPDATE', [value.id]);
             if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
                 throw new PersistenceResourceConflictError();
             }
             if (!existing.rows[0]) {
-                const count = await client.query('SELECT COUNT(*)::text AS count FROM notes WHERE user_id = $1', [value.user_id]);
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM skills WHERE user_id = $1', [value.user_id]);
                 if (Number(count.rows[0]?.count || 0) >= maximum) {
-                    throw new PersistenceResourceLimitError('note', maximum);
+                    throw new PersistenceResourceLimitError('skill', maximum);
                 }
             }
-            const result = await client.query(`INSERT INTO notes (id, user_id, title, content, created_at, updated_at)
-         VALUES ($1, $2, $3, $4, $5, $6)
+            const result = await client.query(`INSERT INTO skills
+           (id, user_id, slug, name, description, instructions, enabled,
+            version, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
          ON CONFLICT (id) DO UPDATE SET
-           title = EXCLUDED.title,
-           content = EXCLUDED.content,
+           slug = EXCLUDED.slug,
+           name = EXCLUDED.name,
+           description = EXCLUDED.description,
+           instructions = EXCLUDED.instructions,
+           enabled = EXCLUDED.enabled,
+           version = EXCLUDED.version,
            updated_at = EXCLUDED.updated_at
-         WHERE notes.user_id = EXCLUDED.user_id`, [
+         WHERE skills.user_id = EXCLUDED.user_id`, [
                 value.id,
                 value.user_id,
-                value.title,
-                value.content,
+                value.slug,
+                value.name,
+                value.description,
+                value.instructions,
+                value.enabled,
+                value.version,
                 value.created_at,
                 value.updated_at,
             ]);
             if (result.rowCount !== 1)
                 throw new PersistenceResourceConflictError();
+            if (archivedVersion) {
+                await client.query(`INSERT INTO skill_versions
+             (id, skill_id, version, instructions, created_at)
+           VALUES ($1, $2, $3, $4, $5)
+           ON CONFLICT (skill_id, version) DO NOTHING`, [
+                    archivedVersion.id,
+                    archivedVersion.skill_id,
+                    archivedVersion.version,
+                    archivedVersion.instructions,
+                    archivedVersion.created_at,
+                ]);
+            }
         });
     }
-    async patchByOwner(noteId, userId, patch) {
-        const assignments = [];
-        const values = [];
-        const assign = (column, value) => {
-            values.push(value);
-            assignments.push(`${column} = $${values.length}`);
-        };
-        if (patch.title !== undefined)
-            assign('title', patch.title);
-        if (patch.content !== undefined)
-            assign('content', patch.content);
-        assign('updated_at', patch.updated_at);
-        values.push(noteId, userId);
-        const result = await this.database.query(`UPDATE notes SET ${assignments.join(', ')}
-        WHERE id = $${values.length - 1} AND user_id = $${values.length}
-        RETURNING *`, values);
-        return result.rows[0] ? note(result.rows[0]) : null;
+    async listVersions(skillId, maximum) {
+        const result = await this.database.query(`SELECT * FROM skill_versions
+        WHERE skill_id = $1
+        ORDER BY version DESC
+        LIMIT $2`, [skillId, maximum]);
+        return result.rows.map(skillVersion);
     }
-    async deleteByOwner(noteId, userId) {
-        return (changes((await this.database.query('DELETE FROM notes WHERE id = $1 AND user_id = $2', [noteId, userId])).rowCount) > 0);
+    async findVersion(skillId, version) {
+        const result = await this.database.query('SELECT * FROM skill_versions WHERE skill_id = $1 AND version = $2', [skillId, version]);
+        return result.rows[0] ? skillVersion(result.rows[0]) : null;
+    }
+    async deleteByOwner(skillId, userId) {
+        return (changes((await this.database.query('DELETE FROM skills WHERE id = $1 AND user_id = $2', [skillId, userId])).rowCount) > 0);
+    }
+}
+class PostgresSkillFileRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listBySkill(skillId) {
+        const result = await this.database.query(`SELECT * FROM skill_files
+        WHERE skill_id = $1
+        ORDER BY path ASC`, [skillId]);
+        return result.rows.map(skillFile);
+    }
+    async find(skillId, path) {
+        const result = await this.database.query('SELECT * FROM skill_files WHERE skill_id = $1 AND path = $2', [skillId, path]);
+        return result.rows[0] ? skillFile(result.rows[0]) : null;
+    }
+    async upsert(file, maximumPerSkill) {
+        await this.database.transaction(async (client) => {
+            const existing = await client.query('SELECT id FROM skill_files WHERE skill_id = $1 AND path = $2 FOR UPDATE', [file.skill_id, file.path]);
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM skill_files WHERE skill_id = $1', [file.skill_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximumPerSkill) {
+                    throw new PersistenceResourceLimitError('skill-file', maximumPerSkill);
+                }
+            }
+            await client.query(`INSERT INTO skill_files
+           (id, skill_id, path, content, size, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (skill_id, path) DO UPDATE SET
+           content = EXCLUDED.content,
+           size = EXCLUDED.size,
+           updated_at = EXCLUDED.updated_at`, [
+                file.id,
+                file.skill_id,
+                file.path,
+                file.content,
+                file.size,
+                file.created_at,
+                file.updated_at,
+            ]);
+        });
+    }
+    async replaceAllForSkill(skillId, files) {
+        await this.database.transaction(async (client) => {
+            await client.query('DELETE FROM skill_files WHERE skill_id = $1', [
+                skillId,
+            ]);
+            for (const file of files) {
+                if (file.skill_id !== skillId) {
+                    throw new Error('A skill file does not belong to its skill');
+                }
+                await client.query(`INSERT INTO skill_files
+             (id, skill_id, path, content, size, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
+                    file.id,
+                    file.skill_id,
+                    file.path,
+                    file.content,
+                    file.size,
+                    file.created_at,
+                    file.updated_at,
+                ]);
+            }
+        });
+    }
+    async delete(skillId, path) {
+        return (changes((await this.database.query('DELETE FROM skill_files WHERE skill_id = $1 AND path = $2', [skillId, path])).rowCount) > 0);
     }
 }
 class PostgresSessionFolderRepository {
@@ -465,6 +2047,10 @@ const ARCHIVE_TABLES = {
     'knowledge-collection': 'knowledge_collections',
     document: 'documents',
     persona: 'personas',
+    prompt: 'prompts',
+    skill: 'skills',
+    'tool-server': 'tool_servers',
+    calendar: 'calendars',
 };
 class PostgresDataArchiveRepository {
     constructor(database) {
@@ -756,14 +2342,337 @@ class PostgresDataArchiveRepository {
         });
     }
 }
+const modelTariff = (row) => ({
+    ...row,
+    input_per_million: row.input_per_million === null ? null : Number(row.input_per_million),
+    output_per_million: row.output_per_million === null ? null : Number(row.output_per_million),
+    unit_price: row.unit_price === null ? null : Number(row.unit_price),
+    effective_from: number(row.effective_from, 'tariff effective_from'),
+    created_at: number(row.created_at, 'tariff created_at'),
+});
+const usageBudget = (row) => ({
+    ...row,
+    amount_usd: Number(row.amount_usd),
+    created_at: number(row.created_at, 'budget created_at'),
+    updated_at: number(row.updated_at, 'budget updated_at'),
+});
+const messageFeedback = (row) => ({
+    ...row,
+    rating: number(row.rating, 'feedback rating'),
+    created_at: number(row.created_at, 'feedback created_at'),
+    updated_at: number(row.updated_at, 'feedback updated_at'),
+});
+const arenaVote = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'arena vote created_at'),
+});
+const evalSet = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'eval set created_at'),
+    updated_at: number(row.updated_at, 'eval set updated_at'),
+});
+const evalRun = (row) => ({
+    ...row,
+    created_at: number(row.created_at, 'eval run created_at'),
+    updated_at: number(row.updated_at, 'eval run updated_at'),
+    completed_at: row.completed_at === null
+        ? null
+        : number(row.completed_at, 'eval run completed_at'),
+});
+class PostgresModelTariffRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listAll(maximum) {
+        const result = await this.database.query(`SELECT * FROM model_tariffs
+        ORDER BY plugin_id ASC, model ASC, effective_from DESC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(modelTariff);
+    }
+    async insert(tariff) {
+        await this.database.query(`INSERT INTO model_tariffs
+         (id, plugin_id, model, input_per_million, output_per_million,
+          unit_price, currency, effective_from, created_by, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`, [
+            tariff.id,
+            tariff.plugin_id,
+            tariff.model,
+            tariff.input_per_million,
+            tariff.output_per_million,
+            tariff.unit_price,
+            tariff.currency,
+            tariff.effective_from,
+            tariff.created_by,
+            tariff.created_at,
+        ]);
+    }
+    async deleteById(tariffId) {
+        const result = await this.database.query('DELETE FROM model_tariffs WHERE id = $1', [tariffId]);
+        return changes(result.rowCount) > 0;
+    }
+}
+class PostgresUsageBudgetRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listAll(maximum) {
+        const result = await this.database.query(`SELECT * FROM usage_budgets
+        ORDER BY created_at ASC, id ASC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(usageBudget);
+    }
+    async findById(budgetId) {
+        const result = await this.database.query('SELECT * FROM usage_budgets WHERE id = $1', [budgetId]);
+        return result.rows[0] ? usageBudget(result.rows[0]) : null;
+    }
+    async replace(budget) {
+        await this.database.query(`INSERT INTO usage_budgets
+         (id, name, principal_type, principal_id, period, amount_usd,
+          mode, created_by, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       ON CONFLICT (id) DO UPDATE SET
+         name = EXCLUDED.name,
+         principal_type = EXCLUDED.principal_type,
+         principal_id = EXCLUDED.principal_id,
+         period = EXCLUDED.period,
+         amount_usd = EXCLUDED.amount_usd,
+         mode = EXCLUDED.mode,
+         updated_at = EXCLUDED.updated_at`, [
+            budget.id,
+            budget.name,
+            budget.principal_type,
+            budget.principal_id,
+            budget.period,
+            budget.amount_usd,
+            budget.mode,
+            budget.created_by,
+            budget.created_at,
+            budget.updated_at,
+        ]);
+    }
+    async deleteById(budgetId) {
+        const result = await this.database.query('DELETE FROM usage_budgets WHERE id = $1', [budgetId]);
+        return changes(result.rowCount) > 0;
+    }
+}
+class PostgresMessageFeedbackRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async upsertByMessage(feedback) {
+        await this.database.query(`INSERT INTO message_feedback
+         (id, user_id, session_id, message_id, rating, tags, comment,
+          model, plugin_id, snapshot, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       ON CONFLICT (user_id, message_id) DO UPDATE SET
+         rating = EXCLUDED.rating,
+         tags = EXCLUDED.tags,
+         comment = EXCLUDED.comment,
+         model = EXCLUDED.model,
+         plugin_id = EXCLUDED.plugin_id,
+         snapshot = EXCLUDED.snapshot,
+         updated_at = EXCLUDED.updated_at`, [
+            feedback.id,
+            feedback.user_id,
+            feedback.session_id,
+            feedback.message_id,
+            feedback.rating,
+            feedback.tags,
+            feedback.comment,
+            feedback.model,
+            feedback.plugin_id,
+            feedback.snapshot,
+            feedback.created_at,
+            feedback.updated_at,
+        ]);
+    }
+    async deleteByMessage(userId, messageId) {
+        const result = await this.database.query('DELETE FROM message_feedback WHERE user_id = $1 AND message_id = $2', [userId, messageId]);
+        return changes(result.rowCount) > 0;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM message_feedback
+        WHERE user_id = $1
+        ORDER BY created_at DESC, id DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(messageFeedback);
+    }
+    async listAll(maximum) {
+        const result = await this.database.query(`SELECT * FROM message_feedback
+        ORDER BY created_at DESC, id DESC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(messageFeedback);
+    }
+}
+class PostgresArenaVoteRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertOnce(vote) {
+        const result = await this.database.query(`INSERT INTO arena_votes
+         (id, user_id, compare_group, model_a, model_b, winner, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       ON CONFLICT (user_id, compare_group) DO NOTHING`, [
+            vote.id,
+            vote.user_id,
+            vote.compare_group,
+            vote.model_a,
+            vote.model_b,
+            vote.winner,
+            vote.created_at,
+        ]);
+        return changes(result.rowCount) > 0;
+    }
+    async listAllOrdered(maximum) {
+        const result = await this.database.query(`SELECT * FROM arena_votes
+        ORDER BY created_at ASC, id ASC
+        LIMIT $1`, [maximum]);
+        return result.rows.map(arenaVote);
+    }
+}
+class PostgresEvalSetRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM eval_sets
+        WHERE user_id = $1
+        ORDER BY updated_at DESC, id DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(evalSet);
+    }
+    async findByOwner(setId, userId) {
+        const result = await this.database.query('SELECT * FROM eval_sets WHERE id = $1 AND user_id = $2', [setId, userId]);
+        return result.rows[0] ? evalSet(result.rows[0]) : null;
+    }
+    async replaceWithLimit(value, maximum) {
+        await this.database.transaction(async (client) => {
+            await lockOwner(client, value.user_id);
+            const existing = await client.query('SELECT user_id FROM eval_sets WHERE id = $1 FOR UPDATE', [value.id]);
+            if (existing.rows[0] && existing.rows[0].user_id !== value.user_id) {
+                throw new PersistenceResourceConflictError();
+            }
+            if (!existing.rows[0]) {
+                const count = await client.query('SELECT COUNT(*)::text AS count FROM eval_sets WHERE user_id = $1', [value.user_id]);
+                if (Number(count.rows[0]?.count || 0) >= maximum) {
+                    throw new PersistenceResourceLimitError('eval-set', maximum);
+                }
+            }
+            const result = await client.query(`INSERT INTO eval_sets
+           (id, user_id, name, description, items, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (id) DO UPDATE SET
+           name = EXCLUDED.name,
+           description = EXCLUDED.description,
+           items = EXCLUDED.items,
+           updated_at = EXCLUDED.updated_at
+         WHERE eval_sets.user_id = EXCLUDED.user_id`, [
+                value.id,
+                value.user_id,
+                value.name,
+                value.description,
+                value.items,
+                value.created_at,
+                value.updated_at,
+            ]);
+            if (result.rowCount !== 1)
+                throw new PersistenceResourceConflictError();
+        });
+    }
+    async deleteByOwner(setId, userId) {
+        const result = await this.database.query('DELETE FROM eval_sets WHERE id = $1 AND user_id = $2', [setId, userId]);
+        return changes(result.rowCount) > 0;
+    }
+}
+class PostgresEvalRunRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM eval_runs
+        WHERE user_id = $1
+        ORDER BY created_at DESC, id DESC
+        LIMIT $2`, [userId, maximum]);
+        return result.rows.map(evalRun);
+    }
+    async listBySet(setId, userId, maximum) {
+        const result = await this.database.query(`SELECT * FROM eval_runs
+        WHERE set_id = $1 AND user_id = $2
+        ORDER BY created_at DESC, id DESC
+        LIMIT $3`, [setId, userId, maximum]);
+        return result.rows.map(evalRun);
+    }
+    async findByOwner(runId, userId) {
+        const result = await this.database.query('SELECT * FROM eval_runs WHERE id = $1 AND user_id = $2', [runId, userId]);
+        return result.rows[0] ? evalRun(result.rows[0]) : null;
+    }
+    async insert(run) {
+        await this.database.query(`INSERT INTO eval_runs
+         (id, set_id, user_id, label, plugin_id, model, status, results,
+          error, created_at, updated_at, completed_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+            run.id,
+            run.set_id,
+            run.user_id,
+            run.label,
+            run.plugin_id,
+            run.model,
+            run.status,
+            run.results,
+            run.error,
+            run.created_at,
+            run.updated_at,
+            run.completed_at,
+        ]);
+    }
+    async update(runId, userId, updates) {
+        const result = await this.database.query(`UPDATE eval_runs SET
+         status = $1,
+         results = COALESCE($2, results),
+         error = $3,
+         updated_at = $4,
+         completed_at = COALESCE($5, completed_at)
+       WHERE id = $6 AND user_id = $7`, [
+            updates.status,
+            updates.results ?? null,
+            updates.error ?? null,
+            updates.updated_at,
+            updates.completed_at ?? null,
+            runId,
+            userId,
+        ]);
+        return changes(result.rowCount) > 0;
+    }
+}
 export const createPostgresResourceRepositories = (database) => ({
     chatSessions: new PostgresChatSessionRepository(database),
     knowledgeCollections: new PostgresKnowledgeCollectionRepository(database),
     notes: new PostgresNoteRepository(database),
+    calendars: new PostgresCalendarRepository(database),
+    calendarEvents: new PostgresCalendarEventRepository(database),
+    channels: new PostgresChannelRepository(database),
+    channelMessages: new PostgresChannelMessageRepository(database),
+    notifications: new PostgresNotificationRepository(database),
+    webhookTargets: new PostgresWebhookTargetRepository(database),
+    automations: new PostgresAutomationRepository(database),
+    automationRuns: new PostgresAutomationRunRepository(database),
+    toolServers: new PostgresToolServerRepository(database),
+    toolServerTools: new PostgresToolServerToolRepository(database),
+    toolServerCredentials: new PostgresToolServerCredentialRepository(database),
+    toolApprovals: new PostgresToolApprovalRepository(database),
+    prompts: new PostgresPromptRepository(database),
+    skills: new PostgresSkillRepository(database),
+    skillFiles: new PostgresSkillFileRepository(database),
     sessionFolders: new PostgresSessionFolderRepository(database),
     preferences: new PostgresPreferenceRepository(database),
     systemSettings: new PostgresSystemSettingRepository(database),
     archive: new PostgresDataArchiveRepository(database),
+    modelTariffs: new PostgresModelTariffRepository(database),
+    usageBudgets: new PostgresUsageBudgetRepository(database),
+    messageFeedback: new PostgresMessageFeedbackRepository(database),
+    arenaVotes: new PostgresArenaVoteRepository(database),
+    evalSets: new PostgresEvalSetRepository(database),
+    evalRuns: new PostgresEvalRunRepository(database),
 });
 /** Create transaction-scoped repositories over one pinned pooled client. */
 export const createPostgresTransactionalResourceRepositories = (database, client) => {