devchain-cli 0.23.4 → 0.24.0

package/dist/server/modules/orchestrator/worktrees/services/worktrees.service.js

@@ -1,1274 +0,0 @@
-"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.WorktreesService = void 0;
-const common_1 = require("@nestjs/common");
-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 event_log_service_1 = require("../../../events/services/event-log.service");
-const worktrees_store_1 = require("../worktrees.store");
-const git_worktree_service_1 = require("../../git/services/git-worktree.service");
-const seed_preparation_service_1 = require("../../docker/services/seed-preparation.service");
-const container_runtime_1 = require("../runtime/container-runtime");
-const process_runtime_1 = require("../runtime/process-runtime");
-const task_merge_events_1 = require("../../sync/events/task-merge.events");
-const worktree_events_1 = require("../events/worktree.events");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const worktree_validation_1 = require("../worktree-validation");
-const storage_interface_1 = require("../../../storage/interfaces/storage.interface");
-const error_types_1 = require("../../../../common/errors/error-types");
-const path_validation_1 = require("../../../../common/validation/path-validation");
-const logger = (0, logger_1.createLogger)('OrchestratorWorktreesService');
-const CONTAINER_HEALTH_TIMEOUT_MS = 60_000;
-const HEALTH_MONITOR_INTERVAL_MS = 15_000;
-const HEALTH_MONITOR_PROBE_TIMEOUT_MS = 1_500;
-const MAX_CONSECUTIVE_HEALTH_FAILURES = 3;
-const OVERVIEW_FETCH_TIMEOUT_MS = 2_500;
-const WORKTREE_ACTIVITY_EVENT_NAME = 'orchestrator.worktree.activity';
-let WorktreesService = class WorktreesService {
-    store;
-    containerRuntime;
-    processRuntime;
-    gitService;
-    seedPreparationService;
-    eventEmitter;
-    eventLogService;
-    storage;
-    monitorTimer;
-    unsubscribeDockerEvents;
-    consecutiveHealthFailures = new Map();
-    inFlightOperations = new Map();
-    constructor(store, containerRuntime, processRuntime, gitService, seedPreparationService, eventEmitter, eventLogService, storage) {
-        this.store = store;
-        this.containerRuntime = containerRuntime;
-        this.processRuntime = processRuntime;
-        this.gitService = gitService;
-        this.seedPreparationService = seedPreparationService;
-        this.eventEmitter = eventEmitter;
-        this.eventLogService = eventLogService;
-        this.storage = storage;
-    }
-    async onModuleInit() {
-        this.monitorTimer = setInterval(() => {
-            this.monitorRunningWorktrees().catch((error) => {
-                logger.error({ error }, 'Failed to monitor running worktrees');
-            });
-        }, HEALTH_MONITOR_INTERVAL_MS);
-        this.reconcileProcessOrphans().catch((error) => {
-            logger.warn({ error }, 'Failed process-runtime orphan detection on startup');
-        });
-        try {
-            this.unsubscribeDockerEvents = await this.containerRuntime.subscribeToContainerEvents((event) => {
-                this.handleContainerEvent(event).catch((error) => {
-                    logger.error({ error, event }, 'Failed handling docker container event');
-                });
-            });
-        }
-        catch (error) {
-            logger.warn({ error }, 'Failed to subscribe to docker events stream');
-        }
-    }
-    onModuleDestroy() {
-        if (this.monitorTimer) {
-            clearInterval(this.monitorTimer);
-            this.monitorTimer = undefined;
-        }
-        if (this.unsubscribeDockerEvents) {
-            this.unsubscribeDockerEvents();
-            this.unsubscribeDockerEvents = undefined;
-        }
-    }
-    async createWorktree(input) {
-        this.assertValidWorktreeName(input.name);
-        this.assertValidBranchName(input.branchName, 'branchName');
-        this.assertValidBranchName(input.baseBranch, 'baseBranch');
-        const runtimeType = this.resolveRuntimeType(input.runtimeType);
-        const repoPath = await this.resolveCreateRepoPath(input);
-        const existing = await this.store.getByName(input.name);
-        if (existing) {
-            throw new common_1.ConflictException(`Worktree with name "${input.name}" already exists`);
-        }
-        const worktreePath = this.resolveWorktreePath(repoPath, input.name);
-        const dataPath = this.resolveDataPath(repoPath, input.name);
-        const containerName = this.getContainerName(input.name);
-        const projectId = (0, crypto_1.randomUUID)();
-        let created = await this.store.create({
-            name: input.name,
-            branchName: input.branchName,
-            baseBranch: input.baseBranch,
-            repoPath,
-            worktreePath,
-            templateSlug: input.templateSlug,
-            ownerProjectId: input.ownerProjectId,
-            status: 'creating',
-            description: input.description ?? null,
-            runtimeType,
-        });
-        let containerId = null;
-        let processId = null;
-        let gitWorktreeCreated = false;
-        const copyResults = {
-            copied: [],
-            failed: [],
-        };
-        try {
-            await this.gitService.createWorktree({
-                name: input.name,
-                branchName: input.branchName,
-                baseBranch: input.baseBranch,
-                repoPath,
-                worktreePath,
-            });
-            gitWorktreeCreated = true;
-            const ignoredCopyPlan = await this.prepareIgnoredCopyPlan(repoPath, worktreePath, input.includeIgnoredFiles ?? []);
-            for (const operation of ignoredCopyPlan.operations) {
-                try {
-                    await (0, promises_1.mkdir)((0, path_1.dirname)(operation.destinationPath), { recursive: true });
-                    await (0, promises_1.cp)(operation.sourcePath, operation.destinationPath, { recursive: true });
-                    copyResults.copied.push(operation.relativePath);
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    copyResults.failed.push({
-                        path: operation.relativePath,
-                        error: errorMessage,
-                    });
-                    logger.warn({
-                        error,
-                        sourcePath: operation.sourcePath,
-                        destinationPath: operation.destinationPath,
-                        worktreeName: input.name,
-                    }, 'Failed to copy selected ignored path into worktree');
-                }
-            }
-            logger.info({
-                worktreeName: input.name,
-                ownerProjectId: input.ownerProjectId,
-                requested: ignoredCopyPlan.requestedCount,
-                deduplicated: ignoredCopyPlan.deduplicatedCount,
-                copied: copyResults.copied.length,
-                failed: copyResults.failed.length,
-                skipped: ignoredCopyPlan.requestedCount - ignoredCopyPlan.deduplicatedCount,
-            }, 'Ignored file copy step completed');
-            await (0, promises_1.mkdir)(dataPath, { recursive: true });
-            await this.seedPreparationService.prepareSeedData(dataPath);
-            if (runtimeType === 'process') {
-                const runtime = await this.processRuntime.startProcessRuntime({
-                    worktreePath,
-                    dataPath,
-                    projectId,
-                });
-                processId = runtime.processId;
-                const project = await this.registerProjectInContainer(runtime.hostPort, {
-                    name: input.name,
-                    templateSlug: input.templateSlug,
-                    description: input.description ?? null,
-                    projectId,
-                    rootPath: worktreePath,
-                    presetName: input.presetName,
-                });
-                created = (await this.store.update(created.id, {
-                    containerId: null,
-                    processId: runtime.processId,
-                    runtimeToken: runtime.runtimeToken,
-                    startedAt: runtime.startedAt,
-                    containerPort: runtime.hostPort,
-                    devchainProjectId: project.projectId,
-                    status: 'running',
-                    errorMessage: null,
-                }));
-            }
-            else {
-                const container = await this.containerRuntime.createContainer({
-                    name: containerName,
-                    worktreePath,
-                    dataPath,
-                    worktreeName: input.name,
-                    env: {
-                        CONTAINER_PROJECT_ID: projectId,
-                        ...(process.env.DEVCHAIN_CLOUD_UI_ENABLED !== undefined
-                            ? { DEVCHAIN_CLOUD_UI_ENABLED: process.env.DEVCHAIN_CLOUD_UI_ENABLED }
-                            : {}),
-                    },
-                });
-                containerId = container.id;
-                await this.containerRuntime
-                    .ensureWorktreeOnComposeNetwork(input.name, container.id)
-                    .catch(() => undefined);
-                const healthy = await this.containerRuntime.waitForHealthy(container.id, CONTAINER_HEALTH_TIMEOUT_MS);
-                if (!healthy) {
-                    throw new Error('Container did not become healthy before timeout');
-                }
-                const project = await this.registerProjectInContainer(container.hostPort, {
-                    name: input.name,
-                    templateSlug: input.templateSlug,
-                    description: input.description ?? null,
-                    projectId,
-                    rootPath: '/project',
-                    presetName: input.presetName,
-                });
-                created = (await this.store.update(created.id, {
-                    containerId: container.id,
-                    containerPort: container.hostPort,
-                    devchainProjectId: project.projectId,
-                    status: 'running',
-                    errorMessage: null,
-                }));
-            }
-            this.consecutiveHealthFailures.set(created.id, 0);
-            this.eventEmitter.emit(worktree_events_1.WORKTREE_CHANGED_EVENT, {
-                worktreeId: created.id,
-            });
-            this.recordWorktreeActivity({
-                worktreeId: created.id,
-                worktreeName: created.name,
-                ownerProjectId: created.ownerProjectId,
-                type: 'created',
-                message: `Worktree '${created.name}' created on branch ${created.branchName}`,
-            });
-            const response = await this.toResponse(created);
-            return {
-                ...response,
-                copyResults,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            await this.tryUpdateStatus(created.id, 'error', {
-                errorMessage,
-            });
-            if (containerId) {
-                await this.containerRuntime.removeContainer(containerId, true).catch(() => undefined);
-            }
-            if (processId) {
-                await this.processRuntime.terminateProcess(processId).catch(() => undefined);
-            }
-            if (gitWorktreeCreated) {
-                await this.gitService.removeWorktree(worktreePath, repoPath, true).catch(() => undefined);
-                if (created.branchName !== created.baseBranch) {
-                    await this.gitService
-                        .deleteBranch(created.branchName, repoPath, true)
-                        .catch((cleanupError) => logger.warn({
-                        error: cleanupError,
-                        worktreeId: created.id,
-                        branchName: created.branchName,
-                    }, 'Failed to clean up branch after create-worktree error'));
-                }
-            }
-            const crashLog = await this.processRuntime.readRecentLog(dataPath);
-            if (crashLog) {
-                logger.error({ worktreeId: created.id, logContent: crashLog }, 'Process runtime log before cleanup');
-            }
-            await (0, promises_1.rm)(dataPath, { recursive: true, force: true }).catch(() => undefined);
-            throw new common_1.BadRequestException(`Failed to create worktree: ${errorMessage}`);
-        }
-    }
-    async listWorktrees() {
-        const rows = await this.store.list();
-        return Promise.all(rows.map((row) => this.toResponse(row)));
-    }
-    async listByOwnerProject(ownerProjectId) {
-        const rows = await this.store.listByOwnerProject(ownerProjectId);
-        return Promise.all(rows.map((row) => this.toResponse(row)));
-    }
-    async getWorktree(id) {
-        const row = await this.store.getById(id);
-        if (!row) {
-            throw new common_1.NotFoundException(`Worktree not found: ${id}`);
-        }
-        return this.toResponse(row);
-    }
-    async listWorktreeOverviews(ownerProjectId) {
-        const rows = ownerProjectId
-            ? await this.store.listByOwnerProject(ownerProjectId)
-            : await this.store.list();
-        return Promise.all(rows.map((row) => this.buildWorktreeOverview(row)));
-    }
-    async getWorktreeOverview(id) {
-        const row = await this.requireWorktree(id);
-        return this.buildWorktreeOverview(row);
-    }
-    async deleteWorktree(id, options = {}) {
-        return this.withOperationGuard(id, 'delete', () => this.executeDelete(id, options));
-    }
-    async executeDelete(id, options) {
-        const row = await this.requireWorktree(id);
-        const runtimeType = this.resolveRuntimeType(row.runtimeType);
-        const shouldDeleteBranch = options.deleteBranch ?? true;
-        const repoPath = this.resolveRepoPath(row.repoPath);
-        const worktreeRoot = this.resolveWorktreeRoot(repoPath);
-        const worktreePath = row.worktreePath
-            ? this.ensurePathWithinRoot(worktreeRoot, row.worktreePath, 'worktree path')
-            : null;
-        const dataPath = this.resolveDataPath(repoPath, row.name);
-        if (runtimeType === 'container' || row.containerId) {
-            await this.containerRuntime
-                .cleanupWorktreeProjectContainers(row.name, row.containerId)
-                .catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed cleaning project sub-containers'));
-            if (row.containerId) {
-                await this.containerRuntime.stopContainer(row.containerId).catch(() => undefined);
-                await this.containerRuntime.removeContainer(row.containerId, true).catch(() => undefined);
-            }
-            await this.containerRuntime
-                .removeWorktreeNetwork(row.name)
-                .catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed removing worktree docker network'));
-        }
-        else {
-            await this.processRuntime
-                .terminateProcess(row.processId)
-                .catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed stopping worktree process during delete'));
-        }
-        if (worktreePath) {
-            await this.gitService.removeWorktree(worktreePath, repoPath, true).catch(() => undefined);
-        }
-        if (shouldDeleteBranch && row.branchName !== row.baseBranch) {
-            await this.gitService.deleteBranch(row.branchName, repoPath, true).catch((error) => logger.warn({
-                error,
-                worktreeId: row.id,
-                branchName: row.branchName,
-            }, 'Failed deleting branch during worktree cleanup'));
-        }
-        await (0, promises_1.rm)(dataPath, { recursive: true, force: true }).catch(() => undefined);
-        this.consecutiveHealthFailures.delete(row.id);
-        await this.store.remove(row.id);
-        this.recordWorktreeActivity({
-            worktreeId: row.id,
-            worktreeName: row.name,
-            ownerProjectId: row.ownerProjectId,
-            type: 'deleted',
-            message: `Worktree '${row.name}' deleted`,
-        });
-        this.eventEmitter.emit(worktree_events_1.WORKTREE_CHANGED_EVENT, {
-            worktreeId: row.id,
-        });
-        return { success: true };
-    }
-    async startWorktree(id) {
-        return this.withOperationGuard(id, 'start', () => this.executeStart(id));
-    }
-    async executeStart(id) {
-        const row = await this.requireWorktree(id);
-        const runtimeType = this.resolveRuntimeType(row.runtimeType);
-        if (runtimeType === 'process') {
-            const projectId = row.devchainProjectId?.trim();
-            if (!projectId) {
-                throw new common_1.BadRequestException('Worktree has no scoped project id to start');
-            }
-            const repoPath = this.resolveRepoPath(row.repoPath);
-            const worktreePath = row.worktreePath ?? this.resolveWorktreePath(repoPath, row.name);
-            const dataPath = this.resolveDataPath(repoPath, row.name);
-            await (0, promises_1.mkdir)(dataPath, { recursive: true });
-            try {
-                const runtime = await this.processRuntime.startProcessRuntime({
-                    worktreePath,
-                    dataPath,
-                    projectId,
-                });
-                const updated = await this.tryUpdateStatus(row.id, 'running', {
-                    processId: runtime.processId,
-                    runtimeToken: runtime.runtimeToken,
-                    startedAt: runtime.startedAt,
-                    containerPort: runtime.hostPort,
-                    errorMessage: null,
-                });
-                return this.toResponse(updated ?? row);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                await this.tryUpdateStatus(row.id, 'error', {
-                    errorMessage: `Process failed readiness check after start: ${message}`,
-                });
-                throw new common_1.BadRequestException(`Failed to start process worktree: ${message}`);
-            }
-        }
-        if (!row.containerId) {
-            throw new common_1.BadRequestException('Worktree has no container to start');
-        }
-        await this.containerRuntime.startContainer(row.containerId);
-        const healthy = await this.containerRuntime.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
-        if (!healthy) {
-            await this.tryUpdateStatus(row.id, 'error', {
-                errorMessage: 'Container failed readiness check after start',
-            });
-            throw new common_1.BadRequestException('Container started but failed readiness check');
-        }
-        await this.containerRuntime
-            .ensureWorktreeOnComposeNetwork(row.name, row.containerId)
-            .catch(() => undefined);
-        const hostPort = await this.containerRuntime
-            .getContainerHostPort(row.containerId)
-            .catch(() => null);
-        const updated = await this.tryUpdateStatus(row.id, 'running', {
-            errorMessage: null,
-            ...(hostPort != null ? { containerPort: hostPort } : {}),
-        });
-        return this.toResponse(updated ?? row);
-    }
-    async stopWorktree(id) {
-        return this.withOperationGuard(id, 'stop', () => this.executeStop(id));
-    }
-    async executeStop(id) {
-        const row = await this.requireWorktree(id);
-        const runtimeType = this.resolveRuntimeType(row.runtimeType);
-        if (runtimeType === 'process') {
-            await this.processRuntime.terminateProcess(row.processId);
-            this.consecutiveHealthFailures.set(row.id, 0);
-            const updated = await this.tryUpdateStatus(row.id, 'stopped', {
-                processId: null,
-                runtimeToken: null,
-                startedAt: null,
-                containerPort: null,
-                errorMessage: null,
-            });
-            return this.toResponse(updated ?? row);
-        }
-        if (!row.containerId) {
-            throw new common_1.BadRequestException('Worktree has no container to stop');
-        }
-        await this.containerRuntime.stopContainer(row.containerId);
-        this.consecutiveHealthFailures.set(row.id, 0);
-        const updated = await this.tryUpdateStatus(row.id, 'stopped');
-        return this.toResponse(updated ?? row);
-    }
-    async previewMergeWorktree(id) {
-        const row = await this.requireWorktree(id);
-        const currentStatus = String(row.status).toLowerCase();
-        if (currentStatus === 'merged') {
-            throw new common_1.BadRequestException('Worktree is already merged');
-        }
-        const [branchStatus, changeSummary, preview] = await Promise.all([
-            this.gitService.getBranchStatus(row.repoPath, row.baseBranch, row.branchName),
-            this.gitService.getBranchChangeSummary(row.repoPath, row.baseBranch, row.branchName),
-            this.gitService.previewMerge(row.repoPath, row.branchName, row.baseBranch),
-        ]);
-        const conflicts = this.buildConflictDetails(preview.conflicts.length > 0 ? preview.conflicts : this.extractConflictFiles(preview.output), 'merge');
-        if (conflicts.length === 0 && row.mergeConflicts?.trim()) {
-            await this.store.update(row.id, {
-                mergeConflicts: null,
-            });
-        }
-        return {
-            canMerge: !preview.hasConflicts,
-            commitsAhead: branchStatus.commitsAhead,
-            commitsBehind: branchStatus.commitsBehind,
-            filesChanged: changeSummary.filesChanged,
-            insertions: changeSummary.insertions,
-            deletions: changeSummary.deletions,
-            conflicts,
-        };
-    }
-    async mergeWorktree(id) {
-        return this.withOperationGuard(id, 'merge', () => this.executeMerge(id));
-    }
-    async executeMerge(id) {
-        const row = await this.requireWorktree(id);
-        const currentStatus = String(row.status).toLowerCase();
-        if (currentStatus === 'merged') {
-            throw new common_1.BadRequestException('Worktree is already merged');
-        }
-        if (!['running', 'stopped', 'completed', 'error'].includes(currentStatus)) {
-            throw new common_1.BadRequestException(`Cannot merge worktree while status is "${row.status}"`);
-        }
-        await this.assertCleanWorkingTree(row.worktreePath ?? row.repoPath, 'Merge');
-        const extractionRow = currentStatus === 'running' ? row : await this.ensureContainerReadyForTaskExtraction(row);
-        await this.extractTasksForMergedHistory(extractionRow);
-        if (row.containerId) {
-            await this.containerRuntime.stopContainer(row.containerId).catch(() => undefined);
-        }
-        const mergeResult = await this.gitService.executeMerge(row.repoPath, row.branchName, row.baseBranch, {
-            message: this.buildMergeCommitMessage(row),
-        });
-        if (!mergeResult.success || !mergeResult.mergeCommit) {
-            const message = mergeResult.output.trim() || 'Merge failed';
-            const conflictFiles = mergeResult.conflicts && mergeResult.conflicts.length > 0
-                ? mergeResult.conflicts
-                : this.extractConflictFiles(message);
-            const conflictDetails = this.buildConflictDetails(conflictFiles, 'merge');
-            const hasConflicts = conflictDetails.length > 0 || /\bconflict\b/i.test(message);
-            await this.tryUpdateStatus(row.id, 'error', {
-                mergeConflicts: hasConflicts && conflictFiles.length > 0 ? conflictFiles.join('\n') : null,
-                errorMessage: message,
-            });
-            if (hasConflicts) {
-                throw new common_1.ConflictException({
-                    message: 'Merge failed with conflicts',
-                    conflicts: conflictDetails,
-                });
-            }
-            throw new common_1.BadRequestException(`Merge failed: ${message}`);
-        }
-        this.consecutiveHealthFailures.set(row.id, 0);
-        const mergedMessage = `Worktree '${row.name}' merged into ${row.baseBranch}`;
-        const updated = await this.tryUpdateStatus(row.id, 'merged', {
-            mergeCommit: mergeResult.mergeCommit,
-            mergeConflicts: null,
-            errorMessage: null,
-        }, { activity: { type: 'merged', message: mergedMessage } });
-        return this.toResponse(updated ?? row);
-    }
-    async rebaseWorktree(id) {
-        return this.withOperationGuard(id, 'rebase', () => this.executeRebase(id));
-    }
-    async executeRebase(id) {
-        const row = await this.requireWorktree(id);
-        const currentStatus = String(row.status).toLowerCase();
-        if (currentStatus === 'merged') {
-            throw new common_1.BadRequestException('Cannot rebase a merged worktree');
-        }
-        if (!['running', 'stopped', 'completed', 'error'].includes(currentStatus)) {
-            throw new common_1.BadRequestException(`Cannot rebase worktree while status is "${row.status}"`);
-        }
-        await this.assertCleanWorkingTree(row.worktreePath ?? row.repoPath, 'Rebase');
-        if (row.containerId) {
-            await this.containerRuntime.stopContainer(row.containerId).catch(() => undefined);
-        }
-        const rebaseResult = await this.gitService.executeRebase(row.worktreePath ?? row.repoPath, row.branchName, row.baseBranch);
-        if (!rebaseResult.success) {
-            const message = rebaseResult.output.trim() || 'Rebase failed';
-            const conflictFiles = rebaseResult.conflicts.length > 0
-                ? rebaseResult.conflicts
-                : this.extractConflictFiles(rebaseResult.output);
-            const conflictDetails = this.buildConflictDetails(conflictFiles, 'rebase');
-            const hasConflicts = conflictDetails.length > 0 || /\bconflict\b/i.test(message);
-            await this.tryUpdateStatus(row.id, 'error', {
-                mergeConflicts: hasConflicts && conflictFiles.length > 0 ? conflictFiles.join('\n') : null,
-                errorMessage: message,
-            });
-            if (hasConflicts) {
-                throw new common_1.ConflictException({
-                    message: 'Rebase failed with conflicts',
-                    conflicts: conflictDetails,
-                });
-            }
-            throw new common_1.BadRequestException(`Rebase failed: ${message}`);
-        }
-        if (row.containerId) {
-            await this.containerRuntime.startContainer(row.containerId).catch(() => undefined);
-            const healthy = await this.containerRuntime.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
-            if (!healthy) {
-                await this.tryUpdateStatus(row.id, 'error', {
-                    errorMessage: 'Container failed readiness check after rebase',
-                });
-                throw new common_1.BadRequestException('Rebase succeeded but container failed readiness check');
-            }
-            this.recordWorktreeActivity({
-                worktreeId: row.id,
-                worktreeName: row.name,
-                ownerProjectId: row.ownerProjectId,
-                type: 'rebased',
-                message: `Worktree '${row.name}' rebased onto ${row.baseBranch}`,
-            });
-            const updated = await this.tryUpdateStatus(row.id, 'running', {
-                mergeConflicts: null,
-                errorMessage: null,
-            });
-            return this.toResponse(updated ?? row);
-        }
-        this.recordWorktreeActivity({
-            worktreeId: row.id,
-            worktreeName: row.name,
-            ownerProjectId: row.ownerProjectId,
-            type: 'rebased',
-            message: `Worktree '${row.name}' rebased onto ${row.baseBranch}`,
-        });
-        const updated = await this.store.update(row.id, {
-            mergeConflicts: null,
-            errorMessage: null,
-        });
-        return this.toResponse(updated ?? row);
-    }
-    async extractTasksForMergedHistory(row) {
-        let extractionError;
-        try {
-            await this.emitTaskMergeRequested(row.id);
-            return;
-        }
-        catch (error) {
-            extractionError = error;
-        }
-        const recovered = await this.tryRecoverContainerForTaskExtraction(row);
-        if (recovered) {
-            try {
-                await this.emitTaskMergeRequested(row.id);
-                return;
-            }
-            catch (retryError) {
-                extractionError = retryError;
-            }
-        }
-        const message = extractionError instanceof Error ? extractionError.message : String(extractionError);
-        const actionableMessage = 'Merge blocked: unable to preserve task history. Start or restore the worktree container, then retry merge.';
-        await this.tryUpdateStatus(row.id, 'error', {
-            errorMessage: `Task extraction failed before merge: ${message}`,
-        });
-        throw new common_1.BadRequestException(`${actionableMessage} (${message})`);
-    }
-    async emitTaskMergeRequested(worktreeId) {
-        const results = await this.eventEmitter.emitAsync(task_merge_events_1.WORKTREE_TASK_MERGE_REQUESTED_EVENT, {
-            worktreeId,
-        });
-        if (results.length === 0) {
-            throw new Error('No task merge handlers registered');
-        }
-    }
-    async ensureContainerReadyForTaskExtraction(row) {
-        if (!row.containerId) {
-            throw new common_1.BadRequestException('Merge blocked: worktree container is missing. Recreate or start a container before merge to preserve task history.');
-        }
-        const recovered = await this.tryRecoverContainerForTaskExtraction(row);
-        if (!recovered) {
-            await this.tryUpdateStatus(row.id, 'error', {
-                errorMessage: 'Task extraction failed before merge: container could not be started',
-            });
-            throw new common_1.BadRequestException('Merge blocked: unable to start worktree container for task extraction. Restore the container and retry merge.');
-        }
-        const refreshed = await this.requireWorktree(row.id);
-        return refreshed;
-    }
-    async tryRecoverContainerForTaskExtraction(row) {
-        if (!row.containerId) {
-            return false;
-        }
-        try {
-            await this.containerRuntime.startContainer(row.containerId).catch(() => undefined);
-            const healthy = await this.containerRuntime.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
-            if (!healthy) {
-                return false;
-            }
-            await this.tryUpdateStatus(row.id, 'running', {
-                errorMessage: null,
-            }).catch(() => undefined);
-            return true;
-        }
-        catch (error) {
-            logger.warn({ error, worktreeId: row.id }, 'Failed recovering container for task extraction');
-            return false;
-        }
-    }
-    async assertCleanWorkingTree(path, operation) {
-        const status = await this.gitService.getWorkingTreeStatus(path);
-        if (status.clean) {
-            return;
-        }
-        throw new common_1.ConflictException({
-            message: `${operation} blocked: worktree has uncommitted changes`,
-            conflicts: [{ file: 'WORKTREE_DIRTY', type: 'uncommitted' }],
-            details: status.output,
-        });
-    }
-    buildMergeCommitMessage(row) {
-        const description = row.description?.trim();
-        if (!description) {
-            return `Merge ${row.branchName}`;
-        }
-        return `Merge ${row.branchName}: ${description}`;
-    }
-    extractConflictFiles(raw) {
-        const lines = raw.split('\n');
-        const files = new Set();
-        for (const line of lines) {
-            let match = line.match(/CONFLICT \([^)]+\): .* in (.+)$/i);
-            if (!match) {
-                match = line.match(/^\s*both modified:\s+(.+)$/i);
-            }
-            if (!match) {
-                match = line.match(/^\s*UU\s+(.+)$/i);
-            }
-            if (match?.[1]) {
-                files.add(match[1].trim());
-            }
-        }
-        return [...files];
-    }
-    buildConflictDetails(files, type) {
-        return [...new Set(files.map((file) => file.trim()).filter(Boolean))].map((file) => ({
-            file,
-            type,
-        }));
-    }
-    async getWorktreeLogs(id, query) {
-        const row = await this.requireWorktree(id);
-        if (this.resolveRuntimeType(row.runtimeType) === 'process') {
-            const dataPath = this.resolveDataPath(row.repoPath, row.name);
-            return { logs: await this.processRuntime.readLogs(dataPath, query.tail) };
-        }
-        if (!row.containerId) {
-            throw new common_1.BadRequestException('Worktree has no container');
-        }
-        const logs = await this.containerRuntime.getContainerLogs(row.containerId, query.tail);
-        return { logs };
-    }
-    async buildWorktreeOverview(row) {
-        const worktree = await this.toResponse(row);
-        const fallback = {
-            worktree,
-            epics: { total: null, done: null },
-            agents: { total: null },
-            fetchedAt: new Date().toISOString(),
-        };
-        if (!row.containerPort || !row.devchainProjectId) {
-            return fallback;
-        }
-        const status = String(row.status).toLowerCase();
-        if (!['running', 'stopped', 'completed'].includes(status)) {
-            return fallback;
-        }
-        const baseUrl = `http://127.0.0.1:${row.containerPort}`;
-        const [epicsPayload, statusesPayload, agentsPayload] = await Promise.all([
-            this.fetchContainerJson(`${baseUrl}/api/epics?projectId=${encodeURIComponent(row.devchainProjectId)}&limit=1000`),
-            this.fetchContainerJson(`${baseUrl}/api/projects/${encodeURIComponent(row.devchainProjectId)}/statuses?limit=500`),
-            this.fetchContainerJson(`${baseUrl}/api/agents?projectId=${encodeURIComponent(row.devchainProjectId)}`),
-        ]);
-        if (!epicsPayload || !statusesPayload || !agentsPayload) {
-            return fallback;
-        }
-        const statusItems = statusesPayload.items ?? [];
-        const doneStatusIds = new Set(statusItems
-            .filter((statusItem) => {
-            const label = statusItem.label?.trim().toLowerCase();
-            return label === 'done' || label === 'completed';
-        })
-            .map((statusItem) => statusItem.id)
-            .filter((statusId) => Boolean(statusId)));
-        const epicItems = epicsPayload.items ?? [];
-        const doneCount = epicItems.reduce((total, epic) => {
-            if (!epic.statusId) {
-                return total;
-            }
-            return doneStatusIds.has(epic.statusId) ? total + 1 : total;
-        }, 0);
-        return {
-            worktree,
-            epics: {
-                total: typeof epicsPayload.total === 'number' ? epicsPayload.total : epicItems.length,
-                done: doneCount,
-            },
-            agents: {
-                total: typeof agentsPayload.total === 'number' ? agentsPayload.total : null,
-            },
-            fetchedAt: new Date().toISOString(),
-        };
-    }
-    async fetchContainerJson(url) {
-        const abortController = new AbortController();
-        const timeout = setTimeout(() => abortController.abort(), OVERVIEW_FETCH_TIMEOUT_MS);
-        try {
-            const response = await fetch(url, {
-                headers: { accept: 'application/json' },
-                signal: abortController.signal,
-            });
-            if (!response.ok) {
-                return null;
-            }
-            return (await response.json());
-        }
-        catch {
-            return null;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    async monitorRunningWorktrees() {
-        const rows = await this.store.listMonitored();
-        await Promise.all(rows.map(async (row) => {
-            const runtimeType = this.resolveRuntimeType(row.runtimeType);
-            if (runtimeType === 'process') {
-                await this.monitorProcessWorktree(row);
-                return;
-            }
-            if (!row.containerId) {
-                return;
-            }
-            await this.containerRuntime
-                .ensureWorktreeOnComposeNetwork(row.name, row.containerId)
-                .catch(() => undefined);
-            const healthy = await this.containerRuntime.waitForHealthy(row.containerId, HEALTH_MONITOR_PROBE_TIMEOUT_MS);
-            if (healthy) {
-                this.consecutiveHealthFailures.set(row.id, 0);
-                if (row.status === 'error') {
-                    await this.tryUpdateStatus(row.id, 'running', {
-                        errorMessage: null,
-                    });
-                }
-                return;
-            }
-            const failures = (this.consecutiveHealthFailures.get(row.id) ?? 0) + 1;
-            this.consecutiveHealthFailures.set(row.id, failures);
-            if (row.status === 'running' && failures >= MAX_CONSECUTIVE_HEALTH_FAILURES) {
-                await this.tryUpdateStatus(row.id, 'error', {
-                    errorMessage: `Readiness probe failed ${failures} consecutive times`,
-                });
-            }
-        }));
-    }
-    async monitorProcessWorktree(row) {
-        const verdict = await this.processRuntime.probeHealth({
-            pid: row.processId ?? null,
-            hostPort: row.containerPort ?? null,
-            runtimeToken: row.runtimeToken?.trim() || null,
-        });
-        if (verdict === 'dead' || verdict === 'token-mismatch') {
-            this.consecutiveHealthFailures.set(row.id, 0);
-            await this.tryUpdateStatus(row.id, 'stopped', {
-                processId: null,
-                runtimeToken: null,
-                startedAt: null,
-                containerPort: null,
-                errorMessage: null,
-            });
-            return;
-        }
-        if (verdict === 'unreachable') {
-            await this.handleProcessProbeFailure(row.id, row.status);
-            return;
-        }
-        this.consecutiveHealthFailures.set(row.id, 0);
-        if (row.status === 'error') {
-            await this.tryUpdateStatus(row.id, 'running', {
-                errorMessage: null,
-            });
-        }
-    }
-    async handleProcessProbeFailure(id, status) {
-        const failures = (this.consecutiveHealthFailures.get(id) ?? 0) + 1;
-        this.consecutiveHealthFailures.set(id, failures);
-        if (status === 'running' && failures >= MAX_CONSECUTIVE_HEALTH_FAILURES) {
-            await this.tryUpdateStatus(id, 'error', {
-                errorMessage: `Readiness probe failed ${failures} consecutive times`,
-            });
-        }
-    }
-    async reconcileProcessOrphans() {
-        const rows = await this.store.listMonitored();
-        const candidates = rows.filter((row) => this.resolveRuntimeType(row.runtimeType) === 'process' && row.status === 'running');
-        await Promise.all(candidates.map(async (row) => {
-            const pid = row.processId ?? null;
-            if (!pid || !this.processRuntime.isProcessAlive(pid)) {
-                await this.tryUpdateStatus(row.id, 'stopped', {
-                    processId: null,
-                    runtimeToken: null,
-                    startedAt: null,
-                    containerPort: null,
-                    errorMessage: null,
-                });
-                return;
-            }
-            if (!row.containerPort || !row.runtimeToken) {
-                await this.tryUpdateStatus(row.id, 'stopped', {
-                    processId: null,
-                    runtimeToken: null,
-                    startedAt: null,
-                    containerPort: null,
-                    errorMessage: null,
-                });
-                return;
-            }
-            const metadata = await this.processRuntime.fetchRuntimeMetadata(row.containerPort);
-            if (!metadata || metadata.runtimeToken !== row.runtimeToken) {
-                await this.tryUpdateStatus(row.id, 'stopped', {
-                    processId: null,
-                    runtimeToken: null,
-                    startedAt: null,
-                    containerPort: null,
-                    errorMessage: null,
-                });
-            }
-        }));
-    }
-    resolveRuntimeType(runtimeType) {
-        return runtimeType === 'process' ? 'process' : 'container';
-    }
-    async handleContainerEvent(event) {
-        const containerId = event.id;
-        if (!containerId) {
-            return;
-        }
-        const action = event.Action ?? event.status;
-        if (!action) {
-            return;
-        }
-        const row = await this.store.getByContainerId(containerId);
-        if (!row) {
-            return;
-        }
-        if (['die', 'stop', 'kill', 'destroy'].includes(action)) {
-            this.consecutiveHealthFailures.set(row.id, 0);
-            await this.tryUpdateStatus(row.id, 'stopped', {
-                errorMessage: null,
-            });
-            return;
-        }
-        if (['start', 'restart'].includes(action)) {
-            this.consecutiveHealthFailures.set(row.id, 0);
-            await this.tryUpdateStatus(row.id, 'running', {
-                errorMessage: null,
-            });
-        }
-    }
-    async requireWorktree(id) {
-        const row = await this.store.getById(id);
-        if (!row) {
-            throw new common_1.NotFoundException(`Worktree not found: ${id}`);
-        }
-        return row;
-    }
-    withOperationGuard(worktreeId, operation, run) {
-        const inFlight = this.inFlightOperations.get(worktreeId);
-        if (inFlight) {
-            if (inFlight.operation === operation) {
-                return inFlight.promise;
-            }
-            throw new common_1.ConflictException(`Worktree is already running an in-flight "${inFlight.operation}" operation`);
-        }
-        const promise = run().finally(() => {
-            this.inFlightOperations.delete(worktreeId);
-        });
-        this.inFlightOperations.set(worktreeId, { operation, promise });
-        return promise;
-    }
-    async registerProjectInContainer(hostPort, input) {
-        if (!hostPort) {
-            throw new Error('Container did not expose a host port');
-        }
-        await this.ensureTemplateExists(hostPort, input.templateSlug);
-        const response = await fetch(`http://127.0.0.1:${hostPort}/api/projects/from-template`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({
-                name: input.name,
-                description: input.description,
-                rootPath: input.rootPath,
-                slug: input.templateSlug,
-                projectId: input.projectId,
-                ...(input.presetName && { presetName: input.presetName }),
-            }),
-        });
-        const payload = (await response.json().catch(() => ({})));
-        logger.debug({
-            hostPort,
-            status: response.status,
-            success: payload.success,
-            projectId: payload.project?.id,
-            message: payload.message,
-        }, 'registerProjectInContainer response');
-        if (!response.ok) {
-            throw new Error(payload.message || `Project registration failed with HTTP ${response.status}`);
-        }
-        if (!payload.success || !payload.project?.id) {
-            throw new Error('Project registration failed: invalid response payload');
-        }
-        if (payload.project.id !== input.projectId) {
-            throw new Error('Project registration failed: returned project id did not match requested id');
-        }
-        return { projectId: payload.project.id };
-    }
-    async ensureTemplateExists(hostPort, templateSlug) {
-        const response = await fetch(`http://127.0.0.1:${hostPort}/api/templates`);
-        const payload = (await response.json().catch(() => ({})));
-        const templates = payload.templates ?? [];
-        if (!response.ok || !templates.some((template) => template.slug === templateSlug)) {
-            throw new Error(`Template slug "${templateSlug}" is not available in runtime`);
-        }
-    }
-    resolveRepoPath(repoPath) {
-        if (repoPath) {
-            return (0, path_1.resolve)(repoPath);
-        }
-        const env = (0, env_config_1.getEnvConfig)();
-        if (env.DEVCHAIN_MODE !== 'normal' && env.REPO_ROOT) {
-            return (0, path_1.resolve)(env.REPO_ROOT);
-        }
-        return (0, path_1.resolve)(process.cwd());
-    }
-    async resolveCreateRepoPath(input) {
-        if (!this.storage) {
-            return this.resolveRepoPath(input.repoPath);
-        }
-        const project = await this.storage.getProject(input.ownerProjectId);
-        const rootPath = project.rootPath?.trim();
-        if (!rootPath) {
-            throw new common_1.BadRequestException(`Project ${input.ownerProjectId} has no rootPath configured`);
-        }
-        return (0, path_1.resolve)(rootPath);
-    }
-    async prepareIgnoredCopyPlan(repoPath, worktreePath, requestedPaths) {
-        if (requestedPaths.length === 0) {
-            return {
-                requestedCount: 0,
-                deduplicatedCount: 0,
-                operations: [],
-            };
-        }
-        const normalizedRequested = this.normalizeAndDedupeIgnoredPaths(requestedPaths);
-        const ignoredFiles = await this.gitService.listIgnoredFiles(repoPath);
-        const allowedPaths = new Set(ignoredFiles.map((entry) => this.normalizeIgnoredPath(entry.path)));
-        const operations = [];
-        for (const relativePath of normalizedRequested) {
-            if (!allowedPaths.has(relativePath)) {
-                throw new common_1.BadRequestException(`Ignored path "${relativePath}" is not currently gitignored in repository`);
-            }
-            try {
-                const validatedSource = (0, path_validation_1.validatePathWithinRoot)(repoPath, relativePath, {
-                    errorPrefix: 'Ignored file validation failed',
-                });
-                const sourcePath = await (0, path_validation_1.validateResolvedPathWithinRoot)(validatedSource.absolutePath, repoPath, {
-                    errorPrefix: 'Ignored file validation failed',
-                });
-                const validatedDestination = (0, path_validation_1.validatePathWithinRoot)(worktreePath, relativePath, {
-                    errorPrefix: 'Ignored file validation failed',
-                });
-                const destinationPath = await (0, path_validation_1.validateResolvedPathWithinRoot)(validatedDestination.absolutePath, worktreePath, {
-                    errorPrefix: 'Ignored file validation failed',
-                    allowNonExistent: true,
-                });
-                operations.push({
-                    relativePath,
-                    sourcePath,
-                    destinationPath,
-                });
-            }
-            catch (error) {
-                if (error instanceof error_types_1.ValidationError) {
-                    throw new common_1.BadRequestException(error.message);
-                }
-                throw error;
-            }
-        }
-        return {
-            requestedCount: requestedPaths.length,
-            deduplicatedCount: normalizedRequested.length,
-            operations,
-        };
-    }
-    normalizeAndDedupeIgnoredPaths(requestedPaths) {
-        const deduplicated = [];
-        const seen = new Set();
-        for (const requestedPath of requestedPaths) {
-            const normalizedPath = this.normalizeIgnoredPath(requestedPath);
-            if (!normalizedPath) {
-                throw new common_1.BadRequestException('Ignored file path cannot be empty');
-            }
-            if (seen.has(normalizedPath)) {
-                continue;
-            }
-            seen.add(normalizedPath);
-            deduplicated.push(normalizedPath);
-        }
-        return deduplicated;
-    }
-    normalizeIgnoredPath(path) {
-        const trimmed = path.trim().replace(/\\/g, '/');
-        const withoutLeadingDot = trimmed.replace(/^\.\/+/, '');
-        const collapsedSeparators = withoutLeadingDot.replace(/\/{2,}/g, '/');
-        return collapsedSeparators.replace(/\/+$/, '');
-    }
-    resolveWorktreeRoot(repoPath) {
-        const env = (0, env_config_1.getEnvConfig)();
-        const root = env.WORKTREES_ROOT ?? (0, path_1.join)(repoPath, 'worktrees');
-        return (0, path_1.resolve)(root);
-    }
-    resolveDataRoot(repoPath) {
-        const env = (0, env_config_1.getEnvConfig)();
-        const root = env.WORKTREES_DATA_ROOT ?? (0, path_1.join)(repoPath, 'worktrees-data');
-        return (0, path_1.resolve)(root);
-    }
-    resolveWorktreePath(repoPath, name) {
-        this.assertValidWorktreeName(name);
-        const root = this.resolveWorktreeRoot(repoPath);
-        return this.ensurePathWithinRoot(root, (0, path_1.resolve)(root, name), 'worktree path');
-    }
-    resolveDataPath(repoPath, name) {
-        this.assertValidWorktreeName(name);
-        const root = this.resolveDataRoot(repoPath);
-        return this.ensurePathWithinRoot(root, (0, path_1.resolve)(root, name, 'data'), 'worktree data path');
-    }
-    getContainerName(name) {
-        this.assertValidWorktreeName(name);
-        return `devchain-wt-${name}`;
-    }
-    ensurePathWithinRoot(rootPath, candidatePath, label) {
-        const resolvedRoot = (0, path_1.resolve)(rootPath);
-        const resolvedCandidate = (0, path_1.resolve)(candidatePath);
-        const rootWithSeparator = resolvedRoot.endsWith(path_1.sep) ? resolvedRoot : `${resolvedRoot}${path_1.sep}`;
-        if (resolvedCandidate !== resolvedRoot && !resolvedCandidate.startsWith(rootWithSeparator)) {
-            throw new common_1.BadRequestException(`Invalid ${label}: path escapes configured root`);
-        }
-        const relativePath = (0, path_1.relative)(resolvedRoot, resolvedCandidate);
-        if (relativePath.startsWith('..') || (0, path_1.isAbsolute)(relativePath)) {
-            throw new common_1.BadRequestException(`Invalid ${label}: path escapes configured root`);
-        }
-        return resolvedCandidate;
-    }
-    assertValidWorktreeName(name) {
-        if (!(0, worktree_validation_1.isValidWorktreeName)(name)) {
-            throw new common_1.BadRequestException('Invalid worktree name. Use lowercase letters, numbers, and hyphens (1-63 chars, no edge hyphen).');
-        }
-    }
-    assertValidBranchName(branchName, fieldName) {
-        if (!(0, worktree_validation_1.isValidGitBranchName)(branchName)) {
-            throw new common_1.BadRequestException(`Invalid ${fieldName}`);
-        }
-    }
-    async toResponse(row) {
-        let commitsAhead = null;
-        let commitsBehind = null;
-        if (row.repoPath && row.baseBranch && row.branchName) {
-            try {
-                const branchStatus = await this.gitService.getBranchStatus(row.repoPath, row.baseBranch, row.branchName);
-                commitsAhead = branchStatus.commitsAhead;
-                commitsBehind = branchStatus.commitsBehind;
-            }
-            catch (error) {
-                logger.debug({ error, worktreeId: row.id }, 'Unable to compute branch ahead/behind');
-            }
-        }
-        return {
-            id: row.id,
-            name: row.name,
-            branchName: row.branchName,
-            baseBranch: row.baseBranch,
-            repoPath: row.repoPath,
-            worktreePath: row.worktreePath ?? null,
-            containerId: row.containerId ?? null,
-            containerPort: row.containerPort ?? null,
-            templateSlug: row.templateSlug,
-            ownerProjectId: row.ownerProjectId,
-            status: row.status,
-            description: row.description ?? null,
-            devchainProjectId: row.devchainProjectId ?? null,
-            mergeCommit: row.mergeCommit ?? null,
-            mergeConflicts: row.mergeConflicts ?? null,
-            errorMessage: row.errorMessage ?? null,
-            commitsAhead,
-            commitsBehind,
-            runtimeType: row.runtimeType ?? 'container',
-            processId: row.processId ?? null,
-            runtimeToken: row.runtimeToken ?? null,
-            startedAt: row.startedAt ? row.startedAt.toISOString() : null,
-            createdAt: row.createdAt.toISOString(),
-            updatedAt: row.updatedAt.toISOString(),
-        };
-    }
-    async tryUpdateStatus(id, nextStatus, extraPatch = {}, options = {}) {
-        const current = await this.store.getById(id);
-        if (!current) {
-            return null;
-        }
-        this.assertValidStatusTransition(current.status, nextStatus);
-        const updated = await this.store.update(id, {
-            ...extraPatch,
-            status: nextStatus,
-        });
-        if (!updated) {
-            return null;
-        }
-        if (current.status !== nextStatus) {
-            this.eventEmitter.emit(worktree_events_1.WORKTREE_CHANGED_EVENT, {
-                worktreeId: id,
-            });
-            const activity = options.activity ?? this.getStatusTransitionActivity(current, updated, nextStatus);
-            if (activity) {
-                this.recordWorktreeActivity({
-                    worktreeId: id,
-                    worktreeName: updated.name,
-                    ownerProjectId: updated.ownerProjectId,
-                    type: activity.type,
-                    message: activity.message,
-                });
-            }
-        }
-        return updated;
-    }
-    getStatusTransitionActivity(current, updated, nextStatus) {
-        if (current.status === nextStatus) {
-            return null;
-        }
-        if (nextStatus === 'running') {
-            return {
-                type: 'started',
-                message: `Worktree '${updated.name}' started`,
-            };
-        }
-        if (nextStatus === 'stopped') {
-            return {
-                type: 'stopped',
-                message: `Worktree '${updated.name}' stopped`,
-            };
-        }
-        if (nextStatus === 'error') {
-            const detail = updated.errorMessage?.trim() || 'Unknown error';
-            return {
-                type: 'error',
-                message: `Worktree '${updated.name}' encountered an error: ${detail}`,
-            };
-        }
-        if (nextStatus === 'merged') {
-            return {
-                type: 'merged',
-                message: `Worktree '${updated.name}' merged`,
-            };
-        }
-        return null;
-    }
-    recordWorktreeActivity(params) {
-        void this.eventLogService
-            .recordPublished({
-            name: WORKTREE_ACTIVITY_EVENT_NAME,
-            payload: {
-                worktreeId: params.worktreeId,
-                worktreeName: params.worktreeName,
-                ownerProjectId: params.ownerProjectId,
-                type: params.type,
-                message: params.message,
-            },
-        })
-            .catch((error) => {
-            logger.warn({ error, worktreeId: params.worktreeId, type: params.type }, 'Failed to record worktree activity event');
-        });
-    }
-    assertValidStatusTransition(current, next) {
-        if (current === next) {
-            return;
-        }
-        const allowed = {
-            creating: ['running', 'error'],
-            running: ['stopped', 'completed', 'merged', 'error'],
-            stopped: ['running', 'merged', 'error'],
-            completed: ['merged', 'running', 'error'],
-            merged: [],
-            error: ['running', 'stopped'],
-        };
-        if (!allowed[current]?.includes(next)) {
-            throw new common_1.BadRequestException(`Invalid worktree status transition: ${current} -> ${next}`);
-        }
-    }
-};
-exports.WorktreesService = WorktreesService;
-exports.WorktreesService = WorktreesService = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(worktrees_store_1.WORKTREES_STORE)),
-    __param(7, (0, common_1.Optional)()),
-    __param(7, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
-    __metadata("design:paramtypes", [Object, container_runtime_1.ContainerRuntime,
-        process_runtime_1.ProcessRuntime,
-        git_worktree_service_1.GitWorktreeService,
-        seed_preparation_service_1.SeedPreparationService,
-        event_emitter_1.EventEmitter2,
-        event_log_service_1.EventLogService, Object])
-], WorktreesService);
-//# sourceMappingURL=worktrees.service.js.map