devchain-cli 0.1.0

package/dist/server/modules/storage/local/local-storage.service.js

@@ -0,0 +1,2069 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageService = void 0;
+const common_1 = require("@nestjs/common");
+const better_sqlite3_1 = require("drizzle-orm/better-sqlite3");
+const db_provider_1 = require("../db/db.provider");
+const error_types_1 = require("../../../common/errors/error-types");
+const logger_1 = require("../../../common/logging/logger");
+const sqlite_raw_1 = require("../db/sqlite-raw");
+const feature_flags_1 = require("../../../common/config/feature-flags");
+const logger = (0, logger_1.createLogger)('LocalStorageService');
+let LocalStorageService = class LocalStorageService {
+    constructor(db) {
+        this.db = db;
+        logger.info('LocalStorageService initialized');
+    }
+    getFeatureFlags() {
+        return { ...feature_flags_1.DEFAULT_FEATURE_FLAGS };
+    }
+    async ensureValidEpicParent(projectId, parentId, childId) {
+        if (!parentId) {
+            return;
+        }
+        if (childId && parentId === childId) {
+            throw new error_types_1.ValidationError('An epic cannot be its own parent.', {
+                epicId: childId,
+                parentId,
+            });
+        }
+        const parent = await this.getEpic(parentId);
+        if (parent.projectId !== projectId) {
+            throw new error_types_1.ValidationError('Parent epic must belong to the same project.', {
+                projectId,
+                parentProjectId: parent.projectId,
+                parentId,
+            });
+        }
+        if (parent.parentId) {
+            throw new error_types_1.ValidationError('Cannot assign a sub-epic as a parent (one-level hierarchy).', {
+                parentId,
+            });
+        }
+        if (childId) {
+            const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+            const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+            const descendants = await this.db
+                .select({ id: epics.id })
+                .from(epics)
+                .where(eq(epics.parentId, childId));
+            if (descendants.some((row) => row.id === parentId)) {
+                throw new error_types_1.ValidationError('Cannot assign a descendant as the parent epic.', {
+                    parentId,
+                    epicId: childId,
+                });
+            }
+        }
+    }
+    async ensureValidAgent(projectId, agentId) {
+        if (!agentId) {
+            return;
+        }
+        const agent = await this.getAgent(agentId);
+        if (agent.projectId !== projectId) {
+            throw new error_types_1.ValidationError('Agent must belong to the same project as the epic.', {
+                projectId,
+                agentProjectId: agent.projectId,
+                agentId,
+            });
+        }
+    }
+    async createProject(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const project = {
+            id: randomUUID(),
+            ...data,
+            isTemplate: data.isTemplate ?? false,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const { projects, statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        await this.db.transaction(async (tx) => {
+            await tx.insert(projects).values({
+                id: project.id,
+                name: project.name,
+                description: project.description,
+                rootPath: project.rootPath,
+                isTemplate: project.isTemplate,
+                createdAt: project.createdAt,
+                updatedAt: project.updatedAt,
+            });
+            const defaultStatuses = [
+                { label: 'Proposed', color: '#6c757d', position: 0 },
+                { label: 'In Progress', color: '#007bff', position: 1 },
+                { label: 'Review', color: '#ffc107', position: 2 },
+                { label: 'Done', color: '#28a745', position: 3 },
+                { label: 'Blocked', color: '#dc3545', position: 4 },
+            ];
+            for (const status of defaultStatuses) {
+                await tx.insert(statuses).values({
+                    id: randomUUID(),
+                    projectId: project.id,
+                    label: status.label,
+                    color: status.color,
+                    position: status.position,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+            }
+        });
+        logger.info({ projectId: project.id }, 'Created project with default statuses (transactional)');
+        return project;
+    }
+    async createProjectWithTemplate(data, template) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const project = {
+            id: randomUUID(),
+            ...data,
+            isTemplate: data.isTemplate ?? false,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const { projects, statuses, prompts, agentProfiles, agents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const statusIdMap = {};
+        const promptIdMap = {};
+        const profileIdMap = {};
+        const agentIdMap = {};
+        const createdPrompts = [];
+        const sqlite = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        if (!sqlite || typeof sqlite.exec !== 'function') {
+            throw new error_types_1.StorageError('Unable to access underlying SQLite client for transaction control');
+        }
+        sqlite.exec('BEGIN IMMEDIATE TRANSACTION');
+        try {
+            await this.db.insert(projects).values({
+                id: project.id,
+                name: project.name,
+                description: project.description,
+                rootPath: project.rootPath,
+                isTemplate: project.isTemplate,
+                createdAt: project.createdAt,
+                updatedAt: project.updatedAt,
+            });
+            for (const s of template.statuses.sort((a, b) => a.position - b.position)) {
+                const statusId = randomUUID();
+                await this.db.insert(statuses).values({
+                    id: statusId,
+                    projectId: project.id,
+                    label: s.label,
+                    color: s.color,
+                    position: s.position,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (s.id)
+                    statusIdMap[s.id] = statusId;
+            }
+            for (const p of template.prompts) {
+                const promptId = randomUUID();
+                await this.db.insert(prompts).values({
+                    id: promptId,
+                    projectId: project.id,
+                    title: p.title,
+                    content: p.content ?? '',
+                    version: 1,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (p.id)
+                    promptIdMap[p.id] = promptId;
+                createdPrompts.push({ id: promptId, title: p.title });
+            }
+            for (const prof of template.profiles) {
+                const profileId = randomUUID();
+                await this.db.insert(agentProfiles).values({
+                    id: profileId,
+                    projectId: project.id,
+                    name: prof.name,
+                    providerId: prof.providerId,
+                    options: prof.options,
+                    systemPrompt: null,
+                    instructions: prof.instructions,
+                    temperature: prof.temperature,
+                    maxTokens: prof.maxTokens,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (prof.id)
+                    profileIdMap[prof.id] = profileId;
+            }
+            for (const a of template.agents) {
+                const oldProfileId = a.profileId ?? '';
+                const newProfileId = oldProfileId && profileIdMap[oldProfileId] ? profileIdMap[oldProfileId] : undefined;
+                if (!newProfileId) {
+                    throw new error_types_1.ValidationError(`Profile mapping missing for agent ${a.name}`, {
+                        profileId: oldProfileId || null,
+                    });
+                }
+                const agentId = randomUUID();
+                await this.db.insert(agents).values({
+                    id: agentId,
+                    projectId: project.id,
+                    name: a.name,
+                    profileId: newProfileId,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (a.id)
+                    agentIdMap[a.id] = agentId;
+            }
+            sqlite.exec('COMMIT');
+            logger.info({ projectId: project.id, counts: template }, 'Created project with template (transactional)');
+        }
+        catch (error) {
+            try {
+                sqlite.exec('ROLLBACK');
+                logger.info({ projectId: project.id }, 'Transaction rolled back successfully');
+            }
+            catch (rollbackError) {
+                logger.error({ rollbackError }, 'Failed to rollback transaction');
+            }
+            logger.error({ error, projectId: project.id }, 'Transaction failed');
+            throw error;
+        }
+        return {
+            project,
+            imported: {
+                prompts: template.prompts.length,
+                profiles: template.profiles.length,
+                agents: template.agents.length,
+                statuses: template.statuses.length,
+            },
+            mappings: {
+                promptIdMap,
+                profileIdMap,
+                agentIdMap,
+                statusIdMap,
+            },
+            initialPromptSet: false,
+        };
+    }
+    async getProject(id) {
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(projects).where(eq(projects.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Project', id);
+        }
+        const row = result[0];
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            rootPath: row.rootPath,
+            isTemplate: Boolean(row.isTemplate ?? false),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    async findProjectByPath(path) {
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db
+            .select()
+            .from(projects)
+            .where(eq(projects.rootPath, path))
+            .limit(1);
+        if (!result[0])
+            return null;
+        const row = result[0];
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            rootPath: row.rootPath,
+            isTemplate: Boolean(row.isTemplate ?? false),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    async listProjects(options = {}) {
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db.select().from(projects).limit(limit).offset(offset);
+        const countResult = await this.db.select({ count: sql `count(*)` }).from(projects);
+        const total = Number(countResult[0]?.count ?? 0);
+        const mapped = items.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            rootPath: row.rootPath,
+            isTemplate: Boolean(row.isTemplate ?? false),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        }));
+        return {
+            items: mapped,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async updateProject(id, data) {
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        await this.db
+            .update(projects)
+            .set({ ...data, updatedAt: now })
+            .where(eq(projects.id, id));
+        return this.getProject(id);
+    }
+    async deleteProject(id) {
+        const { projects, chatThreads, chatMessages, chatMembers, chatMessageTargets, chatMessageReads, chatThreadSessionInvites, chatActivities, sessions, transcripts, epicComments, records, recordTags, epicTags, epics, documents, documentTags, prompts, promptTags, agentProfilePrompts, agents, agentProfiles, tags, statuses, } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const projectEpics = await this.db
+            .select({ id: epics.id })
+            .from(epics)
+            .where(eq(epics.projectId, id));
+        const epicIds = projectEpics.map((e) => e.id);
+        const projectChatThreads = await this.db
+            .select({ id: chatThreads.id })
+            .from(chatThreads)
+            .where(eq(chatThreads.projectId, id));
+        const threadIds = projectChatThreads.map((t) => t.id);
+        const projectMessages = threadIds.length > 0
+            ? await this.db
+                .select({ id: chatMessages.id })
+                .from(chatMessages)
+                .where(inArray(chatMessages.threadId, threadIds))
+            : [];
+        const messageIds = projectMessages.map((m) => m.id);
+        const projectAgents = await this.db
+            .select({ id: agents.id })
+            .from(agents)
+            .where(eq(agents.projectId, id));
+        const agentIds = projectAgents.map((a) => a.id);
+        const projectDocs = await this.db
+            .select({ id: documents.id })
+            .from(documents)
+            .where(eq(documents.projectId, id));
+        const docIds = projectDocs.map((d) => d.id);
+        const projectPrompts = await this.db
+            .select({ id: prompts.id })
+            .from(prompts)
+            .where(eq(prompts.projectId, id));
+        const promptIds = projectPrompts.map((p) => p.id);
+        const projectProfiles = await this.db
+            .select({ id: agentProfiles.id })
+            .from(agentProfiles)
+            .where(eq(agentProfiles.projectId, id));
+        const profileIds = projectProfiles.map((p) => p.id);
+        const projectTags = await this.db
+            .select({ id: tags.id })
+            .from(tags)
+            .where(eq(tags.projectId, id));
+        const tagIds = projectTags.map((t) => t.id);
+        const projectSessions = agentIds.length > 0
+            ? await this.db
+                .select({ id: sessions.id })
+                .from(sessions)
+                .where(inArray(sessions.agentId, agentIds))
+            : [];
+        const sessionIds = projectSessions.map((s) => s.id);
+        if (messageIds.length > 0) {
+            await this.db.delete(chatMessageReads).where(inArray(chatMessageReads.messageId, messageIds));
+            await this.db
+                .delete(chatMessageTargets)
+                .where(inArray(chatMessageTargets.messageId, messageIds));
+            await this.db
+                .delete(chatThreadSessionInvites)
+                .where(inArray(chatThreadSessionInvites.inviteMessageId, messageIds));
+        }
+        if (agentIds.length > 0) {
+            await this.db.delete(chatMessageReads).where(inArray(chatMessageReads.agentId, agentIds));
+            await this.db.delete(chatMessageTargets).where(inArray(chatMessageTargets.agentId, agentIds));
+            await this.db
+                .delete(chatThreadSessionInvites)
+                .where(inArray(chatThreadSessionInvites.agentId, agentIds));
+            await this.db.delete(chatActivities).where(inArray(chatActivities.agentId, agentIds));
+            await this.db.delete(chatMembers).where(inArray(chatMembers.agentId, agentIds));
+        }
+        if (messageIds.length > 0) {
+            await this.db.delete(chatMessages).where(inArray(chatMessages.threadId, threadIds));
+        }
+        if (threadIds.length > 0) {
+            await this.db.delete(chatThreads).where(inArray(chatThreads.id, threadIds));
+        }
+        if (sessionIds.length > 0) {
+            await this.db.delete(transcripts).where(inArray(transcripts.sessionId, sessionIds));
+            await this.db.delete(sessions).where(inArray(sessions.id, sessionIds));
+        }
+        if (epicIds.length > 0) {
+            await this.db.delete(epicComments).where(inArray(epicComments.epicId, epicIds));
+            const projectRecords = await this.db
+                .select({ id: records.id })
+                .from(records)
+                .where(inArray(records.epicId, epicIds));
+            const recordIds = projectRecords.map((r) => r.id);
+            if (recordIds.length > 0) {
+                await this.db.delete(recordTags).where(inArray(recordTags.recordId, recordIds));
+                await this.db.delete(records).where(inArray(records.id, recordIds));
+            }
+            await this.db.delete(epicTags).where(inArray(epicTags.epicId, epicIds));
+        }
+        if (epicIds.length > 0) {
+            await this.db.delete(epics).where(inArray(epics.id, epicIds));
+        }
+        if (docIds.length > 0) {
+            await this.db.delete(documentTags).where(inArray(documentTags.documentId, docIds));
+            await this.db.delete(documents).where(inArray(documents.id, docIds));
+        }
+        if (promptIds.length > 0) {
+            await this.db.delete(promptTags).where(inArray(promptTags.promptId, promptIds));
+            await this.db
+                .delete(agentProfilePrompts)
+                .where(inArray(agentProfilePrompts.promptId, promptIds));
+            await this.db.delete(prompts).where(inArray(prompts.id, promptIds));
+        }
+        if (agentIds.length > 0) {
+            await this.db.delete(agents).where(inArray(agents.id, agentIds));
+        }
+        if (profileIds.length > 0) {
+            await this.db
+                .delete(agentProfilePrompts)
+                .where(inArray(agentProfilePrompts.profileId, profileIds));
+            await this.db.delete(agentProfiles).where(inArray(agentProfiles.id, profileIds));
+        }
+        if (tagIds.length > 0) {
+            await this.db.delete(tags).where(inArray(tags.id, tagIds));
+        }
+        await this.db.delete(statuses).where(eq(statuses.projectId, id));
+        await this.db.delete(projects).where(eq(projects.id, id));
+        logger.info({ projectId: id }, 'Deleted project and all related records');
+    }
+    async createStatus(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const status = {
+            id: randomUUID(),
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(statuses).values({
+            id: status.id,
+            projectId: status.projectId,
+            label: status.label,
+            color: status.color,
+            position: status.position,
+            createdAt: status.createdAt,
+            updatedAt: status.updatedAt,
+        });
+        return status;
+    }
+    async getStatus(id) {
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(statuses).where(eq(statuses.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Status', id);
+        }
+        return result[0];
+    }
+    async listStatuses(projectId, options = {}) {
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, asc, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(statuses)
+            .where(eq(statuses.projectId, projectId))
+            .orderBy(asc(statuses.position))
+            .limit(limit)
+            .offset(offset);
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(statuses)
+            .where(eq(statuses.projectId, projectId));
+        const total = Number(totalResult[0]?.count ?? 0);
+        return {
+            items: items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async findStatusByName(projectId, name) {
+        const normalized = name.trim().toLowerCase();
+        if (!normalized) {
+            return null;
+        }
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db
+            .select()
+            .from(statuses)
+            .where(and(eq(statuses.projectId, projectId), sql `lower(${statuses.label}) = ${normalized}`))
+            .limit(1);
+        return result[0] ? result[0] : null;
+    }
+    async updateStatus(id, data) {
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        await this.db
+            .update(statuses)
+            .set({ ...data, updatedAt: now })
+            .where(eq(statuses.id, id));
+        return this.getStatus(id);
+    }
+    async deleteStatus(id) {
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(statuses).where(eq(statuses.id, id));
+    }
+    async createEpic(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { epics, epicTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const epicId = randomUUID();
+        await this.ensureValidEpicParent(data.projectId, data.parentId ?? null, epicId);
+        await this.ensureValidAgent(data.projectId, data.agentId ?? null);
+        const epic = {
+            id: epicId,
+            projectId: data.projectId,
+            title: data.title,
+            description: data.description ?? null,
+            statusId: data.statusId,
+            parentId: data.parentId ?? null,
+            agentId: data.agentId ?? null,
+            version: 1,
+            data: data.data ?? null,
+            tags: data.tags ?? [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(epics).values({
+            id: epic.id,
+            projectId: epic.projectId,
+            title: epic.title,
+            description: epic.description,
+            statusId: epic.statusId,
+            parentId: epic.parentId,
+            agentId: epic.agentId,
+            version: epic.version,
+            data: epic.data ? JSON.stringify(epic.data) : null,
+            createdAt: epic.createdAt,
+            updatedAt: epic.updatedAt,
+        });
+        if (epic.tags.length) {
+            for (const tagName of epic.tags) {
+                const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+                let tag = await this.db
+                    .select()
+                    .from(tags)
+                    .where(and(eq(tags.name, tagName), or(eq(tags.projectId, data.projectId), isNull(tags.projectId))))
+                    .limit(1);
+                if (!tag[0]) {
+                    const newTag = await this.createTag({ projectId: data.projectId, name: tagName });
+                    tag = [newTag];
+                }
+                await this.db.insert(epicTags).values({
+                    epicId: epic.id,
+                    tagId: tag[0].id,
+                    createdAt: now,
+                });
+            }
+        }
+        return epic;
+    }
+    async getEpic(id) {
+        const { epics, epicTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(epics).where(eq(epics.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Epic', id);
+        }
+        const epicTagsResult = await this.db
+            .select({ tag: tags })
+            .from(epicTags)
+            .innerJoin(tags, eq(epicTags.tagId, tags.id))
+            .where(eq(epicTags.epicId, id));
+        return {
+            ...result[0],
+            tags: epicTagsResult.map((et) => et.tag.name),
+        };
+    }
+    async listEpics(projectId, options = {}) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epics)
+            .where(eq(epics.projectId, projectId))
+            .limit(limit)
+            .offset(offset);
+        const itemsWithTags = await Promise.all(items.map((item) => this.getEpic(item.id)));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async listEpicsByStatus(statusId, options = {}) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epics)
+            .where(eq(epics.statusId, statusId))
+            .limit(limit)
+            .offset(offset);
+        const itemsWithTags = await Promise.all(items.map((item) => this.getEpic(item.id)));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async listProjectEpics(projectId, options = {}) {
+        const { epics, statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, sql, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const conditions = [eq(epics.projectId, projectId)];
+        if (options.q) {
+            const search = options.q.trim().toLowerCase();
+            if (search.length) {
+                const pattern = `%${search}%`;
+                conditions.push(sql `(lower(${epics.title}) LIKE ${pattern} OR lower(ifnull(${epics.description}, '')) LIKE ${pattern})`);
+            }
+        }
+        if (options.statusId) {
+            conditions.push(eq(epics.statusId, options.statusId));
+        }
+        const listType = (options.type ?? 'active').toLowerCase();
+        let archivedFilter = null;
+        if (listType === 'active') {
+            archivedFilter = sql `lower(${statuses.label}) NOT LIKE '%archiv%'`;
+        }
+        else if (listType === 'archived') {
+            archivedFilter = sql `lower(${statuses.label}) LIKE '%archiv%'`;
+        }
+        if (archivedFilter) {
+            conditions.push(archivedFilter);
+        }
+        const whereClause = and(...conditions);
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(epics)
+            .innerJoin(statuses, eq(statuses.id, epics.statusId))
+            .where(whereClause);
+        const total = Number(totalResult[0]?.count ?? 0);
+        const rows = await this.db
+            .select({ id: epics.id })
+            .from(epics)
+            .innerJoin(statuses, eq(statuses.id, epics.statusId))
+            .where(whereClause)
+            .orderBy(desc(epics.updatedAt))
+            .limit(limit)
+            .offset(offset);
+        const items = await Promise.all(rows.map((row) => this.getEpic(row.id)));
+        return {
+            items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async listAssignedEpics(projectId, options) {
+        if (!options.agentName?.trim()) {
+            throw new error_types_1.ValidationError('agentName is required to list assigned epics.', {
+                projectId,
+            });
+        }
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq, sql, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const agent = await this.getAgentByName(projectId, options.agentName);
+        const whereClause = and(eq(epics.projectId, projectId), eq(epics.agentId, agent.id));
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(epics)
+            .where(whereClause);
+        const total = Number(totalResult[0]?.count ?? 0);
+        const rows = await this.db
+            .select({ id: epics.id })
+            .from(epics)
+            .where(whereClause)
+            .orderBy(desc(epics.updatedAt))
+            .limit(limit)
+            .offset(offset);
+        const items = await Promise.all(rows.map((row) => this.getEpic(row.id)));
+        return {
+            items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async createEpicForProject(projectId, input) {
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, asc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        let statusId = input.statusId ?? null;
+        if (statusId) {
+            const status = await this.getStatus(statusId);
+            if (status.projectId !== projectId) {
+                throw new error_types_1.ValidationError('Status must belong to the target project.', {
+                    statusId,
+                    projectId,
+                    statusProjectId: status.projectId,
+                });
+            }
+        }
+        else {
+            const defaultStatusResult = await this.db
+                .select({ id: statuses.id })
+                .from(statuses)
+                .where(eq(statuses.projectId, projectId))
+                .orderBy(asc(statuses.position))
+                .limit(1);
+            const defaultStatus = defaultStatusResult[0];
+            if (!defaultStatus) {
+                throw new error_types_1.ValidationError('Project has no statuses configured.', { projectId });
+            }
+            statusId = defaultStatus.id;
+        }
+        let agentId = input.agentId ?? null;
+        if (!agentId && input.agentName?.trim()) {
+            const agent = await this.getAgentByName(projectId, input.agentName);
+            agentId = agent.id;
+        }
+        await this.ensureValidAgent(projectId, agentId);
+        await this.ensureValidEpicParent(projectId, input.parentId ?? null);
+        return this.createEpic({
+            projectId,
+            title: input.title,
+            description: input.description ?? null,
+            statusId,
+            parentId: input.parentId ?? null,
+            agentId,
+            tags: input.tags ?? [],
+            data: null,
+        });
+    }
+    async updateEpic(id, data, expectedVersion) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const current = await this.getEpic(id);
+        if (current.version !== expectedVersion) {
+            throw new error_types_1.OptimisticLockError('Epic', id, {
+                expectedVersion,
+                actualVersion: current.version,
+            });
+        }
+        if (data.parentId !== undefined) {
+            await this.ensureValidEpicParent(current.projectId, data.parentId ?? null, id);
+        }
+        if (data.agentId !== undefined) {
+            await this.ensureValidAgent(current.projectId, data.agentId ?? null);
+        }
+        const updateData = { ...data };
+        if (data.data !== undefined) {
+            updateData.data = JSON.stringify(data.data);
+        }
+        for (const key of Object.keys(updateData)) {
+            if (updateData[key] === undefined) {
+                delete updateData[key];
+            }
+        }
+        await this.db
+            .update(epics)
+            .set({ ...updateData, version: expectedVersion + 1, updatedAt: now })
+            .where(eq(epics.id, id));
+        return this.getEpic(id);
+    }
+    async deleteEpic(id) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const subEpics = await this.db
+            .select({ id: epics.id })
+            .from(epics)
+            .where(eq(epics.parentId, id));
+        for (const subEpic of subEpics) {
+            await this.deleteEpic(subEpic.id);
+        }
+        await this.db.delete(epics).where(eq(epics.id, id));
+        logger.info({ epicId: id, deletedSubEpics: subEpics.length }, 'Deleted epic and sub-epics');
+    }
+    async listSubEpics(parentId, options = {}) {
+        await this.getEpic(parentId);
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epics)
+            .where(eq(epics.parentId, parentId))
+            .limit(limit)
+            .offset(offset);
+        const itemsWithTags = await Promise.all(items.map((item) => this.getEpic(item.id)));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async countSubEpicsByStatus(parentId) {
+        await this.getEpic(parentId);
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({ statusId: epics.statusId })
+            .from(epics)
+            .where(eq(epics.parentId, parentId));
+        return rows.reduce((acc, row) => {
+            const key = row.statusId;
+            acc[key] = (acc[key] ?? 0) + 1;
+            return acc;
+        }, {});
+    }
+    async listEpicComments(epicId, options = {}) {
+        await this.getEpic(epicId);
+        const { epicComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, asc, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epicComments)
+            .where(eq(epicComments.epicId, epicId))
+            .orderBy(asc(epicComments.createdAt))
+            .limit(limit)
+            .offset(offset);
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(epicComments)
+            .where(eq(epicComments.epicId, epicId));
+        const total = Number(totalResult[0]?.count ?? 0);
+        return {
+            items: items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async createEpicComment(data) {
+        await this.getEpic(data.epicId);
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const { epicComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const now = new Date().toISOString();
+        const comment = {
+            id: randomUUID(),
+            epicId: data.epicId,
+            authorName: data.authorName,
+            content: data.content,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(epicComments).values({
+            id: comment.id,
+            epicId: comment.epicId,
+            authorName: comment.authorName,
+            content: comment.content,
+            createdAt: comment.createdAt,
+            updatedAt: comment.updatedAt,
+        });
+        return comment;
+    }
+    async deleteEpicComment(id) {
+        const { epicComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(epicComments).where(eq(epicComments.id, id));
+    }
+    async createPrompt(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { prompts, promptTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const prompt = {
+            id: randomUUID(),
+            ...data,
+            version: 1,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(prompts).values({
+            id: prompt.id,
+            projectId: prompt.projectId,
+            title: prompt.title,
+            content: prompt.content,
+            version: prompt.version,
+            createdAt: prompt.createdAt,
+            updatedAt: prompt.updatedAt,
+        });
+        if (data.tags?.length) {
+            for (const tagName of data.tags) {
+                const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+                let tag = await this.db
+                    .select()
+                    .from(tags)
+                    .where(and(eq(tags.name, tagName), or(eq(tags.projectId, data.projectId || ''), isNull(tags.projectId))))
+                    .limit(1);
+                if (!tag[0]) {
+                    const newTag = await this.createTag({ projectId: data.projectId, name: tagName });
+                    tag = [newTag];
+                }
+                await this.db.insert(promptTags).values({
+                    promptId: prompt.id,
+                    tagId: tag[0].id,
+                    createdAt: now,
+                });
+            }
+        }
+        return prompt;
+    }
+    async getPrompt(id) {
+        const { prompts, promptTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(prompts).where(eq(prompts.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Prompt', id);
+        }
+        const promptTagsResult = await this.db
+            .select({ tag: tags })
+            .from(promptTags)
+            .innerJoin(tags, eq(promptTags.tagId, tags.id))
+            .where(eq(promptTags.promptId, id));
+        return {
+            ...result[0],
+            tags: promptTagsResult.map((pt) => pt.tag.name),
+        };
+    }
+    async listPrompts(projectId, options = {}) {
+        const { prompts } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const query = projectId ? eq(prompts.projectId, projectId) : undefined;
+        const items = await this.db.select().from(prompts).where(query).limit(limit).offset(offset);
+        const itemsWithTags = await Promise.all(items.map((item) => this.getPrompt(item.id)));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async updatePrompt(id, data, expectedVersion) {
+        const { prompts, promptTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        logger.info({ id, data, expectedVersion }, 'updatePrompt called with data');
+        const current = await this.getPrompt(id);
+        if (current.version !== expectedVersion) {
+            throw new error_types_1.OptimisticLockError('Prompt', id, {
+                expectedVersion,
+                actualVersion: current.version,
+            });
+        }
+        const { tags: newTags, ...updateData } = data;
+        logger.info({ newTags, updateData }, 'Separated tags from updateData');
+        await this.db
+            .update(prompts)
+            .set({ ...updateData, version: expectedVersion + 1, updatedAt: now })
+            .where(eq(prompts.id, id));
+        logger.info('Updated prompt fields in database');
+        if (newTags !== undefined) {
+            logger.info({ newTags, newTagsLength: newTags.length }, 'Updating tags');
+            await this.db.delete(promptTags).where(eq(promptTags.promptId, id));
+            logger.info('Deleted existing prompt tags');
+            if (newTags.length > 0) {
+                for (const tagName of newTags) {
+                    logger.info({ tagName }, 'Processing tag');
+                    const { and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+                    let tag = await this.db
+                        .select()
+                        .from(tags)
+                        .where(and(eq(tags.name, tagName), or(eq(tags.projectId, current.projectId || ''), isNull(tags.projectId))))
+                        .limit(1);
+                    if (!tag[0]) {
+                        logger.info({ tagName }, 'Tag not found, creating new tag');
+                        const newTag = await this.createTag({ projectId: current.projectId, name: tagName });
+                        tag = [newTag];
+                    }
+                    else {
+                        logger.info({ tagName, tagId: tag[0].id }, 'Found existing tag');
+                    }
+                    await this.db.insert(promptTags).values({
+                        promptId: id,
+                        tagId: tag[0].id,
+                        createdAt: now,
+                    });
+                    logger.info({ tagName, tagId: tag[0].id }, 'Inserted prompt tag');
+                }
+            }
+        }
+        else {
+            logger.info('No tags provided in update data');
+        }
+        return this.getPrompt(id);
+    }
+    async deletePrompt(id) {
+        const { prompts } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(prompts).where(eq(prompts.id, id));
+    }
+    async getInitialSessionPrompt(projectId) {
+        const { settings } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        let rawValue;
+        try {
+            const mapRows = await this.db
+                .select({ value: settings.value })
+                .from(settings)
+                .where(eq(settings.key, 'initialSessionPromptIds'))
+                .limit(1);
+            const mapRaw = mapRows[0]?.value;
+            const promptIdFromMap = this.extractPromptIdFromMap(mapRaw, projectId);
+            if (promptIdFromMap) {
+                rawValue = promptIdFromMap;
+            }
+            else {
+                const result = await this.db
+                    .select({ value: settings.value })
+                    .from(settings)
+                    .where(eq(settings.key, 'initialSessionPromptId'))
+                    .limit(1);
+                rawValue = result[0]?.value;
+            }
+        }
+        catch (error) {
+            logger.warn({ error }, 'Drizzle read failed for initialSessionPromptId; falling back to raw SQLite');
+            try {
+                const mapRow = (0, sqlite_raw_1.getRawSqliteClient)(this.db)
+                    .prepare('SELECT value FROM settings WHERE key = ? LIMIT 1')
+                    .get('initialSessionPromptIds');
+                const fromMap = this.extractPromptIdFromMap(mapRow?.value, projectId);
+                if (fromMap) {
+                    rawValue = fromMap;
+                }
+                else {
+                    const row = (0, sqlite_raw_1.getRawSqliteClient)(this.db)
+                        .prepare('SELECT value FROM settings WHERE key = ? LIMIT 1')
+                        .get('initialSessionPromptId');
+                    rawValue = row?.value;
+                }
+            }
+            catch (sqliteError) {
+                logger.error({ sqliteError }, 'Raw SQLite read failed for initialSessionPromptId');
+                return null;
+            }
+        }
+        const promptId = typeof rawValue === 'string' ? rawValue : this.extractPromptId(rawValue);
+        logger.debug({ rawType: typeof rawValue, rawValue: safePreview(rawValue), promptId }, 'Resolved initial session prompt id from settings');
+        if (!promptId) {
+            return null;
+        }
+        try {
+            return await this.getPrompt(promptId);
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                logger.warn({ promptId }, 'Initial session prompt not found');
+                return null;
+            }
+            throw error;
+        }
+    }
+    extractPromptId(value) {
+        if (value === undefined || value === null) {
+            return null;
+        }
+        if (typeof value === 'object') {
+            if ('initialSessionPromptId' in value) {
+                return this.extractPromptId(value.initialSessionPromptId);
+            }
+            if ('value' in value) {
+                return this.extractPromptId(value.value);
+            }
+            return null;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return null;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                return this.extractPromptId(parsed);
+            }
+            catch {
+            }
+            if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+                return trimmed.slice(1, -1).trim() || null;
+            }
+            return trimmed;
+        }
+        return String(value).trim() || null;
+    }
+    extractPromptIdFromMap(value, projectId) {
+        try {
+            const obj = typeof value === 'string' ? JSON.parse(value) : value;
+            if (obj && typeof obj === 'object') {
+                const map = obj;
+                if (projectId && typeof map[projectId] === 'string') {
+                    const v = map[projectId].trim();
+                    return v || null;
+                }
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    async listDocuments(filters = {}) {
+        const { documents, documentTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq, isNull, like, or, desc, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const whereClauses = [];
+        if (filters.projectId !== undefined) {
+            whereClauses.push(filters.projectId === null
+                ? isNull(documents.projectId)
+                : eq(documents.projectId, filters.projectId));
+        }
+        const tagKeys = this.normalizeTagList(filters.tagKeys);
+        if (tagKeys.length) {
+            for (const key of tagKeys) {
+                whereClauses.push(sql `EXISTS (
+            SELECT 1
+            FROM ${documentTags} dt
+            INNER JOIN ${tags} t ON t.id = dt.tag_id
+            WHERE dt.document_id = ${documents.id}
+              AND (
+                (
+                  CASE
+                    WHEN instr(t.name, ':') > 0 THEN substr(t.name, 1, instr(t.name, ':') - 1)
+                    ELSE NULL
+                  END
+                ) = ${key}
+                OR t.name = ${key}
+              )
+          )`);
+            }
+        }
+        const searchTerm = filters.q?.trim();
+        if (searchTerm) {
+            const pattern = `%${searchTerm}%`;
+            whereClauses.push(or(like(documents.title, pattern), like(documents.contentMd, pattern)));
+        }
+        const whereCondition = whereClauses.length === 0
+            ? undefined
+            : whereClauses.length === 1
+                ? whereClauses[0]
+                : and(...whereClauses);
+        const rows = await (whereCondition
+            ? this.db.select().from(documents).where(whereCondition).orderBy(desc(documents.updatedAt))
+            : this.db.select().from(documents).orderBy(desc(documents.updatedAt)));
+        if (!rows.length) {
+            return {
+                items: [],
+                total: 0,
+                limit: filters.limit ?? 100,
+                offset: filters.offset ?? 0,
+            };
+        }
+        const documentsWithTags = await Promise.all(rows.map((row) => this.getDocument({ id: row.id })));
+        let filtered = documentsWithTags;
+        if (filters.tags?.length) {
+            const requiredTags = this.normalizeTagList(filters.tags);
+            filtered = documentsWithTags.filter((doc) => requiredTags.every((tag) => doc.tags.includes(tag)));
+        }
+        const limit = filters.limit ?? 100;
+        const offset = filters.offset ?? 0;
+        const items = filtered.slice(offset, offset + limit);
+        return {
+            items,
+            total: filtered.length,
+            limit,
+            offset,
+        };
+    }
+    async getDocument(identifier) {
+        const { documents, documentTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        let whereCondition;
+        if (identifier.id) {
+            whereCondition = eq(documents.id, identifier.id);
+        }
+        else if (identifier.slug) {
+            if (identifier.projectId === undefined) {
+                throw new error_types_1.ValidationError('projectId is required when querying document by slug');
+            }
+            whereCondition =
+                identifier.projectId === null
+                    ? and(isNull(documents.projectId), eq(documents.slug, identifier.slug))
+                    : and(eq(documents.projectId, identifier.projectId), eq(documents.slug, identifier.slug));
+        }
+        else {
+            throw new error_types_1.ValidationError('Document identifier requires either id or slug');
+        }
+        const result = await this.db.select().from(documents).where(whereCondition).limit(1);
+        const record = result[0];
+        if (!record) {
+            const lookup = identifier.id ?? `${identifier.projectId ?? 'global'}:${identifier.slug}`;
+            throw new error_types_1.NotFoundError('Document', lookup || 'unknown');
+        }
+        const tagRows = await this.db
+            .select({ tag: tags })
+            .from(documentTags)
+            .innerJoin(tags, eq(documentTags.tagId, tags.id))
+            .where(eq(documentTags.documentId, record.id));
+        return {
+            ...record,
+            projectId: record.projectId ?? null,
+            tags: tagRows.map((row) => row.tag.name),
+        };
+    }
+    async createDocument(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const normalizedProjectId = data.projectId ?? null;
+        const { documents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const slugSource = data.slug ?? data.title;
+        const slug = await this.generateDocumentSlug(normalizedProjectId, slugSource);
+        const tags = this.normalizeTagList(data.tags);
+        const id = randomUUID();
+        await this.db.insert(documents).values({
+            id,
+            projectId: normalizedProjectId,
+            title: data.title,
+            slug,
+            contentMd: data.contentMd,
+            version: 1,
+            archived: false,
+            createdAt: now,
+            updatedAt: now,
+        });
+        if (tags.length) {
+            await this.setDocumentTags(id, tags, normalizedProjectId);
+        }
+        logger.info({ documentId: id }, 'Created document');
+        return this.getDocument({ id });
+    }
+    async updateDocument(id, data) {
+        const { documents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const current = await this.getDocument({ id });
+        if (data.version !== undefined && data.version !== current.version) {
+            throw new error_types_1.OptimisticLockError('Document', id, {
+                expectedVersion: data.version,
+                actualVersion: current.version,
+            });
+        }
+        const updatePayload = {
+            updatedAt: now,
+            version: current.version + 1,
+        };
+        if (data.title !== undefined) {
+            updatePayload.title = data.title;
+        }
+        if (data.contentMd !== undefined) {
+            updatePayload.contentMd = data.contentMd;
+        }
+        if (data.archived !== undefined) {
+            updatePayload.archived = data.archived;
+        }
+        if (data.slug !== undefined) {
+            updatePayload.slug = await this.generateDocumentSlug(current.projectId, data.slug, id);
+        }
+        await this.db.update(documents).set(updatePayload).where(eq(documents.id, id));
+        if (data.tags !== undefined) {
+            const tags = this.normalizeTagList(data.tags);
+            await this.setDocumentTags(id, tags, current.projectId);
+        }
+        logger.info({ documentId: id }, 'Updated document');
+        return this.getDocument({ id });
+    }
+    async deleteDocument(id) {
+        const { documents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(documents).where(eq(documents.id, id));
+        logger.info({ documentId: id }, 'Deleted document');
+    }
+    async createTag(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const tag = {
+            id: randomUUID(),
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(tags).values({
+            id: tag.id,
+            projectId: tag.projectId,
+            name: tag.name,
+            createdAt: tag.createdAt,
+            updatedAt: tag.updatedAt,
+        });
+        return tag;
+    }
+    async getTag(id) {
+        const { tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(tags).where(eq(tags.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Tag', id);
+        }
+        return result[0];
+    }
+    async listTags(projectId, options = {}) {
+        const { tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const query = projectId ? eq(tags.projectId, projectId) : undefined;
+        const items = await this.db.select().from(tags).where(query).limit(limit).offset(offset);
+        return {
+            items: items,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async updateTag(id, data) {
+        const { tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        await this.db
+            .update(tags)
+            .set({ ...data, updatedAt: now })
+            .where(eq(tags.id, id));
+        return this.getTag(id);
+    }
+    async deleteTag(id) {
+        const { tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(tags).where(eq(tags.id, id));
+    }
+    async createProvider(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { providers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const provider = {
+            id: randomUUID(),
+            name: data.name,
+            binPath: data.binPath ?? null,
+            mcpConfigured: data.mcpConfigured ?? false,
+            mcpEndpoint: data.mcpEndpoint ?? null,
+            mcpRegisteredAt: data.mcpRegisteredAt ?? null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(providers).values({
+            id: provider.id,
+            name: provider.name,
+            binPath: provider.binPath,
+            mcpConfigured: provider.mcpConfigured,
+            mcpEndpoint: provider.mcpEndpoint,
+            mcpRegisteredAt: provider.mcpRegisteredAt,
+            createdAt: provider.createdAt,
+            updatedAt: provider.updatedAt,
+        });
+        logger.info({ providerId: provider.id, name: provider.name }, 'Created provider');
+        return provider;
+    }
+    async getProvider(id) {
+        const { providers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(providers).where(eq(providers.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Provider', id);
+        }
+        return result[0];
+    }
+    async listProviders(options = {}) {
+        const { providers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db.select().from(providers).limit(limit).offset(offset);
+        return {
+            items: items,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async updateProvider(id, data) {
+        const { providers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const payload = Object.fromEntries(Object.entries({
+            ...data,
+            updatedAt: now,
+        }).filter(([, value]) => value !== undefined));
+        await this.db.update(providers).set(payload).where(eq(providers.id, id));
+        logger.info({ providerId: id }, 'Updated provider');
+        return this.getProvider(id);
+    }
+    async deleteProvider(id) {
+        const { providers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(providers).where(eq(providers.id, id));
+        logger.info({ providerId: id }, 'Deleted provider');
+    }
+    async getProviderMcpMetadata(id) {
+        const provider = await this.getProvider(id);
+        return {
+            mcpConfigured: provider.mcpConfigured,
+            mcpEndpoint: provider.mcpEndpoint,
+            mcpRegisteredAt: provider.mcpRegisteredAt,
+        };
+    }
+    async updateProviderMcpMetadata(id, metadata) {
+        const update = {};
+        if (metadata.mcpConfigured !== undefined) {
+            update.mcpConfigured = metadata.mcpConfigured;
+        }
+        if (metadata.mcpEndpoint !== undefined) {
+            update.mcpEndpoint = metadata.mcpEndpoint ?? null;
+        }
+        if (metadata.mcpRegisteredAt !== undefined) {
+            update.mcpRegisteredAt = metadata.mcpRegisteredAt ?? null;
+        }
+        return this.updateProvider(id, update);
+    }
+    async createAgentProfile(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { agentProfiles } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const profile = {
+            id: randomUUID(),
+            projectId: data.projectId ?? null,
+            name: data.name,
+            providerId: data.providerId,
+            options: data.options ?? null,
+            systemPrompt: data.systemPrompt ?? null,
+            instructions: data.instructions ?? null,
+            temperature: data.temperature ?? null,
+            maxTokens: data.maxTokens ?? null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(agentProfiles).values({
+            id: profile.id,
+            projectId: profile.projectId,
+            name: profile.name,
+            providerId: profile.providerId,
+            options: profile.options,
+            systemPrompt: profile.systemPrompt,
+            instructions: profile.instructions,
+            temperature: profile.temperature ? Math.round(profile.temperature * 100) : null,
+            maxTokens: profile.maxTokens,
+            createdAt: profile.createdAt,
+            updatedAt: profile.updatedAt,
+        });
+        return profile;
+    }
+    async getAgentProfile(id) {
+        const { agentProfiles } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db
+            .select()
+            .from(agentProfiles)
+            .where(eq(agentProfiles.id, id))
+            .limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Agent profile', id);
+        }
+        const profile = result[0];
+        return {
+            ...profile,
+            temperature: profile.temperature ? profile.temperature / 100 : null,
+            options: profile.options ?? null,
+        };
+    }
+    async listAgentProfiles(options = {}) {
+        const { agentProfiles } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        let whereClause;
+        if (options.projectId !== undefined) {
+            whereClause =
+                options.projectId === null
+                    ? isNull(agentProfiles.projectId)
+                    : eq(agentProfiles.projectId, options.projectId);
+        }
+        const items = await this.db
+            .select()
+            .from(agentProfiles)
+            .where(whereClause)
+            .limit(limit)
+            .offset(offset);
+        return {
+            items: items.map((p) => ({
+                ...p,
+                temperature: p.temperature ? p.temperature / 100 : null,
+                options: p.options ?? null,
+            })),
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async updateAgentProfile(id, data) {
+        const { agentProfiles } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const updateData = { ...data };
+        if (data.temperature !== undefined && data.temperature !== null) {
+            updateData.temperature = Math.round(data.temperature * 100);
+        }
+        if (data.temperature === null) {
+            updateData.temperature = null;
+        }
+        if (data.instructions !== undefined) {
+            updateData.instructions = data.instructions ?? null;
+        }
+        if (data.options !== undefined) {
+            updateData.options = data.options ?? null;
+        }
+        await this.db
+            .update(agentProfiles)
+            .set({ ...updateData, updatedAt: now })
+            .where(eq(agentProfiles.id, id));
+        return this.getAgentProfile(id);
+    }
+    async deleteAgentProfile(id) {
+        const { agentProfiles } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(agentProfiles).where(eq(agentProfiles.id, id));
+    }
+    async setAgentProfilePrompts(profileId, promptIdsOrdered) {
+        const { agentProfilePrompts, prompts } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const profile = await this.getAgentProfile(profileId);
+        if (promptIdsOrdered.length > 0) {
+            const items = await this.db
+                .select({ id: prompts.id, projectId: prompts.projectId })
+                .from(prompts)
+                .where(inArray(prompts.id, promptIdsOrdered));
+            const foundIds = new Set(items.map((i) => i.id));
+            const missing = promptIdsOrdered.filter((id) => !foundIds.has(id));
+            if (missing.length > 0) {
+                throw new error_types_1.ValidationError('Unknown prompt ids provided', { missing });
+            }
+            const crossProject = items.filter((i) => i.projectId !== (profile.projectId ?? null));
+            if (crossProject.length > 0) {
+                throw new error_types_1.ValidationError('Cross-project prompts are not allowed for this profile', {
+                    profileProjectId: profile.projectId ?? null,
+                    promptIds: crossProject.map((i) => i.id),
+                });
+            }
+        }
+        await this.db.transaction(async (tx) => {
+            await tx.delete(agentProfilePrompts).where(eq(agentProfilePrompts.profileId, profileId));
+            if (promptIdsOrdered.length === 0)
+                return;
+            const base = new Date();
+            const rows = promptIdsOrdered.map((pid, idx) => ({
+                profileId,
+                promptId: pid,
+                createdAt: new Date(base.getTime() + idx).toISOString(),
+            }));
+            await tx.insert(agentProfilePrompts).values(rows);
+        });
+    }
+    async getAgentProfilePrompts(profileId) {
+        const { agentProfilePrompts } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, asc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({ promptId: agentProfilePrompts.promptId, createdAt: agentProfilePrompts.createdAt })
+            .from(agentProfilePrompts)
+            .where(eq(agentProfilePrompts.profileId, profileId))
+            .orderBy(asc(agentProfilePrompts.createdAt));
+        return rows;
+    }
+    async getAgentProfileWithPrompts(id) {
+        const profile = await this.getAgentProfile(id);
+        const { agentProfilePrompts, prompts } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, asc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({
+            promptId: agentProfilePrompts.promptId,
+            createdAt: agentProfilePrompts.createdAt,
+            title: prompts.title,
+        })
+            .from(agentProfilePrompts)
+            .innerJoin(prompts, eq(agentProfilePrompts.promptId, prompts.id))
+            .where(eq(agentProfilePrompts.profileId, id))
+            .orderBy(asc(agentProfilePrompts.createdAt));
+        const promptsDetailed = rows.map((row, idx) => ({
+            promptId: row.promptId,
+            title: row.title,
+            order: idx + 1,
+        }));
+        return { ...profile, prompts: promptsDetailed };
+    }
+    async listAgentProfilesWithPrompts(options = {}) {
+        const base = await this.listAgentProfiles(options);
+        if (!base.items.length)
+            return { ...base, items: [] };
+        const ids = base.items.map((p) => p.id);
+        const { agentProfilePrompts, prompts } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { inArray, asc, eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({
+            profileId: agentProfilePrompts.profileId,
+            promptId: agentProfilePrompts.promptId,
+            createdAt: agentProfilePrompts.createdAt,
+            title: prompts.title,
+        })
+            .from(agentProfilePrompts)
+            .innerJoin(prompts, eq(agentProfilePrompts.promptId, prompts.id))
+            .where(inArray(agentProfilePrompts.profileId, ids))
+            .orderBy(asc(agentProfilePrompts.profileId), asc(agentProfilePrompts.createdAt));
+        const grouped = new Map();
+        for (const r of rows) {
+            const pid = r.profileId;
+            const arr = grouped.get(pid) ?? [];
+            arr.push({
+                promptId: r.promptId,
+                title: r.title,
+                createdAt: r.createdAt,
+            });
+            grouped.set(pid, arr);
+        }
+        const items = base.items.map((p) => {
+            const arr = grouped.get(p.id) ?? [];
+            const promptsDetailed = arr.map((row, idx) => ({
+                promptId: row.promptId,
+                title: row.title,
+                order: idx + 1,
+            }));
+            return { ...p, prompts: promptsDetailed };
+        });
+        return { ...base, items };
+    }
+    async createAgent(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { agents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const agent = {
+            id: randomUUID(),
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const profile = await this.getAgentProfile(agent.profileId);
+        if (profile.projectId !== agent.projectId) {
+            throw new error_types_1.ValidationError('Agent.profileId must belong to the same project as the agent.', {
+                agentProjectId: agent.projectId,
+                profileProjectId: profile.projectId,
+                profileId: agent.profileId,
+            });
+        }
+        await this.db.insert(agents).values({
+            id: agent.id,
+            projectId: agent.projectId,
+            profileId: agent.profileId,
+            name: agent.name,
+            createdAt: agent.createdAt,
+            updatedAt: agent.updatedAt,
+        });
+        logger.info({ agentId: agent.id, projectId: agent.projectId }, 'Created agent');
+        return agent;
+    }
+    async getAgent(id) {
+        const { agents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(agents).where(eq(agents.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Agent', id);
+        }
+        return result[0];
+    }
+    async listAgents(projectId, options = {}) {
+        const { agents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(agents)
+            .where(eq(agents.projectId, projectId))
+            .limit(limit)
+            .offset(offset);
+        return {
+            items: items,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async getAgentByName(projectId, name) {
+        const { agents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const normalized = name.toLowerCase();
+        const result = await this.db
+            .select()
+            .from(agents)
+            .where(and(eq(agents.projectId, projectId), sql `lower(${agents.name}) = ${normalized}`))
+            .limit(1);
+        const record = result[0];
+        if (!record) {
+            throw new error_types_1.NotFoundError('Agent', `${projectId}:${name}`);
+        }
+        const agent = record;
+        const profile = await this.getAgentProfile(agent.profileId);
+        return { ...agent, profile };
+    }
+    async updateAgent(id, data) {
+        const { agents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        if (data.projectId !== undefined || data.profileId !== undefined) {
+            const current = await this.getAgent(id);
+            const newProjectId = data.projectId ?? current.projectId;
+            const newProfileId = data.profileId ?? current.profileId;
+            const profile = await this.getAgentProfile(newProfileId);
+            if (profile.projectId !== newProjectId) {
+                throw new error_types_1.ValidationError('Agent.profileId must belong to the same project as the agent.', {
+                    agentProjectId: newProjectId,
+                    profileProjectId: profile.projectId,
+                    profileId: newProfileId,
+                });
+            }
+        }
+        await this.db
+            .update(agents)
+            .set({ ...data, updatedAt: now })
+            .where(eq(agents.id, id));
+        return this.getAgent(id);
+    }
+    async deleteAgent(id) {
+        const { agents, sessions } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const relatedSessions = await this.db.select().from(sessions).where(eq(sessions.agentId, id));
+        const runningSessions = relatedSessions.filter((s) => s.status === 'running');
+        if (runningSessions.length > 0) {
+            throw new error_types_1.ConflictError(`Cannot delete agent: ${runningSessions.length} active session(s) are still running. Please terminate the active sessions first.`);
+        }
+        const completedSessions = relatedSessions.filter((s) => s.status === 'stopped' || s.status === 'failed');
+        if (completedSessions.length > 0) {
+            logger.info({ agentId: id, count: completedSessions.length }, 'Auto-deleting completed sessions for agent');
+            for (const session of completedSessions) {
+                await this.db.delete(sessions).where(eq(sessions.id, session.id));
+            }
+        }
+        await this.db.delete(agents).where(eq(agents.id, id));
+        logger.info({ agentId: id, deletedSessions: completedSessions.length }, 'Deleted agent');
+    }
+    async createRecord(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { records, recordTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const record = {
+            id: randomUUID(),
+            ...data,
+            version: 1,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(records).values({
+            id: record.id,
+            epicId: record.epicId,
+            type: record.type,
+            data: JSON.stringify(record.data),
+            version: record.version,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        });
+        if (data.tags?.length) {
+            for (const tagName of data.tags) {
+                const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+                const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+                const epic = await this.db.select().from(epics).where(eq(epics.id, data.epicId)).limit(1);
+                const projectId = epic[0]?.projectId || null;
+                let tag = await this.db
+                    .select()
+                    .from(tags)
+                    .where(and(eq(tags.name, tagName), or(eq(tags.projectId, projectId || ''), isNull(tags.projectId))))
+                    .limit(1);
+                if (!tag[0]) {
+                    const newTag = await this.createTag({ projectId, name: tagName });
+                    tag = [newTag];
+                }
+                await this.db.insert(recordTags).values({
+                    recordId: record.id,
+                    tagId: tag[0].id,
+                    createdAt: now,
+                });
+            }
+        }
+        logger.info({ recordId: record.id, epicId: record.epicId, type: record.type }, 'Created record');
+        return record;
+    }
+    async getRecord(id) {
+        const { records, recordTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(records).where(eq(records.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Record', id);
+        }
+        const recordTagsResult = await this.db
+            .select({ tag: tags })
+            .from(recordTags)
+            .innerJoin(tags, eq(recordTags.tagId, tags.id))
+            .where(eq(recordTags.recordId, id));
+        return {
+            ...result[0],
+            data: result[0].data,
+            tags: recordTagsResult.map((rt) => rt.tag.name),
+        };
+    }
+    async listRecords(epicId, options = {}) {
+        const { records } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(records)
+            .where(eq(records.epicId, epicId))
+            .limit(limit)
+            .offset(offset);
+        const itemsWithTags = await Promise.all(items.map((item) => this.getRecord(item.id)));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async updateRecord(id, data, expectedVersion) {
+        const { records, recordTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const current = await this.getRecord(id);
+        if (current.version !== expectedVersion) {
+            throw new error_types_1.OptimisticLockError('Record', id, {
+                expectedVersion,
+                actualVersion: current.version,
+            });
+        }
+        const updateData = {};
+        if (data.data !== undefined) {
+            updateData.data = JSON.stringify(data.data);
+        }
+        if (data.type !== undefined) {
+            updateData.type = data.type;
+        }
+        await this.db
+            .update(records)
+            .set({ ...updateData, version: expectedVersion + 1, updatedAt: now })
+            .where(eq(records.id, id));
+        if (data.tags !== undefined) {
+            await this.db.delete(recordTags).where(eq(recordTags.recordId, id));
+            if (data.tags.length > 0) {
+                const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+                const epic = await this.db
+                    .select()
+                    .from(epics)
+                    .where(eq(epics.id, current.epicId))
+                    .limit(1);
+                const projectId = epic[0]?.projectId || null;
+                for (const tagName of data.tags) {
+                    const { and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+                    let tag = await this.db
+                        .select()
+                        .from(tags)
+                        .where(and(eq(tags.name, tagName), or(eq(tags.projectId, projectId || ''), isNull(tags.projectId))))
+                        .limit(1);
+                    if (!tag[0]) {
+                        const newTag = await this.createTag({ projectId, name: tagName });
+                        tag = [newTag];
+                    }
+                    await this.db.insert(recordTags).values({
+                        recordId: id,
+                        tagId: tag[0].id,
+                        createdAt: now,
+                    });
+                }
+            }
+        }
+        logger.info({ recordId: id }, 'Updated record');
+        return this.getRecord(id);
+    }
+    async deleteRecord(id) {
+        const { records } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(records).where(eq(records.id, id));
+        logger.info({ recordId: id }, 'Deleted record');
+    }
+    async markMessageAsRead(messageId, agentId, readAt) {
+        const { chatMessageReads } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const existing = await this.db
+            .select()
+            .from(chatMessageReads)
+            .where(and(eq(chatMessageReads.messageId, messageId), eq(chatMessageReads.agentId, agentId)))
+            .limit(1);
+        if (!existing[0]) {
+            await this.db.insert(chatMessageReads).values({
+                messageId,
+                agentId,
+                readAt,
+            });
+            logger.info({ messageId, agentId }, 'Marked message as read');
+        }
+        else {
+            logger.debug({ messageId, agentId }, 'Message already marked as read');
+        }
+    }
+    normalizeTagList(tags) {
+        if (!tags?.length) {
+            return [];
+        }
+        const unique = new Set();
+        for (const tag of tags) {
+            const trimmed = tag.trim();
+            if (trimmed) {
+                unique.add(trimmed);
+            }
+        }
+        return Array.from(unique);
+    }
+    slugify(value) {
+        return value
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/-{2,}/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    async generateDocumentSlug(projectId, desired, excludeId) {
+        const { documents } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, isNull, ne } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const base = this.slugify(desired || 'document') || 'document';
+        let candidate = base;
+        let attempt = 1;
+        while (true) {
+            const projectCondition = projectId === null ? isNull(documents.projectId) : eq(documents.projectId, projectId);
+            const slugCondition = eq(documents.slug, candidate);
+            const whereClause = excludeId
+                ? and(slugCondition, projectCondition, ne(documents.id, excludeId))
+                : and(slugCondition, projectCondition);
+            const existing = await this.db
+                .select({ id: documents.id })
+                .from(documents)
+                .where(whereClause)
+                .limit(1);
+            if (!existing[0]) {
+                return candidate;
+            }
+            attempt += 1;
+            candidate = `${base}-${attempt}`;
+        }
+    }
+    async setDocumentTags(documentId, tagNames, projectId) {
+        const normalizedTags = this.normalizeTagList(tagNames);
+        const { documentTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(documentTags).where(eq(documentTags.documentId, documentId));
+        for (const tagName of normalizedTags) {
+            const projectCondition = projectId === null
+                ? isNull(tags.projectId)
+                : or(eq(tags.projectId, projectId), isNull(tags.projectId));
+            const existing = await this.db
+                .select()
+                .from(tags)
+                .where(and(eq(tags.name, tagName), projectCondition))
+                .limit(1);
+            let tagId = existing[0]?.id;
+            if (!tagId) {
+                const newTag = await this.createTag({ projectId, name: tagName });
+                tagId = newTag.id;
+            }
+            await this.db.insert(documentTags).values({
+                documentId,
+                tagId,
+            });
+        }
+    }
+};
+exports.LocalStorageService = LocalStorageService;
+exports.LocalStorageService = LocalStorageService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(db_provider_1.DB_CONNECTION)),
+    __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database])
+], LocalStorageService);
+function safePreview(v) {
+    try {
+        if (v === undefined)
+            return 'undefined';
+        if (v === null)
+            return 'null';
+        if (typeof v === 'string')
+            return v.length > 200 ? v.slice(0, 200) + '…' : v;
+        return JSON.stringify(v).slice(0, 200);
+    }
+    catch {
+        return '[unserializable]';
+    }
+}
+//# sourceMappingURL=local-storage.service.js.map