devchain-cli 0.9.2 → 0.10.0

package/dist/server/modules/orchestrator/sync/services/task-merge.service.js

@@ -0,0 +1,730 @@
+"use strict";
+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 __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.TaskMergeService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const crypto_1 = require("crypto");
+const logger_1 = require("../../../../common/logging/logger");
+const env_config_1 = require("../../../../common/config/env.config");
+const orchestrator_provider_1 = require("../../orchestrator-storage/db/orchestrator.provider");
+const schema_1 = require("../../../storage/db/schema");
+const worktrees_store_1 = require("../../worktrees/worktrees.store");
+const task_merge_events_1 = require("../events/task-merge.events");
+const sqlite_raw_1 = require("../../../storage/db/sqlite-raw");
+const main_project_bootstrap_service_1 = require("../../../projects/services/main-project-bootstrap.service");
+const storage_interface_1 = require("../../../storage/interfaces/storage.interface");
+const path_1 = require("path");
+const logger = (0, logger_1.createLogger)('OrchestratorTaskMergeService');
+const CONTAINER_FETCH_TIMEOUT_MS = 5_000;
+const UNKNOWN_STATUS_LABEL = 'Unknown';
+const UNKNOWN_STATUS_COLOR = '#6c757d';
+const UNKNOWN_PROFILE_LABEL = 'Unknown';
+const SQLITE_EPIC_PAGE_SIZE = 500;
+const SQLITE_STATUS_PAGE_SIZE = 500;
+const SQLITE_AGENT_PAGE_SIZE = 500;
+const MERGED_TAG_PREFIX = 'merged:';
+let TaskMergeService = class TaskMergeService {
+    constructor(store, db, storage, mainProjectBootstrap, moduleRef) {
+        this.store = store;
+        this.db = db;
+        this.storage = storage;
+        this.mainProjectBootstrap = mainProjectBootstrap;
+        this.moduleRef = moduleRef;
+        this.sqliteMergeImportQueue = Promise.resolve();
+    }
+    async handleTaskMergeRequested(payload) {
+        return this.mergeTasksFromContainer(payload.worktreeId);
+    }
+    async mergeTasksFromContainer(worktreeId) {
+        const worktree = await this.store.getById(worktreeId);
+        if (!worktree) {
+            throw new common_1.NotFoundException(`Worktree not found: ${worktreeId}`);
+        }
+        if (!worktree.containerPort || !worktree.devchainProjectId) {
+            throw new common_1.BadRequestException(`Worktree ${worktreeId} has no active container endpoint for task extraction`);
+        }
+        const baseUrl = `http://127.0.0.1:${worktree.containerPort}`;
+        const projectId = encodeURIComponent(worktree.devchainProjectId);
+        let epicsPayload;
+        let agentsPayload;
+        let statusesPayload;
+        let profilesPayload;
+        try {
+            [epicsPayload, agentsPayload, statusesPayload, profilesPayload] = await Promise.all([
+                this.fetchContainerJson(`${baseUrl}/api/epics?projectId=${projectId}&limit=1000&type=all`),
+                this.fetchContainerJson(`${baseUrl}/api/agents?projectId=${projectId}&limit=1000`),
+                this.fetchContainerJsonSafe(`${baseUrl}/api/statuses?projectId=${projectId}&limit=1000`),
+                this.fetchProfilesForProject(baseUrl, projectId),
+            ]);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new common_1.BadRequestException(`Failed to extract task history from worktree container ${worktree.name}: ${message}`);
+        }
+        const nowIso = new Date().toISOString();
+        const epics = this.normalizeEpics(epicsPayload.items ?? []);
+        const agents = this.normalizeAgents(agentsPayload.items ?? []);
+        const agentNameById = new Map(agents.map((agent) => [agent.id, agent.name]));
+        const statusById = this.buildStatusMap(statusesPayload?.items ?? []);
+        const profileNameById = this.buildProfileMap(profilesPayload?.items ?? []);
+        const assignedEpicsByAgent = new Map();
+        for (const epic of epics) {
+            if (!epic.agentId) {
+                continue;
+            }
+            assignedEpicsByAgent.set(epic.agentId, (assignedEpicsByAgent.get(epic.agentId) ?? 0) + 1);
+        }
+        const mergedEpicRows = epics.map((epic) => {
+            const resolvedStatus = this.resolveStatus(epic.statusId, statusById);
+            return {
+                id: (0, crypto_1.randomUUID)(),
+                worktreeId: worktree.id,
+                devchainEpicId: epic.id,
+                title: epic.title,
+                description: epic.description,
+                statusName: resolvedStatus.label,
+                statusColor: resolvedStatus.color,
+                agentName: epic.agentId ? (agentNameById.get(epic.agentId) ?? null) : null,
+                parentEpicId: epic.parentId,
+                tags: epic.tags,
+                createdAtSource: epic.createdAtSource,
+                mergedAt: nowIso,
+            };
+        });
+        const mergedAgentRows = agents.map((agent) => ({
+            id: (0, crypto_1.randomUUID)(),
+            worktreeId: worktree.id,
+            devchainAgentId: agent.id,
+            name: agent.name,
+            profileName: this.resolveProfileName(agent.profileId, profileNameById),
+            epicsCompleted: agent.epicsCompleted ??
+                agent.completedEpics ??
+                agent.activityCount ??
+                assignedEpicsByAgent.get(agent.id) ??
+                0,
+            mergedAt: nowIso,
+        }));
+        await this.persistMergedRows(mergedEpicRows, mergedAgentRows);
+        const sqliteImportSummary = await this.importEpicsIntoMainProject({
+            worktreeId: worktree.id,
+            worktreeName: worktree.name,
+            epics,
+            statusById,
+            agentNameById,
+        });
+        logger.info({
+            worktreeId: worktree.id,
+            worktreeName: worktree.name,
+            epicsMerged: mergedEpicRows.length,
+            agentsMerged: mergedAgentRows.length,
+            sqliteEpicsImported: sqliteImportSummary.imported,
+            sqliteEpicsSkipped: sqliteImportSummary.skipped,
+            sqliteStatusesCreated: sqliteImportSummary.statusesCreated,
+        }, 'Merged task history from container into orchestrator storage');
+        return {
+            worktreeId: worktree.id,
+            epicsMerged: mergedEpicRows.length,
+            agentsMerged: mergedAgentRows.length,
+        };
+    }
+    async persistMergedRows(mergedEpicRows, mergedAgentRows) {
+        const persist = async (targetDb) => {
+            if (mergedEpicRows.length > 0) {
+                await targetDb
+                    .insert(schema_1.mergedEpics)
+                    .values(mergedEpicRows)
+                    .onConflictDoNothing({
+                    target: [schema_1.mergedEpics.worktreeId, schema_1.mergedEpics.devchainEpicId],
+                });
+            }
+            if (mergedAgentRows.length > 0) {
+                await targetDb
+                    .insert(schema_1.mergedAgents)
+                    .values(mergedAgentRows)
+                    .onConflictDoNothing({
+                    target: [schema_1.mergedAgents.worktreeId, schema_1.mergedAgents.devchainAgentId],
+                });
+            }
+        };
+        const rawSqlite = this.resolveRawSqliteClientForOrchestratorDb();
+        if (!rawSqlite) {
+            const dbWithTransaction = this.db;
+            if (typeof dbWithTransaction.transaction === 'function') {
+                await dbWithTransaction.transaction(async (tx) => {
+                    await persist(tx);
+                });
+                return;
+            }
+            await persist(this.db);
+            return;
+        }
+        await this.runWithSqliteMergeLock(async () => {
+            rawSqlite.exec('BEGIN IMMEDIATE TRANSACTION');
+            try {
+                await persist(this.db);
+                rawSqlite.exec('COMMIT');
+            }
+            catch (error) {
+                try {
+                    rawSqlite.exec('ROLLBACK');
+                }
+                catch {
+                }
+                throw error;
+            }
+        });
+    }
+    normalizeEpics(items) {
+        return items
+            .map((item) => {
+            const id = item.id?.trim();
+            if (!id) {
+                return null;
+            }
+            const createdAtSource = this.parseIsoDate(item.createdAt);
+            return {
+                id,
+                title: item.title?.trim() || 'Untitled Epic',
+                description: item.description ?? null,
+                statusId: item.statusId?.trim() || null,
+                parentId: item.parentId?.trim() || null,
+                agentId: item.agentId?.trim() || null,
+                tags: Array.isArray(item.tags) ? item.tags.filter((tag) => typeof tag === 'string') : [],
+                createdAtSource,
+            };
+        })
+            .filter((item) => Boolean(item));
+    }
+    buildStatusMap(items) {
+        const map = new Map();
+        for (const item of items) {
+            const id = item.id?.trim();
+            if (!id) {
+                continue;
+            }
+            const label = item.label?.trim() || `${UNKNOWN_STATUS_LABEL} (${id})`;
+            const color = this.normalizeStatusColor(item.color);
+            map.set(id, { label, color });
+        }
+        return map;
+    }
+    buildProfileMap(items) {
+        const map = new Map();
+        for (const item of items) {
+            const id = item.id?.trim();
+            if (!id) {
+                continue;
+            }
+            const name = item.name?.trim();
+            map.set(id, name && name.length > 0 ? name : `${UNKNOWN_PROFILE_LABEL} (${id})`);
+        }
+        return map;
+    }
+    resolveStatus(statusId, map) {
+        if (!statusId) {
+            return { label: UNKNOWN_STATUS_LABEL, color: UNKNOWN_STATUS_COLOR };
+        }
+        return (map.get(statusId) ?? {
+            label: `${UNKNOWN_STATUS_LABEL} (${statusId})`,
+            color: UNKNOWN_STATUS_COLOR,
+        });
+    }
+    resolveProfileName(profileId, map) {
+        if (!profileId) {
+            return UNKNOWN_PROFILE_LABEL;
+        }
+        return map.get(profileId) ?? `${UNKNOWN_PROFILE_LABEL} (${profileId})`;
+    }
+    normalizeStatusColor(color) {
+        const normalized = color?.trim();
+        if (normalized && /^#[0-9a-fA-F]{6}$/.test(normalized)) {
+            return normalized;
+        }
+        return UNKNOWN_STATUS_COLOR;
+    }
+    normalizeAgents(items) {
+        return items
+            .map((item) => {
+            const id = item.id?.trim();
+            if (!id) {
+                return null;
+            }
+            return {
+                id,
+                name: item.name?.trim() || null,
+                profileId: item.profileId?.trim() || null,
+                epicsCompleted: this.toNumberOrNull(item.epicsCompleted),
+                completedEpics: this.toNumberOrNull(item.completedEpics),
+                activityCount: this.toNumberOrNull(item.activityCount),
+            };
+        })
+            .filter((item) => Boolean(item));
+    }
+    toNumberOrNull(value) {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+            return null;
+        }
+        return Math.max(0, Math.floor(value));
+    }
+    parseIsoDate(value) {
+        if (!value) {
+            return null;
+        }
+        const parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime())) {
+            return null;
+        }
+        return parsed.toISOString();
+    }
+    async fetchContainerJson(url) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), CONTAINER_FETCH_TIMEOUT_MS);
+        try {
+            const response = await fetch(url, {
+                headers: { accept: 'application/json' },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Container request failed with HTTP ${response.status}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Container request timed out after ${CONTAINER_FETCH_TIMEOUT_MS}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async fetchContainerJsonSafe(url) {
+        try {
+            return await this.fetchContainerJson(url);
+        }
+        catch (error) {
+            logger.warn({ error, url }, 'Optional container lookup failed; using fallback values');
+            return null;
+        }
+    }
+    async fetchProfilesForProject(baseUrl, projectId) {
+        const primary = await this.fetchContainerJsonSafe(`${baseUrl}/api/agent-profiles?projectId=${projectId}&limit=1000`);
+        if (primary?.items && primary.items.length > 0) {
+            return primary;
+        }
+        const fallback = await this.fetchContainerJsonSafe(`${baseUrl}/api/profiles?projectId=${projectId}&limit=1000`);
+        if (fallback?.items && fallback.items.length > 0) {
+            return fallback;
+        }
+        return primary ?? fallback;
+    }
+    async importEpicsIntoMainProject(input) {
+        if (process.env.DEVCHAIN_MODE !== 'main') {
+            return { imported: 0, skipped: input.epics.length, statusesCreated: 0 };
+        }
+        if (!this.storage) {
+            logger.warn('Main mode epic import skipped because STORAGE_SERVICE is unavailable');
+            return { imported: 0, skipped: input.epics.length, statusesCreated: 0 };
+        }
+        const targetProjectId = await this.resolveMainProjectId();
+        if (!targetProjectId) {
+            logger.warn({ worktreeId: input.worktreeId }, 'Main mode epic import skipped: no target project');
+            return { imported: 0, skipped: input.epics.length, statusesCreated: 0 };
+        }
+        const existingSourceToTarget = await this.loadExistingMergedEpicMap(targetProjectId, input.worktreeId);
+        const statusState = await this.buildStatusState(targetProjectId);
+        const mainAgentByName = await this.buildMainAgentMap(targetProjectId);
+        const mergeDateIso = new Date().toISOString();
+        const pending = new Map(input.epics
+            .filter((epic) => !existingSourceToTarget.has(epic.id))
+            .map((epic) => [epic.id, epic]));
+        let imported = 0;
+        const sourceToTargetId = new Map(existingSourceToTarget);
+        while (pending.size > 0) {
+            let progressed = false;
+            for (const [sourceEpicId, epic] of [...pending.entries()]) {
+                if (epic.parentId && pending.has(epic.parentId) && !sourceToTargetId.has(epic.parentId)) {
+                    continue;
+                }
+                const resolvedStatus = this.resolveStatus(epic.statusId, input.statusById);
+                const statusId = await this.ensureMainStatus(targetProjectId, resolvedStatus, statusState);
+                const sourceAgentName = epic.agentId
+                    ? (input.agentNameById.get(epic.agentId) ?? null)
+                    : null;
+                const mappedAgentId = sourceAgentName
+                    ? (mainAgentByName.get(sourceAgentName.trim().toLowerCase()) ?? null)
+                    : null;
+                const parentTargetId = epic.parentId && sourceToTargetId.has(epic.parentId)
+                    ? (sourceToTargetId.get(epic.parentId) ?? null)
+                    : null;
+                const mergedTags = this.buildMergedTags(epic.tags, input.worktreeName);
+                const mergeResult = await this.createMainEpicWithAtomicDedup({
+                    projectId: targetProjectId,
+                    worktreeId: input.worktreeId,
+                    sourceEpicId,
+                    createInput: {
+                        projectId: targetProjectId,
+                        title: epic.title,
+                        description: epic.description,
+                        statusId,
+                        parentId: parentTargetId,
+                        agentId: mappedAgentId,
+                        tags: mergedTags,
+                        data: {
+                            mergedFrom: {
+                                worktreeId: input.worktreeId,
+                                worktreeName: input.worktreeName,
+                                sourceEpicId,
+                                sourceParentEpicId: epic.parentId,
+                                sourceStatusId: epic.statusId,
+                                sourceAgentId: epic.agentId,
+                                sourceAgentName,
+                                mergedAt: mergeDateIso,
+                            },
+                        },
+                        skillsRequired: null,
+                    },
+                });
+                sourceToTargetId.set(sourceEpicId, mergeResult.epicId);
+                pending.delete(sourceEpicId);
+                if (mergeResult.inserted) {
+                    imported += 1;
+                }
+                progressed = true;
+            }
+            if (progressed) {
+                continue;
+            }
+            for (const [sourceEpicId, epic] of [...pending.entries()]) {
+                const resolvedStatus = this.resolveStatus(epic.statusId, input.statusById);
+                const statusId = await this.ensureMainStatus(targetProjectId, resolvedStatus, statusState);
+                const sourceAgentName = epic.agentId
+                    ? (input.agentNameById.get(epic.agentId) ?? null)
+                    : null;
+                const mappedAgentId = sourceAgentName
+                    ? (mainAgentByName.get(sourceAgentName.trim().toLowerCase()) ?? null)
+                    : null;
+                const mergedTags = this.buildMergedTags(epic.tags, input.worktreeName);
+                const mergeResult = await this.createMainEpicWithAtomicDedup({
+                    projectId: targetProjectId,
+                    worktreeId: input.worktreeId,
+                    sourceEpicId,
+                    createInput: {
+                        projectId: targetProjectId,
+                        title: epic.title,
+                        description: epic.description,
+                        statusId,
+                        parentId: null,
+                        agentId: mappedAgentId,
+                        tags: mergedTags,
+                        data: {
+                            mergedFrom: {
+                                worktreeId: input.worktreeId,
+                                worktreeName: input.worktreeName,
+                                sourceEpicId,
+                                sourceParentEpicId: epic.parentId,
+                                sourceStatusId: epic.statusId,
+                                sourceAgentId: epic.agentId,
+                                sourceAgentName,
+                                mergedAt: mergeDateIso,
+                                unresolvedParent: Boolean(epic.parentId),
+                            },
+                        },
+                        skillsRequired: null,
+                    },
+                });
+                sourceToTargetId.set(sourceEpicId, mergeResult.epicId);
+                pending.delete(sourceEpicId);
+                if (mergeResult.inserted) {
+                    imported += 1;
+                }
+            }
+            break;
+        }
+        return {
+            imported,
+            skipped: input.epics.length - imported,
+            statusesCreated: statusState.createdCount,
+        };
+    }
+    async createMainEpicWithAtomicDedup(input) {
+        if (!this.storage) {
+            throw new Error('Storage service is unavailable for main epic import');
+        }
+        const storage = this.storage;
+        const rawSqlite = this.resolveRawSqliteClientForStorage(storage);
+        if (!rawSqlite) {
+            const created = await storage.createEpic(input.createInput);
+            return { epicId: created.id, inserted: true };
+        }
+        const existingLookup = rawSqlite.prepare(`
+        SELECT e.id AS id
+        FROM epics e
+        WHERE e.project_id = ?
+          AND json_extract(json_extract(e.data, '$'), '$.mergedFrom.worktreeId') = ?
+          AND json_extract(json_extract(e.data, '$'), '$.mergedFrom.sourceEpicId') = ?
+        LIMIT 1
+      `);
+        return this.runWithSqliteMergeLock(async () => {
+            rawSqlite.exec('BEGIN IMMEDIATE TRANSACTION');
+            try {
+                const existing = existingLookup.get(input.projectId, input.worktreeId, input.sourceEpicId);
+                if (existing?.id) {
+                    rawSqlite.exec('COMMIT');
+                    return { epicId: existing.id, inserted: false };
+                }
+                const created = await storage.createEpic(input.createInput);
+                rawSqlite.exec('COMMIT');
+                return { epicId: created.id, inserted: true };
+            }
+            catch (error) {
+                try {
+                    rawSqlite.exec('ROLLBACK');
+                }
+                catch {
+                }
+                throw error;
+            }
+        });
+    }
+    async resolveMainProjectId() {
+        if (!this.storage) {
+            return null;
+        }
+        const bootstrapProjectId = this.resolveMainProjectBootstrapService()?.getMainProjectId();
+        if (bootstrapProjectId) {
+            return bootstrapProjectId;
+        }
+        const env = (0, env_config_1.getEnvConfig)();
+        const repoRoot = (0, path_1.resolve)(env.REPO_ROOT ?? process.cwd());
+        const existingByPath = await this.storage.findProjectByPath(repoRoot);
+        if (existingByPath) {
+            return existingByPath.id;
+        }
+        const allProjects = await this.storage.listProjects({ limit: 1000, offset: 0 });
+        if (allProjects.total > 0 && allProjects.items.length > 0) {
+            return allProjects.items[0].id;
+        }
+        const created = await this.storage.createProject({
+            name: (0, path_1.basename)(repoRoot) || 'Main',
+            description: 'Auto-created main project for merged worktree epics',
+            rootPath: repoRoot,
+            isTemplate: false,
+        });
+        return created.id;
+    }
+    resolveMainProjectBootstrapService() {
+        if (this.mainProjectBootstrap) {
+            return this.mainProjectBootstrap;
+        }
+        if (!this.moduleRef) {
+            return null;
+        }
+        try {
+            return this.moduleRef.get(main_project_bootstrap_service_1.MainProjectBootstrapService, { strict: false });
+        }
+        catch {
+            return null;
+        }
+    }
+    async buildStatusState(projectId) {
+        if (!this.storage) {
+            return {
+                byLabel: new Map(),
+                nextPosition: { value: 0 },
+                createdCount: 0,
+            };
+        }
+        const allStatuses = [];
+        let offset = 0;
+        while (true) {
+            const page = await this.storage.listStatuses(projectId, {
+                limit: SQLITE_STATUS_PAGE_SIZE,
+                offset,
+            });
+            allStatuses.push(...page.items);
+            offset += page.items.length;
+            if (offset >= page.total || page.items.length === 0) {
+                break;
+            }
+        }
+        const byLabel = new Map();
+        let maxPosition = -1;
+        for (const status of allStatuses) {
+            byLabel.set(status.label.trim().toLowerCase(), status);
+            maxPosition = Math.max(maxPosition, status.position);
+        }
+        return {
+            byLabel,
+            nextPosition: { value: maxPosition + 1 },
+            createdCount: 0,
+        };
+    }
+    async ensureMainStatus(projectId, resolvedStatus, statusState) {
+        if (!this.storage) {
+            throw new Error('Storage service is unavailable for main status mapping');
+        }
+        const normalizedLabel = resolvedStatus.label.trim().toLowerCase();
+        const existing = statusState.byLabel.get(normalizedLabel);
+        if (existing) {
+            return existing.id;
+        }
+        const created = await this.storage.createStatus({
+            projectId,
+            label: resolvedStatus.label,
+            color: resolvedStatus.color,
+            position: statusState.nextPosition.value++,
+        });
+        statusState.byLabel.set(normalizedLabel, created);
+        statusState.createdCount += 1;
+        return created.id;
+    }
+    async buildMainAgentMap(projectId) {
+        if (!this.storage) {
+            return new Map();
+        }
+        const byName = new Map();
+        let offset = 0;
+        while (true) {
+            const page = await this.storage.listAgents(projectId, {
+                limit: SQLITE_AGENT_PAGE_SIZE,
+                offset,
+            });
+            for (const agent of page.items) {
+                const normalized = agent.name.trim().toLowerCase();
+                if (!byName.has(normalized)) {
+                    byName.set(normalized, agent.id);
+                }
+            }
+            offset += page.items.length;
+            if (offset >= page.total || page.items.length === 0) {
+                break;
+            }
+        }
+        return byName;
+    }
+    async loadExistingMergedEpicMap(projectId, worktreeId) {
+        if (!this.storage) {
+            return new Map();
+        }
+        const sourceToTarget = new Map();
+        let offset = 0;
+        while (true) {
+            const page = await this.storage.listProjectEpics(projectId, {
+                type: 'all',
+                limit: SQLITE_EPIC_PAGE_SIZE,
+                offset,
+            });
+            for (const epic of page.items) {
+                const sourceEpicId = this.extractSourceEpicId(epic, worktreeId);
+                if (sourceEpicId && !sourceToTarget.has(sourceEpicId)) {
+                    sourceToTarget.set(sourceEpicId, epic.id);
+                }
+            }
+            offset += page.items.length;
+            if (offset >= page.total || page.items.length === 0) {
+                break;
+            }
+        }
+        return sourceToTarget;
+    }
+    extractSourceEpicId(epic, worktreeId) {
+        const data = epic.data;
+        if (data && typeof data === 'object' && 'mergedFrom' in data) {
+            const mergedFrom = data.mergedFrom;
+            if (mergedFrom && typeof mergedFrom === 'object') {
+                const mergedWorktreeId = mergedFrom.worktreeId;
+                const sourceEpicId = mergedFrom.sourceEpicId;
+                if (typeof mergedWorktreeId === 'string' &&
+                    mergedWorktreeId === worktreeId &&
+                    typeof sourceEpicId === 'string' &&
+                    sourceEpicId.trim().length > 0) {
+                    return sourceEpicId.trim();
+                }
+            }
+        }
+        return null;
+    }
+    resolveRawSqliteClientForStorage(storage) {
+        const storageWithDb = storage;
+        if (!storageWithDb.db) {
+            return null;
+        }
+        try {
+            return (0, sqlite_raw_1.getRawSqliteClient)(storageWithDb.db);
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveRawSqliteClientForOrchestratorDb() {
+        try {
+            const raw = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+            if (!raw || typeof raw.exec !== 'function') {
+                return null;
+            }
+            return raw;
+        }
+        catch {
+            return null;
+        }
+    }
+    async runWithSqliteMergeLock(fn) {
+        const previous = this.sqliteMergeImportQueue;
+        let release;
+        this.sqliteMergeImportQueue = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    buildMergedTags(sourceTags, worktreeName) {
+        const tags = new Set();
+        for (const tag of sourceTags) {
+            const trimmed = tag.trim();
+            if (trimmed.length > 0) {
+                tags.add(trimmed);
+            }
+        }
+        tags.add(`${MERGED_TAG_PREFIX}${worktreeName}`);
+        return [...tags];
+    }
+};
+exports.TaskMergeService = TaskMergeService;
+__decorate([
+    (0, event_emitter_1.OnEvent)(task_merge_events_1.WORKTREE_TASK_MERGE_REQUESTED_EVENT, { async: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TaskMergeService.prototype, "handleTaskMergeRequested", null);
+exports.TaskMergeService = TaskMergeService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(worktrees_store_1.WORKTREES_STORE)),
+    __param(1, (0, common_1.Inject)(orchestrator_provider_1.ORCHESTRATOR_DB_CONNECTION)),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
+    __param(3, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Object, Object, Object, main_project_bootstrap_service_1.MainProjectBootstrapService,
+        core_1.ModuleRef])
+], TaskMergeService);
+//# sourceMappingURL=task-merge.service.js.map