cowork-os 0.3.21

package/dist/electron/electron/database/repositories.js

@@ -0,0 +1,1781 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySettingsRepository = exports.MemorySummaryRepository = exports.MemoryRepository = exports.AuditLogRepository = exports.RateLimitRepository = exports.DeliveryTrackingRepository = exports.ScheduledMessageRepository = exports.MessageQueueRepository = exports.ChannelMessageRepository = exports.ChannelSessionRepository = exports.ChannelUserRepository = exports.ChannelRepository = exports.LLMModelRepository = exports.SkillRepository = exports.ApprovalRepository = exports.ArtifactRepository = exports.TaskEventRepository = exports.TaskRepository = exports.WorkspaceRepository = void 0;
+const uuid_1 = require("uuid");
+/**
+ * Safely parse JSON with error handling
+ * Returns defaultValue if parsing fails
+ */
+function safeJsonParse(jsonString, defaultValue, context) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (error) {
+        console.error(`Failed to parse JSON${context ? ` in ${context}` : ''}:`, error, 'Input:', jsonString?.slice(0, 100));
+        return defaultValue;
+    }
+}
+class WorkspaceRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(name, path, permissions) {
+        const workspace = {
+            id: (0, uuid_1.v4)(),
+            name,
+            path,
+            createdAt: Date.now(),
+            permissions,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO workspaces (id, name, path, created_at, permissions)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(workspace.id, workspace.name, workspace.path, workspace.createdAt, JSON.stringify(workspace.permissions));
+        return workspace;
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM workspaces WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToWorkspace(row) : undefined;
+    }
+    findAll() {
+        const stmt = this.db.prepare('SELECT * FROM workspaces ORDER BY created_at DESC');
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToWorkspace(row));
+    }
+    /**
+     * Check if a workspace with the given path already exists
+     */
+    existsByPath(path) {
+        const stmt = this.db.prepare('SELECT 1 FROM workspaces WHERE path = ?');
+        const row = stmt.get(path);
+        return !!row;
+    }
+    /**
+     * Find a workspace by its path
+     */
+    findByPath(path) {
+        const stmt = this.db.prepare('SELECT * FROM workspaces WHERE path = ?');
+        const row = stmt.get(path);
+        return row ? this.mapRowToWorkspace(row) : undefined;
+    }
+    /**
+     * Update workspace permissions
+     */
+    updatePermissions(id, permissions) {
+        const stmt = this.db.prepare('UPDATE workspaces SET permissions = ? WHERE id = ?');
+        stmt.run(JSON.stringify(permissions), id);
+    }
+    /**
+     * Delete a workspace by ID
+     */
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM workspaces WHERE id = ?');
+        stmt.run(id);
+    }
+    mapRowToWorkspace(row) {
+        // Note: network is true by default for browser tools (web access)
+        const defaultPermissions = { read: true, write: true, delete: false, network: true, shell: false };
+        const storedPermissions = safeJsonParse(row.permissions, defaultPermissions, 'workspace.permissions');
+        // Merge with defaults to ensure new fields (like network) get proper defaults
+        // for workspaces created before those fields existed
+        const mergedPermissions = {
+            ...defaultPermissions,
+            ...storedPermissions,
+        };
+        // Migration: if network was explicitly false (old default), upgrade it to true
+        // This ensures existing workspaces get browser tool access
+        if (storedPermissions.network === false) {
+            mergedPermissions.network = true;
+        }
+        return {
+            id: row.id,
+            name: row.name,
+            path: row.path,
+            createdAt: row.created_at,
+            permissions: mergedPermissions,
+        };
+    }
+}
+exports.WorkspaceRepository = WorkspaceRepository;
+class TaskRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(task) {
+        const newTask = {
+            ...task,
+            id: (0, uuid_1.v4)(),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO tasks (id, title, prompt, status, workspace_id, created_at, updated_at, budget_tokens, budget_cost, success_criteria, max_attempts, current_attempt, parent_task_id, agent_type, agent_config, depth, result_summary)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newTask.id, newTask.title, newTask.prompt, newTask.status, newTask.workspaceId, newTask.createdAt, newTask.updatedAt, newTask.budgetTokens || null, newTask.budgetCost || null, newTask.successCriteria ? JSON.stringify(newTask.successCriteria) : null, newTask.maxAttempts || null, newTask.currentAttempt || 1, newTask.parentTaskId || null, newTask.agentType || 'main', newTask.agentConfig ? JSON.stringify(newTask.agentConfig) : null, newTask.depth ?? 0, newTask.resultSummary || null);
+        return newTask;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        Object.entries(updates).forEach(([key, value]) => {
+            // Validate field name against whitelist
+            if (!TaskRepository.ALLOWED_UPDATE_FIELDS.has(key)) {
+                console.warn(`Ignoring unknown field in task update: ${key}`);
+                return;
+            }
+            const snakeKey = key.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+            fields.push(`${snakeKey} = ?`);
+            // JSON serialize object/array fields
+            if ((key === 'successCriteria' || key === 'agentConfig' || key === 'labels' || key === 'mentionedAgentRoleIds') && value != null) {
+                values.push(JSON.stringify(value));
+            }
+            else {
+                values.push(value);
+            }
+        });
+        if (fields.length === 0) {
+            return; // No valid fields to update
+        }
+        fields.push('updated_at = ?');
+        values.push(Date.now());
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE tasks SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM tasks WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToTask(row) : undefined;
+    }
+    findAll(limit = 100, offset = 0) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      ORDER BY created_at DESC
+      LIMIT ? OFFSET ?
+    `);
+        const rows = stmt.all(limit, offset);
+        return rows.map(row => this.mapRowToTask(row));
+    }
+    /**
+     * Find tasks by status (single status or array of statuses)
+     */
+    findByStatus(status) {
+        const statuses = Array.isArray(status) ? status : [status];
+        const placeholders = statuses.map(() => '?').join(', ');
+        const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      WHERE status IN (${placeholders})
+      ORDER BY created_at ASC
+    `);
+        const rows = stmt.all(...statuses);
+        return rows.map(row => this.mapRowToTask(row));
+    }
+    /**
+     * Find tasks by workspace ID
+     */
+    findByWorkspace(workspaceId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      WHERE workspace_id = ?
+      ORDER BY created_at DESC
+    `);
+        const rows = stmt.all(workspaceId);
+        return rows.map(row => this.mapRowToTask(row));
+    }
+    delete(id) {
+        // Use transaction to ensure atomic deletion
+        const deleteTransaction = this.db.transaction((taskId) => {
+            // Delete related records from all tables with foreign keys to tasks
+            const deleteEvents = this.db.prepare('DELETE FROM task_events WHERE task_id = ?');
+            deleteEvents.run(taskId);
+            const deleteArtifacts = this.db.prepare('DELETE FROM artifacts WHERE task_id = ?');
+            deleteArtifacts.run(taskId);
+            const deleteApprovals = this.db.prepare('DELETE FROM approvals WHERE task_id = ?');
+            deleteApprovals.run(taskId);
+            // Delete activity feed entries for this task
+            const deleteActivities = this.db.prepare('DELETE FROM activity_feed WHERE task_id = ?');
+            deleteActivities.run(taskId);
+            // Delete agent mentions for this task
+            const deleteMentions = this.db.prepare('DELETE FROM agent_mentions WHERE task_id = ?');
+            deleteMentions.run(taskId);
+            // Delete working state entries for this task
+            const deleteWorkingState = this.db.prepare('DELETE FROM agent_working_state WHERE task_id = ?');
+            deleteWorkingState.run(taskId);
+            // Nullify task_id in memories rather than deleting them
+            const clearMemoryTaskId = this.db.prepare('UPDATE memories SET task_id = NULL WHERE task_id = ?');
+            clearMemoryTaskId.run(taskId);
+            // Nullify task_id in channel_sessions rather than deleting the session
+            const clearSessionTaskId = this.db.prepare('UPDATE channel_sessions SET task_id = NULL WHERE task_id = ?');
+            clearSessionTaskId.run(taskId);
+            // Finally delete the task
+            const deleteTask = this.db.prepare('DELETE FROM tasks WHERE id = ?');
+            deleteTask.run(taskId);
+        });
+        deleteTransaction(id);
+    }
+    mapRowToTask(row) {
+        return {
+            id: row.id,
+            title: row.title,
+            prompt: row.prompt,
+            status: row.status,
+            workspaceId: row.workspace_id,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            completedAt: row.completed_at || undefined,
+            budgetTokens: row.budget_tokens || undefined,
+            budgetCost: row.budget_cost || undefined,
+            error: row.error || undefined,
+            // Goal Mode fields
+            successCriteria: row.success_criteria ? safeJsonParse(row.success_criteria, undefined, 'task.successCriteria') : undefined,
+            maxAttempts: row.max_attempts || undefined,
+            currentAttempt: row.current_attempt || undefined,
+            // Sub-Agent / Parallel Agent fields
+            parentTaskId: row.parent_task_id || undefined,
+            agentType: row.agent_type || undefined,
+            agentConfig: row.agent_config ? safeJsonParse(row.agent_config, undefined, 'task.agentConfig') : undefined,
+            depth: row.depth ?? undefined,
+            resultSummary: row.result_summary || undefined,
+            // Agent Squad fields
+            assignedAgentRoleId: row.assigned_agent_role_id || undefined,
+            boardColumn: row.board_column || undefined,
+            priority: row.priority ?? undefined,
+            // Task Board fields
+            labels: row.labels ? safeJsonParse(row.labels, [], 'task.labels') : undefined,
+            dueDate: row.due_date || undefined,
+            estimatedMinutes: row.estimated_minutes || undefined,
+            actualMinutes: row.actual_minutes || undefined,
+            mentionedAgentRoleIds: row.mentioned_agent_role_ids ? safeJsonParse(row.mentioned_agent_role_ids, [], 'task.mentionedAgentRoleIds') : undefined,
+        };
+    }
+    /**
+     * Find tasks by parent task ID
+     */
+    findByParent(parentTaskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      WHERE parent_task_id = ?
+      ORDER BY created_at ASC
+    `);
+        const rows = stmt.all(parentTaskId);
+        return rows.map(row => this.mapRowToTask(row));
+    }
+    // ============ Task Board Methods ============
+    /**
+     * Find tasks by workspace and board column
+     */
+    findByBoardColumn(workspaceId, boardColumn) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      WHERE workspace_id = ? AND board_column = ?
+      ORDER BY priority DESC, created_at ASC
+    `);
+        const rows = stmt.all(workspaceId, boardColumn);
+        return rows.map(row => this.mapRowToTask(row));
+    }
+    /**
+     * Get tasks grouped by board column for a workspace
+     */
+    getTaskBoard(workspaceId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      WHERE workspace_id = ? AND parent_task_id IS NULL
+      ORDER BY board_column, priority DESC, created_at ASC
+    `);
+        const rows = stmt.all(workspaceId);
+        const tasks = rows.map(row => this.mapRowToTask(row));
+        // Group tasks by board column
+        const board = {
+            backlog: [],
+            todo: [],
+            in_progress: [],
+            review: [],
+            done: [],
+        };
+        for (const task of tasks) {
+            const column = task.boardColumn || 'backlog';
+            if (board[column]) {
+                board[column].push(task);
+            }
+            else {
+                board.backlog.push(task);
+            }
+        }
+        return board;
+    }
+    /**
+     * Move a task to a different board column
+     */
+    moveToColumn(id, boardColumn) {
+        this.update(id, { boardColumn: boardColumn });
+        return this.findById(id);
+    }
+    /**
+     * Set task priority
+     */
+    setPriority(id, priority) {
+        this.update(id, { priority });
+        return this.findById(id);
+    }
+    /**
+     * Set task due date
+     */
+    setDueDate(id, dueDate) {
+        this.update(id, { dueDate: dueDate || undefined });
+        return this.findById(id);
+    }
+    /**
+     * Set task time estimate
+     */
+    setEstimate(id, estimatedMinutes) {
+        this.update(id, { estimatedMinutes: estimatedMinutes || undefined });
+        return this.findById(id);
+    }
+    /**
+     * Add a label to a task
+     */
+    addLabel(id, labelId) {
+        const task = this.findById(id);
+        if (!task)
+            return undefined;
+        const labels = task.labels || [];
+        if (!labels.includes(labelId)) {
+            labels.push(labelId);
+            this.update(id, { labels });
+        }
+        return this.findById(id);
+    }
+    /**
+     * Remove a label from a task
+     */
+    removeLabel(id, labelId) {
+        const task = this.findById(id);
+        if (!task)
+            return undefined;
+        const labels = task.labels || [];
+        const newLabels = labels.filter(l => l !== labelId);
+        this.update(id, { labels: newLabels });
+        return this.findById(id);
+    }
+    /**
+     * Assign an agent role to a task
+     */
+    assignAgentRole(id, agentRoleId) {
+        this.update(id, { assignedAgentRoleId: agentRoleId || undefined });
+        return this.findById(id);
+    }
+}
+exports.TaskRepository = TaskRepository;
+// Whitelist of allowed update fields to prevent SQL injection
+TaskRepository.ALLOWED_UPDATE_FIELDS = new Set([
+    'title', 'status', 'error', 'result', 'budgetTokens', 'budgetCost',
+    'successCriteria', 'maxAttempts', 'currentAttempt', 'completedAt',
+    'parentTaskId', 'agentType', 'agentConfig', 'depth', 'resultSummary',
+    // Agent Squad fields
+    'assignedAgentRoleId', 'boardColumn', 'priority',
+    // Task Board fields
+    'labels', 'dueDate', 'estimatedMinutes', 'actualMinutes', 'mentionedAgentRoleIds'
+]);
+class TaskEventRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(event) {
+        const newEvent = {
+            ...event,
+            id: (0, uuid_1.v4)(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO task_events (id, task_id, timestamp, type, payload)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(newEvent.id, newEvent.taskId, newEvent.timestamp, newEvent.type, JSON.stringify(newEvent.payload));
+        return newEvent;
+    }
+    findByTaskId(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM task_events
+      WHERE task_id = ?
+      ORDER BY timestamp ASC
+    `);
+        const rows = stmt.all(taskId);
+        return rows.map(row => this.mapRowToEvent(row));
+    }
+    mapRowToEvent(row) {
+        return {
+            id: row.id,
+            taskId: row.task_id,
+            timestamp: row.timestamp,
+            type: row.type,
+            payload: safeJsonParse(row.payload, {}, 'taskEvent.payload'),
+        };
+    }
+    /**
+     * Prune old conversation snapshots for a task, keeping only the most recent one.
+     * This prevents database bloat from accumulating snapshots over time.
+     */
+    pruneOldSnapshots(taskId) {
+        // Find all conversation_snapshot events for this task, ordered by timestamp descending
+        const findStmt = this.db.prepare(`
+      SELECT id, timestamp FROM task_events
+      WHERE task_id = ? AND type = 'conversation_snapshot'
+      ORDER BY timestamp DESC
+    `);
+        const snapshots = findStmt.all(taskId);
+        // Keep only the most recent one, delete the rest
+        if (snapshots.length > 1) {
+            const idsToDelete = snapshots.slice(1).map(s => s.id);
+            const deleteStmt = this.db.prepare(`
+        DELETE FROM task_events WHERE id = ?
+      `);
+            for (const id of idsToDelete) {
+                deleteStmt.run(id);
+            }
+            console.log(`[TaskEventRepository] Pruned ${idsToDelete.length} old snapshot(s) for task ${taskId}`);
+        }
+    }
+}
+exports.TaskEventRepository = TaskEventRepository;
+class ArtifactRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(artifact) {
+        const newArtifact = {
+            ...artifact,
+            id: (0, uuid_1.v4)(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO artifacts (id, task_id, path, mime_type, sha256, size, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newArtifact.id, newArtifact.taskId, newArtifact.path, newArtifact.mimeType, newArtifact.sha256, newArtifact.size, newArtifact.createdAt);
+        return newArtifact;
+    }
+    findByTaskId(taskId) {
+        const stmt = this.db.prepare('SELECT * FROM artifacts WHERE task_id = ? ORDER BY created_at DESC');
+        const rows = stmt.all(taskId);
+        return rows.map(row => this.mapRowToArtifact(row));
+    }
+    mapRowToArtifact(row) {
+        return {
+            id: row.id,
+            taskId: row.task_id,
+            path: row.path,
+            mimeType: row.mime_type,
+            sha256: row.sha256,
+            size: row.size,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.ArtifactRepository = ArtifactRepository;
+class ApprovalRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(approval) {
+        const newApproval = {
+            ...approval,
+            id: (0, uuid_1.v4)(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO approvals (id, task_id, type, description, details, status, requested_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newApproval.id, newApproval.taskId, newApproval.type, newApproval.description, JSON.stringify(newApproval.details), newApproval.status, newApproval.requestedAt);
+        return newApproval;
+    }
+    update(id, status) {
+        const stmt = this.db.prepare(`
+      UPDATE approvals
+      SET status = ?, resolved_at = ?
+      WHERE id = ?
+    `);
+        stmt.run(status, Date.now(), id);
+    }
+    findPendingByTaskId(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM approvals
+      WHERE task_id = ? AND status = 'pending'
+      ORDER BY requested_at ASC
+    `);
+        const rows = stmt.all(taskId);
+        return rows.map(row => this.mapRowToApproval(row));
+    }
+    mapRowToApproval(row) {
+        return {
+            id: row.id,
+            taskId: row.task_id,
+            type: row.type,
+            description: row.description,
+            details: safeJsonParse(row.details, {}, 'approval.details'),
+            status: row.status,
+            requestedAt: row.requested_at,
+            resolvedAt: row.resolved_at || undefined,
+        };
+    }
+}
+exports.ApprovalRepository = ApprovalRepository;
+class SkillRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(skill) {
+        const newSkill = {
+            ...skill,
+            id: (0, uuid_1.v4)(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO skills (id, name, description, category, prompt, script_path, parameters)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newSkill.id, newSkill.name, newSkill.description, newSkill.category, newSkill.prompt, newSkill.scriptPath || null, newSkill.parameters ? JSON.stringify(newSkill.parameters) : null);
+        return newSkill;
+    }
+    findAll() {
+        const stmt = this.db.prepare('SELECT * FROM skills ORDER BY name ASC');
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToSkill(row));
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM skills WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToSkill(row) : undefined;
+    }
+    mapRowToSkill(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            category: row.category,
+            prompt: row.prompt,
+            scriptPath: row.script_path || undefined,
+            parameters: row.parameters ? safeJsonParse(row.parameters, undefined, 'skill.parameters') : undefined,
+        };
+    }
+}
+exports.SkillRepository = SkillRepository;
+class LLMModelRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    findAll() {
+        const stmt = this.db.prepare(`
+      SELECT * FROM llm_models
+      WHERE is_active = 1
+      ORDER BY sort_order ASC
+    `);
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToModel(row));
+    }
+    findByKey(key) {
+        const stmt = this.db.prepare('SELECT * FROM llm_models WHERE key = ?');
+        const row = stmt.get(key);
+        return row ? this.mapRowToModel(row) : undefined;
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM llm_models WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToModel(row) : undefined;
+    }
+    mapRowToModel(row) {
+        return {
+            id: row.id,
+            key: row.key,
+            displayName: row.display_name,
+            description: row.description,
+            anthropicModelId: row.anthropic_model_id,
+            bedrockModelId: row.bedrock_model_id,
+            sortOrder: row.sort_order,
+            isActive: row.is_active === 1,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}
+exports.LLMModelRepository = LLMModelRepository;
+class ChannelRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(channel) {
+        const now = Date.now();
+        const newChannel = {
+            ...channel,
+            id: (0, uuid_1.v4)(),
+            createdAt: now,
+            updatedAt: now,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO channels (id, type, name, enabled, config, security_config, status, bot_username, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newChannel.id, newChannel.type, newChannel.name, newChannel.enabled ? 1 : 0, JSON.stringify(newChannel.config), JSON.stringify(newChannel.securityConfig), newChannel.status, newChannel.botUsername || null, newChannel.createdAt, newChannel.updatedAt);
+        return newChannel;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.name !== undefined) {
+            fields.push('name = ?');
+            values.push(updates.name);
+        }
+        if (updates.enabled !== undefined) {
+            fields.push('enabled = ?');
+            values.push(updates.enabled ? 1 : 0);
+        }
+        if (updates.config !== undefined) {
+            fields.push('config = ?');
+            values.push(JSON.stringify(updates.config));
+        }
+        if (updates.securityConfig !== undefined) {
+            fields.push('security_config = ?');
+            values.push(JSON.stringify(updates.securityConfig));
+        }
+        if (updates.status !== undefined) {
+            fields.push('status = ?');
+            values.push(updates.status);
+        }
+        if (updates.botUsername !== undefined) {
+            fields.push('bot_username = ?');
+            values.push(updates.botUsername);
+        }
+        if (fields.length === 0)
+            return;
+        fields.push('updated_at = ?');
+        values.push(Date.now());
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE channels SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM channels WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToChannel(row) : undefined;
+    }
+    findByType(type) {
+        const stmt = this.db.prepare('SELECT * FROM channels WHERE type = ?');
+        const row = stmt.get(type);
+        return row ? this.mapRowToChannel(row) : undefined;
+    }
+    findAll() {
+        const stmt = this.db.prepare('SELECT * FROM channels ORDER BY created_at ASC');
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToChannel(row));
+    }
+    findEnabled() {
+        const stmt = this.db.prepare('SELECT * FROM channels WHERE enabled = 1 ORDER BY created_at ASC');
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToChannel(row));
+    }
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM channels WHERE id = ?');
+        stmt.run(id);
+    }
+    mapRowToChannel(row) {
+        const defaultSecurityConfig = { mode: 'pairing' };
+        return {
+            id: row.id,
+            type: row.type,
+            name: row.name,
+            enabled: row.enabled === 1,
+            config: safeJsonParse(row.config, {}, 'channel.config'),
+            securityConfig: safeJsonParse(row.security_config, defaultSecurityConfig, 'channel.securityConfig'),
+            status: row.status,
+            botUsername: row.bot_username || undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}
+exports.ChannelRepository = ChannelRepository;
+class ChannelUserRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(user) {
+        const now = Date.now();
+        const newUser = {
+            ...user,
+            id: (0, uuid_1.v4)(),
+            pairingAttempts: 0,
+            createdAt: now,
+            lastSeenAt: now,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO channel_users (id, channel_id, channel_user_id, display_name, username, allowed, pairing_code, pairing_attempts, pairing_expires_at, created_at, last_seen_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newUser.id, newUser.channelId, newUser.channelUserId, newUser.displayName, newUser.username || null, newUser.allowed ? 1 : 0, newUser.pairingCode || null, newUser.pairingAttempts, newUser.pairingExpiresAt || null, newUser.createdAt, newUser.lastSeenAt);
+        return newUser;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.displayName !== undefined) {
+            fields.push('display_name = ?');
+            values.push(updates.displayName);
+        }
+        if (updates.username !== undefined) {
+            fields.push('username = ?');
+            values.push(updates.username);
+        }
+        if (updates.allowed !== undefined) {
+            fields.push('allowed = ?');
+            values.push(updates.allowed ? 1 : 0);
+        }
+        if (updates.pairingCode !== undefined) {
+            fields.push('pairing_code = ?');
+            values.push(updates.pairingCode);
+        }
+        if (updates.pairingAttempts !== undefined) {
+            fields.push('pairing_attempts = ?');
+            values.push(updates.pairingAttempts);
+        }
+        if (updates.pairingExpiresAt !== undefined) {
+            fields.push('pairing_expires_at = ?');
+            values.push(updates.pairingExpiresAt);
+        }
+        if (updates.lockoutUntil !== undefined) {
+            fields.push('lockout_until = ?');
+            values.push(updates.lockoutUntil);
+        }
+        if (updates.lastSeenAt !== undefined) {
+            fields.push('last_seen_at = ?');
+            values.push(updates.lastSeenAt);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE channel_users SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM channel_users WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToUser(row) : undefined;
+    }
+    findByChannelUserId(channelId, channelUserId) {
+        const stmt = this.db.prepare('SELECT * FROM channel_users WHERE channel_id = ? AND channel_user_id = ?');
+        const row = stmt.get(channelId, channelUserId);
+        return row ? this.mapRowToUser(row) : undefined;
+    }
+    findByChannelId(channelId) {
+        const stmt = this.db.prepare('SELECT * FROM channel_users WHERE channel_id = ? ORDER BY last_seen_at DESC');
+        const rows = stmt.all(channelId);
+        return rows.map(row => this.mapRowToUser(row));
+    }
+    findAllowedByChannelId(channelId) {
+        const stmt = this.db.prepare('SELECT * FROM channel_users WHERE channel_id = ? AND allowed = 1 ORDER BY last_seen_at DESC');
+        const rows = stmt.all(channelId);
+        return rows.map(row => this.mapRowToUser(row));
+    }
+    deleteByChannelId(channelId) {
+        const stmt = this.db.prepare('DELETE FROM channel_users WHERE channel_id = ?');
+        stmt.run(channelId);
+    }
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM channel_users WHERE id = ?');
+        stmt.run(id);
+    }
+    /**
+     * Delete expired pending pairing entries
+     * These are placeholder entries created when generating pairing codes that have expired
+     * Returns the number of deleted entries
+     */
+    deleteExpiredPending(channelId) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      DELETE FROM channel_users
+      WHERE channel_id = ?
+        AND allowed = 0
+        AND channel_user_id LIKE 'pending_%'
+        AND pairing_expires_at IS NOT NULL
+        AND pairing_expires_at < ?
+    `);
+        const result = stmt.run(channelId, now);
+        return result.changes;
+    }
+    findByPairingCode(channelId, pairingCode) {
+        const stmt = this.db.prepare('SELECT * FROM channel_users WHERE channel_id = ? AND UPPER(pairing_code) = UPPER(?)');
+        const row = stmt.get(channelId, pairingCode);
+        return row ? this.mapRowToUser(row) : undefined;
+    }
+    mapRowToUser(row) {
+        return {
+            id: row.id,
+            channelId: row.channel_id,
+            channelUserId: row.channel_user_id,
+            displayName: row.display_name,
+            username: row.username || undefined,
+            allowed: row.allowed === 1,
+            pairingCode: row.pairing_code || undefined,
+            pairingAttempts: row.pairing_attempts,
+            pairingExpiresAt: row.pairing_expires_at || undefined,
+            lockoutUntil: row.lockout_until || undefined,
+            createdAt: row.created_at,
+            lastSeenAt: row.last_seen_at,
+        };
+    }
+}
+exports.ChannelUserRepository = ChannelUserRepository;
+class ChannelSessionRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(session) {
+        const now = Date.now();
+        const newSession = {
+            ...session,
+            id: (0, uuid_1.v4)(),
+            createdAt: now,
+            lastActivityAt: now,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO channel_sessions (id, channel_id, chat_id, user_id, task_id, workspace_id, state, context, created_at, last_activity_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newSession.id, newSession.channelId, newSession.chatId, newSession.userId || null, newSession.taskId || null, newSession.workspaceId || null, newSession.state, newSession.context ? JSON.stringify(newSession.context) : null, newSession.createdAt, newSession.lastActivityAt);
+        return newSession;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        // Use 'in' check to allow setting fields to null/undefined (clearing them)
+        if ('taskId' in updates) {
+            fields.push('task_id = ?');
+            values.push(updates.taskId ?? null); // Convert undefined to null for SQLite
+        }
+        if ('workspaceId' in updates) {
+            fields.push('workspace_id = ?');
+            values.push(updates.workspaceId ?? null);
+        }
+        if ('state' in updates) {
+            fields.push('state = ?');
+            values.push(updates.state);
+        }
+        if ('lastActivityAt' in updates) {
+            fields.push('last_activity_at = ?');
+            values.push(updates.lastActivityAt);
+        }
+        // Handle shellEnabled and debugMode by merging into context
+        const hasContextUpdate = 'context' in updates || 'shellEnabled' in updates || 'debugMode' in updates;
+        if (hasContextUpdate) {
+            // Load existing session to merge context
+            const existing = this.findById(id);
+            const existingContext = existing?.context || {};
+            const newContext = {
+                ...existingContext,
+                ...('context' in updates ? updates.context : {}),
+                ...('shellEnabled' in updates ? { shellEnabled: updates.shellEnabled } : {}),
+                ...('debugMode' in updates ? { debugMode: updates.debugMode } : {}),
+            };
+            fields.push('context = ?');
+            values.push(JSON.stringify(newContext));
+        }
+        if (fields.length === 0)
+            return;
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE channel_sessions SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM channel_sessions WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToSession(row) : undefined;
+    }
+    findByChatId(channelId, chatId) {
+        const stmt = this.db.prepare('SELECT * FROM channel_sessions WHERE channel_id = ? AND chat_id = ? ORDER BY last_activity_at DESC LIMIT 1');
+        const row = stmt.get(channelId, chatId);
+        return row ? this.mapRowToSession(row) : undefined;
+    }
+    findByTaskId(taskId) {
+        const stmt = this.db.prepare('SELECT * FROM channel_sessions WHERE task_id = ?');
+        const row = stmt.get(taskId);
+        return row ? this.mapRowToSession(row) : undefined;
+    }
+    findActiveByChannelId(channelId) {
+        const stmt = this.db.prepare("SELECT * FROM channel_sessions WHERE channel_id = ? AND state != 'idle' ORDER BY last_activity_at DESC");
+        const rows = stmt.all(channelId);
+        return rows.map(row => this.mapRowToSession(row));
+    }
+    deleteByChannelId(channelId) {
+        const stmt = this.db.prepare('DELETE FROM channel_sessions WHERE channel_id = ?');
+        stmt.run(channelId);
+    }
+    mapRowToSession(row) {
+        const context = row.context ? safeJsonParse(row.context, {}, 'session.context') : undefined;
+        // Extract shellEnabled and debugMode from context
+        const shellEnabled = context?.shellEnabled;
+        const debugMode = context?.debugMode;
+        return {
+            id: row.id,
+            channelId: row.channel_id,
+            chatId: row.chat_id,
+            userId: row.user_id || undefined,
+            taskId: row.task_id || undefined,
+            workspaceId: row.workspace_id || undefined,
+            state: row.state,
+            context,
+            shellEnabled,
+            debugMode,
+            createdAt: row.created_at,
+            lastActivityAt: row.last_activity_at,
+        };
+    }
+}
+exports.ChannelSessionRepository = ChannelSessionRepository;
+class ChannelMessageRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(message) {
+        const newMessage = {
+            ...message,
+            id: (0, uuid_1.v4)(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO channel_messages (id, channel_id, session_id, channel_message_id, chat_id, user_id, direction, content, attachments, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newMessage.id, newMessage.channelId, newMessage.sessionId || null, newMessage.channelMessageId, newMessage.chatId, newMessage.userId || null, newMessage.direction, newMessage.content, newMessage.attachments ? JSON.stringify(newMessage.attachments) : null, newMessage.timestamp);
+        return newMessage;
+    }
+    findBySessionId(sessionId, limit = 50) {
+        const stmt = this.db.prepare('SELECT * FROM channel_messages WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?');
+        const rows = stmt.all(sessionId, limit);
+        return rows.map(row => this.mapRowToMessage(row)).reverse();
+    }
+    findByChatId(channelId, chatId, limit = 50) {
+        const stmt = this.db.prepare('SELECT * FROM channel_messages WHERE channel_id = ? AND chat_id = ? ORDER BY timestamp DESC LIMIT ?');
+        const rows = stmt.all(channelId, chatId, limit);
+        return rows.map(row => this.mapRowToMessage(row)).reverse();
+    }
+    deleteByChannelId(channelId) {
+        const stmt = this.db.prepare('DELETE FROM channel_messages WHERE channel_id = ?');
+        stmt.run(channelId);
+    }
+    mapRowToMessage(row) {
+        return {
+            id: row.id,
+            channelId: row.channel_id,
+            sessionId: row.session_id || undefined,
+            channelMessageId: row.channel_message_id,
+            chatId: row.chat_id,
+            userId: row.user_id || undefined,
+            direction: row.direction,
+            content: row.content,
+            attachments: row.attachments ? safeJsonParse(row.attachments, undefined, 'message.attachments') : undefined,
+            timestamp: row.timestamp,
+        };
+    }
+}
+exports.ChannelMessageRepository = ChannelMessageRepository;
+class MessageQueueRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    enqueue(item) {
+        const newItem = {
+            ...item,
+            id: (0, uuid_1.v4)(),
+            status: 'pending',
+            attempts: 0,
+            createdAt: Date.now(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO message_queue (id, channel_type, chat_id, message, priority, status, attempts, max_attempts, last_attempt_at, error, created_at, scheduled_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newItem.id, newItem.channelType, newItem.chatId, JSON.stringify(newItem.message), newItem.priority, newItem.status, newItem.attempts, newItem.maxAttempts, newItem.lastAttemptAt || null, newItem.error || null, newItem.createdAt, newItem.scheduledAt || null);
+        return newItem;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.status !== undefined) {
+            fields.push('status = ?');
+            values.push(updates.status);
+        }
+        if (updates.attempts !== undefined) {
+            fields.push('attempts = ?');
+            values.push(updates.attempts);
+        }
+        if (updates.lastAttemptAt !== undefined) {
+            fields.push('last_attempt_at = ?');
+            values.push(updates.lastAttemptAt);
+        }
+        if (updates.error !== undefined) {
+            fields.push('error = ?');
+            values.push(updates.error);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE message_queue SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findPending(limit = 50) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      SELECT * FROM message_queue
+      WHERE status = 'pending' AND (scheduled_at IS NULL OR scheduled_at <= ?)
+      ORDER BY priority DESC, created_at ASC
+      LIMIT ?
+    `);
+        const rows = stmt.all(now, limit);
+        return rows.map(row => this.mapRowToItem(row));
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM message_queue WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToItem(row) : undefined;
+    }
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM message_queue WHERE id = ?');
+        stmt.run(id);
+    }
+    deleteOld(olderThanMs) {
+        const cutoff = Date.now() - olderThanMs;
+        const stmt = this.db.prepare("DELETE FROM message_queue WHERE status IN ('sent', 'failed') AND created_at < ?");
+        const result = stmt.run(cutoff);
+        return result.changes;
+    }
+    mapRowToItem(row) {
+        return {
+            id: row.id,
+            channelType: row.channel_type,
+            chatId: row.chat_id,
+            message: safeJsonParse(row.message, {}, 'queue.message'),
+            priority: row.priority,
+            status: row.status,
+            attempts: row.attempts,
+            maxAttempts: row.max_attempts,
+            lastAttemptAt: row.last_attempt_at || undefined,
+            error: row.error || undefined,
+            createdAt: row.created_at,
+            scheduledAt: row.scheduled_at || undefined,
+        };
+    }
+}
+exports.MessageQueueRepository = MessageQueueRepository;
+class ScheduledMessageRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(item) {
+        const newItem = {
+            ...item,
+            id: (0, uuid_1.v4)(),
+            status: 'pending',
+            createdAt: Date.now(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO scheduled_messages (id, channel_type, chat_id, message, scheduled_at, status, sent_message_id, error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newItem.id, newItem.channelType, newItem.chatId, JSON.stringify(newItem.message), newItem.scheduledAt, newItem.status, newItem.sentMessageId || null, newItem.error || null, newItem.createdAt);
+        return newItem;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.status !== undefined) {
+            fields.push('status = ?');
+            values.push(updates.status);
+        }
+        if (updates.sentMessageId !== undefined) {
+            fields.push('sent_message_id = ?');
+            values.push(updates.sentMessageId);
+        }
+        if (updates.error !== undefined) {
+            fields.push('error = ?');
+            values.push(updates.error);
+        }
+        if (updates.scheduledAt !== undefined) {
+            fields.push('scheduled_at = ?');
+            values.push(updates.scheduledAt);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE scheduled_messages SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findDue(limit = 50) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      SELECT * FROM scheduled_messages
+      WHERE status = 'pending' AND scheduled_at <= ?
+      ORDER BY scheduled_at ASC
+      LIMIT ?
+    `);
+        const rows = stmt.all(now, limit);
+        return rows.map(row => this.mapRowToItem(row));
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM scheduled_messages WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToItem(row) : undefined;
+    }
+    findByChatId(channelType, chatId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM scheduled_messages
+      WHERE channel_type = ? AND chat_id = ? AND status = 'pending'
+      ORDER BY scheduled_at ASC
+    `);
+        const rows = stmt.all(channelType, chatId);
+        return rows.map(row => this.mapRowToItem(row));
+    }
+    cancel(id) {
+        const stmt = this.db.prepare("UPDATE scheduled_messages SET status = 'cancelled' WHERE id = ? AND status = 'pending'");
+        stmt.run(id);
+    }
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM scheduled_messages WHERE id = ?');
+        stmt.run(id);
+    }
+    mapRowToItem(row) {
+        return {
+            id: row.id,
+            channelType: row.channel_type,
+            chatId: row.chat_id,
+            message: safeJsonParse(row.message, {}, 'scheduled.message'),
+            scheduledAt: row.scheduled_at,
+            status: row.status,
+            sentMessageId: row.sent_message_id || undefined,
+            error: row.error || undefined,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.ScheduledMessageRepository = ScheduledMessageRepository;
+class DeliveryTrackingRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(item) {
+        const newItem = {
+            ...item,
+            id: (0, uuid_1.v4)(),
+            createdAt: Date.now(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO delivery_tracking (id, channel_type, chat_id, message_id, status, sent_at, delivered_at, read_at, error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newItem.id, newItem.channelType, newItem.chatId, newItem.messageId, newItem.status, newItem.sentAt || null, newItem.deliveredAt || null, newItem.readAt || null, newItem.error || null, newItem.createdAt);
+        return newItem;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.status !== undefined) {
+            fields.push('status = ?');
+            values.push(updates.status);
+        }
+        if (updates.sentAt !== undefined) {
+            fields.push('sent_at = ?');
+            values.push(updates.sentAt);
+        }
+        if (updates.deliveredAt !== undefined) {
+            fields.push('delivered_at = ?');
+            values.push(updates.deliveredAt);
+        }
+        if (updates.readAt !== undefined) {
+            fields.push('read_at = ?');
+            values.push(updates.readAt);
+        }
+        if (updates.error !== undefined) {
+            fields.push('error = ?');
+            values.push(updates.error);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE delivery_tracking SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findByMessageId(messageId) {
+        const stmt = this.db.prepare('SELECT * FROM delivery_tracking WHERE message_id = ?');
+        const row = stmt.get(messageId);
+        return row ? this.mapRowToItem(row) : undefined;
+    }
+    findByChatId(channelType, chatId, limit = 50) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM delivery_tracking
+      WHERE channel_type = ? AND chat_id = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(channelType, chatId, limit);
+        return rows.map(row => this.mapRowToItem(row));
+    }
+    deleteOld(olderThanMs) {
+        const cutoff = Date.now() - olderThanMs;
+        const stmt = this.db.prepare('DELETE FROM delivery_tracking WHERE created_at < ?');
+        const result = stmt.run(cutoff);
+        return result.changes;
+    }
+    mapRowToItem(row) {
+        return {
+            id: row.id,
+            channelType: row.channel_type,
+            chatId: row.chat_id,
+            messageId: row.message_id,
+            status: row.status,
+            sentAt: row.sent_at || undefined,
+            deliveredAt: row.delivered_at || undefined,
+            readAt: row.read_at || undefined,
+            error: row.error || undefined,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.DeliveryTrackingRepository = DeliveryTrackingRepository;
+class RateLimitRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    getOrCreate(channelType, userId) {
+        const stmt = this.db.prepare('SELECT * FROM rate_limits WHERE channel_type = ? AND user_id = ?');
+        const row = stmt.get(channelType, userId);
+        if (row) {
+            return this.mapRowToItem(row);
+        }
+        // Create new record
+        const newItem = {
+            id: (0, uuid_1.v4)(),
+            channelType,
+            userId,
+            messageCount: 0,
+            windowStart: Date.now(),
+            isLimited: false,
+        };
+        const insertStmt = this.db.prepare(`
+      INSERT INTO rate_limits (id, channel_type, user_id, message_count, window_start, is_limited, limit_expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        insertStmt.run(newItem.id, newItem.channelType, newItem.userId, newItem.messageCount, newItem.windowStart, newItem.isLimited ? 1 : 0, newItem.limitExpiresAt || null);
+        return newItem;
+    }
+    update(channelType, userId, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.messageCount !== undefined) {
+            fields.push('message_count = ?');
+            values.push(updates.messageCount);
+        }
+        if (updates.windowStart !== undefined) {
+            fields.push('window_start = ?');
+            values.push(updates.windowStart);
+        }
+        if (updates.isLimited !== undefined) {
+            fields.push('is_limited = ?');
+            values.push(updates.isLimited ? 1 : 0);
+        }
+        if (updates.limitExpiresAt !== undefined) {
+            fields.push('limit_expires_at = ?');
+            values.push(updates.limitExpiresAt);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(channelType, userId);
+        const stmt = this.db.prepare(`UPDATE rate_limits SET ${fields.join(', ')} WHERE channel_type = ? AND user_id = ?`);
+        stmt.run(...values);
+    }
+    resetWindow(channelType, userId) {
+        const stmt = this.db.prepare(`
+      UPDATE rate_limits
+      SET message_count = 0, window_start = ?, is_limited = 0, limit_expires_at = NULL
+      WHERE channel_type = ? AND user_id = ?
+    `);
+        stmt.run(Date.now(), channelType, userId);
+    }
+    mapRowToItem(row) {
+        return {
+            id: row.id,
+            channelType: row.channel_type,
+            userId: row.user_id,
+            messageCount: row.message_count,
+            windowStart: row.window_start,
+            isLimited: row.is_limited === 1,
+            limitExpiresAt: row.limit_expires_at || undefined,
+        };
+    }
+}
+exports.RateLimitRepository = RateLimitRepository;
+class AuditLogRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    log(entry) {
+        const newEntry = {
+            ...entry,
+            id: (0, uuid_1.v4)(),
+            timestamp: Date.now(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO audit_log (id, timestamp, action, channel_type, user_id, chat_id, details, severity)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newEntry.id, newEntry.timestamp, newEntry.action, newEntry.channelType || null, newEntry.userId || null, newEntry.chatId || null, newEntry.details ? JSON.stringify(newEntry.details) : null, newEntry.severity);
+        return newEntry;
+    }
+    find(options) {
+        const conditions = [];
+        const values = [];
+        if (options.action) {
+            conditions.push('action = ?');
+            values.push(options.action);
+        }
+        if (options.channelType) {
+            conditions.push('channel_type = ?');
+            values.push(options.channelType);
+        }
+        if (options.userId) {
+            conditions.push('user_id = ?');
+            values.push(options.userId);
+        }
+        if (options.chatId) {
+            conditions.push('chat_id = ?');
+            values.push(options.chatId);
+        }
+        if (options.fromTimestamp) {
+            conditions.push('timestamp >= ?');
+            values.push(options.fromTimestamp);
+        }
+        if (options.toTimestamp) {
+            conditions.push('timestamp <= ?');
+            values.push(options.toTimestamp);
+        }
+        if (options.severity) {
+            conditions.push('severity = ?');
+            values.push(options.severity);
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const stmt = this.db.prepare(`
+      SELECT * FROM audit_log
+      ${whereClause}
+      ORDER BY timestamp DESC
+      LIMIT ? OFFSET ?
+    `);
+        values.push(limit, offset);
+        const rows = stmt.all(...values);
+        return rows.map(row => this.mapRowToEntry(row));
+    }
+    deleteOld(olderThanMs) {
+        const cutoff = Date.now() - olderThanMs;
+        const stmt = this.db.prepare('DELETE FROM audit_log WHERE timestamp < ?');
+        const result = stmt.run(cutoff);
+        return result.changes;
+    }
+    mapRowToEntry(row) {
+        return {
+            id: row.id,
+            timestamp: row.timestamp,
+            action: row.action,
+            channelType: row.channel_type || undefined,
+            userId: row.user_id || undefined,
+            chatId: row.chat_id || undefined,
+            details: row.details ? safeJsonParse(row.details, undefined, 'audit.details') : undefined,
+            severity: row.severity,
+        };
+    }
+}
+exports.AuditLogRepository = AuditLogRepository;
+class MemoryRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(memory) {
+        const now = Date.now();
+        const newMemory = {
+            ...memory,
+            id: (0, uuid_1.v4)(),
+            createdAt: now,
+            updatedAt: now,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO memories (id, workspace_id, task_id, type, content, summary, tokens, is_compressed, is_private, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newMemory.id, newMemory.workspaceId, newMemory.taskId || null, newMemory.type, newMemory.content, newMemory.summary || null, newMemory.tokens, newMemory.isCompressed ? 1 : 0, newMemory.isPrivate ? 1 : 0, newMemory.createdAt, newMemory.updatedAt);
+        return newMemory;
+    }
+    update(id, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.summary !== undefined) {
+            fields.push('summary = ?');
+            values.push(updates.summary);
+        }
+        if (updates.tokens !== undefined) {
+            fields.push('tokens = ?');
+            values.push(updates.tokens);
+        }
+        if (updates.isCompressed !== undefined) {
+            fields.push('is_compressed = ?');
+            values.push(updates.isCompressed ? 1 : 0);
+        }
+        if (fields.length === 0)
+            return;
+        fields.push('updated_at = ?');
+        values.push(Date.now());
+        values.push(id);
+        const stmt = this.db.prepare(`UPDATE memories SET ${fields.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+    }
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM memories WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToMemory(row) : undefined;
+    }
+    findByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const placeholders = ids.map(() => '?').join(', ');
+        const stmt = this.db.prepare(`SELECT * FROM memories WHERE id IN (${placeholders})`);
+        const rows = stmt.all(...ids);
+        return rows.map(row => this.mapRowToMemory(row));
+    }
+    /**
+     * Layer 1: Search returns IDs + brief snippets (~50 tokens each)
+     * Uses FTS5 for full-text search with relevance ranking
+     */
+    search(workspaceId, query, limit = 20) {
+        try {
+            // Try FTS5 search first
+            const stmt = this.db.prepare(`
+        SELECT m.id, m.summary, m.content, m.type, m.created_at, m.task_id,
+               bm25(memories_fts) as score
+        FROM memories_fts f
+        JOIN memories m ON f.rowid = m.rowid
+        WHERE memories_fts MATCH ? AND m.workspace_id = ? AND m.is_private = 0
+        ORDER BY score
+        LIMIT ?
+      `);
+            const rows = stmt.all(query, workspaceId, limit);
+            return rows.map(row => ({
+                id: row.id,
+                snippet: row.summary || this.truncateToSnippet(row.content, 200),
+                type: row.type,
+                relevanceScore: Math.abs(row.score),
+                createdAt: row.created_at,
+                taskId: row.task_id || undefined,
+            }));
+        }
+        catch {
+            // Fall back to LIKE search if FTS5 is not available
+            const stmt = this.db.prepare(`
+        SELECT id, summary, content, type, created_at, task_id
+        FROM memories
+        WHERE workspace_id = ? AND is_private = 0
+          AND (content LIKE ? OR summary LIKE ?)
+        ORDER BY created_at DESC
+        LIMIT ?
+      `);
+            const likeQuery = `%${query}%`;
+            const rows = stmt.all(workspaceId, likeQuery, likeQuery, limit);
+            return rows.map(row => ({
+                id: row.id,
+                snippet: row.summary || this.truncateToSnippet(row.content, 200),
+                type: row.type,
+                relevanceScore: 1,
+                createdAt: row.created_at,
+                taskId: row.task_id || undefined,
+            }));
+        }
+    }
+    /**
+     * Layer 2: Get timeline context around a specific memory
+     * Returns surrounding memories within a time window
+     */
+    getTimelineContext(memoryId, windowSize = 5) {
+        const memory = this.findById(memoryId);
+        if (!memory)
+            return [];
+        const stmt = this.db.prepare(`
+      SELECT id, content, type, created_at, task_id
+      FROM memories
+      WHERE workspace_id = ? AND is_private = 0
+        AND created_at BETWEEN ? AND ?
+      ORDER BY created_at ASC
+      LIMIT ?
+    `);
+        const timeWindow = 30 * 60 * 1000; // 30 minutes
+        const rows = stmt.all(memory.workspaceId, memory.createdAt - timeWindow, memory.createdAt + timeWindow, windowSize * 2 + 1);
+        return rows.map(row => ({
+            id: row.id,
+            content: row.content,
+            type: row.type,
+            createdAt: row.created_at,
+            taskId: row.task_id || undefined,
+        }));
+    }
+    /**
+     * Layer 3: Get full details for selected IDs
+     * Only called for specific memories when full content is needed
+     */
+    getFullDetails(ids) {
+        return this.findByIds(ids);
+    }
+    /**
+     * Get recent memories for context injection
+     */
+    getRecentForWorkspace(workspaceId, limit = 10) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE workspace_id = ? AND is_private = 0
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(workspaceId, limit);
+        return rows.map(row => this.mapRowToMemory(row));
+    }
+    /**
+     * Get uncompressed memories for batch compression
+     */
+    getUncompressed(limit = 50) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE is_compressed = 0 AND summary IS NULL
+      ORDER BY created_at ASC
+      LIMIT ?
+    `);
+        const rows = stmt.all(limit);
+        return rows.map(row => this.mapRowToMemory(row));
+    }
+    /**
+     * Find memories by workspace
+     */
+    findByWorkspace(workspaceId, limit = 100, offset = 0) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE workspace_id = ?
+      ORDER BY created_at DESC
+      LIMIT ? OFFSET ?
+    `);
+        const rows = stmt.all(workspaceId, limit, offset);
+        return rows.map(row => this.mapRowToMemory(row));
+    }
+    /**
+     * Find memories by task
+     */
+    findByTask(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE task_id = ?
+      ORDER BY created_at ASC
+    `);
+        const rows = stmt.all(taskId);
+        return rows.map(row => this.mapRowToMemory(row));
+    }
+    /**
+     * Cleanup old memories based on retention policy
+     */
+    deleteOlderThan(workspaceId, cutoffTimestamp) {
+        const stmt = this.db.prepare(`
+      DELETE FROM memories
+      WHERE workspace_id = ? AND created_at < ?
+    `);
+        const result = stmt.run(workspaceId, cutoffTimestamp);
+        return result.changes;
+    }
+    /**
+     * Delete all memories for a workspace
+     */
+    deleteByWorkspace(workspaceId) {
+        const stmt = this.db.prepare('DELETE FROM memories WHERE workspace_id = ?');
+        const result = stmt.run(workspaceId);
+        return result.changes;
+    }
+    /**
+     * Get storage statistics for a workspace
+     */
+    getStats(workspaceId) {
+        const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count,
+             COALESCE(SUM(tokens), 0) as total_tokens,
+             SUM(CASE WHEN is_compressed = 1 THEN 1 ELSE 0 END) as compressed_count
+      FROM memories
+      WHERE workspace_id = ?
+    `);
+        const row = stmt.get(workspaceId);
+        const count = row.count;
+        const compressedCount = row.compressed_count;
+        return {
+            count,
+            totalTokens: row.total_tokens,
+            compressedCount,
+            compressionRatio: count > 0 ? compressedCount / count : 0,
+        };
+    }
+    truncateToSnippet(content, maxChars) {
+        if (content.length <= maxChars)
+            return content;
+        return content.slice(0, maxChars - 3) + '...';
+    }
+    mapRowToMemory(row) {
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            taskId: row.task_id || undefined,
+            type: row.type,
+            content: row.content,
+            summary: row.summary || undefined,
+            tokens: row.tokens,
+            isCompressed: row.is_compressed === 1,
+            isPrivate: row.is_private === 1,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}
+exports.MemoryRepository = MemoryRepository;
+class MemorySummaryRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    create(summary) {
+        const newSummary = {
+            ...summary,
+            id: (0, uuid_1.v4)(),
+            createdAt: Date.now(),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO memory_summaries (id, workspace_id, time_period, period_start, period_end, summary, memory_ids, tokens, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(newSummary.id, newSummary.workspaceId, newSummary.timePeriod, newSummary.periodStart, newSummary.periodEnd, newSummary.summary, JSON.stringify(newSummary.memoryIds), newSummary.tokens, newSummary.createdAt);
+        return newSummary;
+    }
+    findByWorkspaceAndPeriod(workspaceId, timePeriod, limit = 10) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memory_summaries
+      WHERE workspace_id = ? AND time_period = ?
+      ORDER BY period_start DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(workspaceId, timePeriod, limit);
+        return rows.map(row => this.mapRowToSummary(row));
+    }
+    findByWorkspace(workspaceId, limit = 50) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memory_summaries
+      WHERE workspace_id = ?
+      ORDER BY period_start DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(workspaceId, limit);
+        return rows.map(row => this.mapRowToSummary(row));
+    }
+    deleteByWorkspace(workspaceId) {
+        const stmt = this.db.prepare('DELETE FROM memory_summaries WHERE workspace_id = ?');
+        const result = stmt.run(workspaceId);
+        return result.changes;
+    }
+    mapRowToSummary(row) {
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            timePeriod: row.time_period,
+            periodStart: row.period_start,
+            periodEnd: row.period_end,
+            summary: row.summary,
+            memoryIds: safeJsonParse(row.memory_ids, [], 'memorySummary.memoryIds'),
+            tokens: row.tokens,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.MemorySummaryRepository = MemorySummaryRepository;
+class MemorySettingsRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    getOrCreate(workspaceId) {
+        const stmt = this.db.prepare('SELECT * FROM memory_settings WHERE workspace_id = ?');
+        const row = stmt.get(workspaceId);
+        if (row) {
+            return this.mapRowToSettings(row);
+        }
+        // Create default settings
+        const defaults = {
+            workspaceId,
+            enabled: true,
+            autoCapture: true,
+            compressionEnabled: true,
+            retentionDays: 90,
+            maxStorageMb: 100,
+            privacyMode: 'normal',
+            excludedPatterns: [],
+        };
+        const insertStmt = this.db.prepare(`
+      INSERT INTO memory_settings (workspace_id, enabled, auto_capture, compression_enabled, retention_days, max_storage_mb, privacy_mode, excluded_patterns)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        insertStmt.run(defaults.workspaceId, defaults.enabled ? 1 : 0, defaults.autoCapture ? 1 : 0, defaults.compressionEnabled ? 1 : 0, defaults.retentionDays, defaults.maxStorageMb, defaults.privacyMode, JSON.stringify(defaults.excludedPatterns));
+        return defaults;
+    }
+    update(workspaceId, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.enabled !== undefined) {
+            fields.push('enabled = ?');
+            values.push(updates.enabled ? 1 : 0);
+        }
+        if (updates.autoCapture !== undefined) {
+            fields.push('auto_capture = ?');
+            values.push(updates.autoCapture ? 1 : 0);
+        }
+        if (updates.compressionEnabled !== undefined) {
+            fields.push('compression_enabled = ?');
+            values.push(updates.compressionEnabled ? 1 : 0);
+        }
+        if (updates.retentionDays !== undefined) {
+            fields.push('retention_days = ?');
+            values.push(updates.retentionDays);
+        }
+        if (updates.maxStorageMb !== undefined) {
+            fields.push('max_storage_mb = ?');
+            values.push(updates.maxStorageMb);
+        }
+        if (updates.privacyMode !== undefined) {
+            fields.push('privacy_mode = ?');
+            values.push(updates.privacyMode);
+        }
+        if (updates.excludedPatterns !== undefined) {
+            fields.push('excluded_patterns = ?');
+            values.push(JSON.stringify(updates.excludedPatterns));
+        }
+        if (fields.length === 0)
+            return;
+        values.push(workspaceId);
+        const stmt = this.db.prepare(`UPDATE memory_settings SET ${fields.join(', ')} WHERE workspace_id = ?`);
+        stmt.run(...values);
+    }
+    delete(workspaceId) {
+        const stmt = this.db.prepare('DELETE FROM memory_settings WHERE workspace_id = ?');
+        stmt.run(workspaceId);
+    }
+    mapRowToSettings(row) {
+        return {
+            workspaceId: row.workspace_id,
+            enabled: row.enabled === 1,
+            autoCapture: row.auto_capture === 1,
+            compressionEnabled: row.compression_enabled === 1,
+            retentionDays: row.retention_days,
+            maxStorageMb: row.max_storage_mb,
+            privacyMode: row.privacy_mode,
+            excludedPatterns: safeJsonParse(row.excluded_patterns, [], 'memorySettings.excludedPatterns'),
+        };
+    }
+}
+exports.MemorySettingsRepository = MemorySettingsRepository;