devchain-cli 0.10.5 → 0.11.1

package/dist/server/modules/projects/services/projects.service.js

@@ -19,14 +19,15 @@ const sessions_service_1 = require("../../sessions/services/sessions.service");
 const settings_service_1 = require("../../settings/services/settings.service");
 const watchers_service_1 = require("../../watchers/services/watchers.service");
 const watcher_runner_service_1 = require("../../watchers/services/watcher-runner.service");
-const logger_1 = require("../../../common/logging/logger");
-const error_types_1 = require("../../../common/errors/error-types");
-const path_1 = require("path");
-const fs_1 = require("fs");
-const shared_1 = require("@devchain/shared");
 const unified_template_service_1 = require("../../registry/services/unified-template.service");
-const templates_directory_1 = require("../../../common/templates-directory");
-const logger = (0, logger_1.createLogger)('ProjectsService');
+const project_import_1 = require("../helpers/project-import");
+const project_export_1 = require("../helpers/project-export");
+const template_loader_1 = require("../helpers/template-loader");
+const profile_mapping_helpers_1 = require("../helpers/profile-mapping.helpers");
+const project_presets_helpers_1 = require("../helpers/project-presets.helpers");
+const project_runtime_helpers_1 = require("../helpers/project-runtime.helpers");
+const project_template_manifest_helpers_1 = require("../helpers/project-template-manifest.helpers");
+const template_file_helpers_1 = require("../helpers/template-file.helpers");
 let ProjectsService = class ProjectsService {
     constructor(storage, sessions, settings, watchersService, watcherRunner, unifiedTemplateService) {
         this.storage = storage;
@@ -36,1870 +37,67 @@ let ProjectsService = class ProjectsService {
         this.watcherRunner = watcherRunner;
         this.unifiedTemplateService = unifiedTemplateService;
     }
-    findTemplatesDirectory() {
-        const templatesDir = (0, templates_directory_1.resolveTemplatesDirectory)(__dirname);
-        if (templatesDir) {
-            logger.debug({ path: templatesDir }, 'Found templates directory');
-            return templatesDir;
-        }
-        logger.warn('Templates directory not found in known locations');
-        return null;
-    }
     async listTemplates() {
-        logger.info('listTemplates');
-        const templatesDir = this.findTemplatesDirectory();
-        if (!templatesDir) {
-            logger.error('Templates directory not found');
-            throw new error_types_1.StorageError('Templates directory not found', {
-                hint: 'Templates directory is not available in this deployment',
-            });
-        }
-        try {
-            const files = (0, fs_1.readdirSync)(templatesDir);
-            const jsonFiles = files.filter((file) => file.endsWith('.json'));
-            const templates = jsonFiles.map((fileName) => {
-                const id = fileName.replace(/\.json$/, '');
-                return { id, fileName };
-            });
-            logger.info({ templatesDir, count: templates.length }, 'Listed project templates');
-            return templates;
-        }
-        catch (error) {
-            logger.error({ error, templatesDir }, 'Failed to read templates directory');
-            throw new error_types_1.StorageError('Failed to read templates directory', {
-                hint: 'Error accessing templates',
-            });
-        }
+        return (0, template_file_helpers_1.listTemplatesWithHelper)(__dirname);
     }
     async getTemplateContent(templateId) {
-        logger.info({ templateId }, 'getTemplateContent');
-        const templatesDir = this.findTemplatesDirectory();
-        if (!templatesDir) {
-            throw new error_types_1.StorageError('Templates directory not found', {
-                hint: 'Templates directory is not available in this deployment',
-            });
-        }
-        const TEMPLATE_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
-        if (!TEMPLATE_ID_REGEX.test(templateId)) {
-            throw new error_types_1.ValidationError('Invalid template ID: must contain only alphanumeric characters, hyphens, and underscores', { templateId });
-        }
-        const resolvedTemplatesDir = (0, path_1.resolve)(templatesDir);
-        const templatePath = (0, path_1.resolve)(templatesDir, `${templateId}.json`);
-        if (!templatePath.startsWith(resolvedTemplatesDir + path_1.sep)) {
-            logger.warn({ templateId, templatePath, templatesDir: resolvedTemplatesDir }, 'Path traversal attempt detected');
-            throw new error_types_1.ValidationError('Invalid template ID: path traversal not allowed', { templateId });
-        }
-        if (!(0, fs_1.existsSync)(templatePath)) {
-            throw new error_types_1.NotFoundError('Template', templateId);
-        }
-        try {
-            const content = (0, fs_1.readFileSync)(templatePath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            logger.error({ error, templatePath }, 'Failed to read template file');
-            throw new error_types_1.StorageError('Failed to read template file', {
-                hint: 'Template file exists but cannot be read or parsed',
-            });
-        }
+        return (0, template_file_helpers_1.getTemplateContentWithHelper)(__dirname, templateId);
     }
     async createFromTemplate(input) {
-        logger.info({ input }, 'createFromTemplate');
-        let templateResult;
-        let templateSlug;
-        if (input.templatePath) {
-            templateResult = this.unifiedTemplateService.getTemplateFromFilePath(input.templatePath);
-            const manifest = templateResult.content._manifest;
-            templateSlug = manifest?.slug ?? this.deriveSlugFromPath(input.templatePath);
-        }
-        else if (input.slug) {
-            templateResult = await this.unifiedTemplateService.getTemplate(input.slug, input.version ?? undefined);
-            templateSlug = input.slug;
-        }
-        else {
-            throw new error_types_1.ValidationError('Either slug or templatePath is required', {});
-        }
-        let payload;
-        try {
-            payload = shared_1.ExportSchema.parse(templateResult.content);
-        }
-        catch (error) {
-            logger.error({ error, slug: templateSlug, version: input.version }, 'Invalid template format');
-            throw new error_types_1.ValidationError('Invalid template format', {
-                hint: 'Template file does not match expected export schema',
-            });
-        }
-        const presetCoveredAgentNames = new Set();
-        const presetAgentResolvedProviders = new Map();
-        let presetCoversAllAgents = false;
-        if (input.presetName) {
-            const selectedPreset = (payload.presets ?? []).find((p) => p.name === input.presetName);
-            if (selectedPreset) {
-                const profileConfigsByProfileId = new Map();
-                for (const prof of payload.profiles ?? []) {
-                    if (!prof.id)
-                        continue;
-                    const providerConfigs = prof.providerConfigs;
-                    if (providerConfigs) {
-                        const configMap = new Map();
-                        for (const pc of providerConfigs) {
-                            configMap.set(pc.name.trim().toLowerCase(), pc.providerName.trim().toLowerCase());
-                        }
-                        profileConfigsByProfileId.set(prof.id, configMap);
-                    }
-                }
-                const agentNameToProfileId = new Map();
-                for (const agent of payload.agents ?? []) {
-                    if (agent.profileId) {
-                        agentNameToProfileId.set(agent.name.trim().toLowerCase(), agent.profileId);
-                    }
-                }
-                const localProviders = await this.storage.listProviders();
-                const localProviderNames = new Set(localProviders.items.map((p) => p.name.trim().toLowerCase()));
-                let allCovered = true;
-                for (const ac of selectedPreset.agentConfigs) {
-                    const agentKey = ac.agentName.trim().toLowerCase();
-                    const profileId = agentNameToProfileId.get(agentKey);
-                    if (!profileId) {
-                        allCovered = false;
-                        continue;
-                    }
-                    const configMap = profileConfigsByProfileId.get(profileId);
-                    const providerName = configMap?.get(ac.providerConfigName.trim().toLowerCase());
-                    if (providerName) {
-                        presetAgentResolvedProviders.set(agentKey, providerName);
-                    }
-                    if (providerName && localProviderNames.has(providerName)) {
-                        presetCoveredAgentNames.add(ac.agentName.trim().toLowerCase());
-                    }
-                    else {
-                        allCovered = false;
-                    }
-                }
-                const allTemplateAgentNames = new Set((payload.agents ?? []).map((a) => a.name.trim().toLowerCase()));
-                presetCoversAllAgents =
-                    allCovered && [...allTemplateAgentNames].every((n) => presetCoveredAgentNames.has(n));
-                if (presetCoversAllAgents) {
-                    logger.info({ presetName: input.presetName, coveredAgents: [...presetCoveredAgentNames] }, 'Preset covers all agents with available providers — skipping family mapping');
-                }
-                else if (presetCoveredAgentNames.size > 0) {
-                    logger.info({ presetName: input.presetName, coveredAgents: [...presetCoveredAgentNames] }, 'Preset partially covers agents — suppressing warnings for covered agents only');
-                }
-            }
-        }
-        const familyResult = await this.computeFamilyAlternatives(payload.profiles, payload.agents);
-        let effectiveFamilyProviderMappings = input.familyProviderMappings;
-        if (!presetCoversAllAgents) {
-            const needsMapping = familyResult.alternatives.some((alt) => !alt.defaultProviderAvailable);
-            if (needsMapping && !effectiveFamilyProviderMappings) {
-                const autoMappings = {};
-                let canAutoSelect = familyResult.canImport;
-                for (const alt of familyResult.alternatives) {
-                    if (!alt.defaultProviderAvailable) {
-                        if (alt.availableProviders.length === 1) {
-                            autoMappings[alt.familySlug] = alt.availableProviders[0];
-                        }
-                        else {
-                            canAutoSelect = false;
-                        }
-                    }
-                }
-                if (canAutoSelect) {
-                    effectiveFamilyProviderMappings = autoMappings;
-                    logger.info({ autoMappings }, 'Auto-selected provider mappings for single-alternative families');
-                }
-                else {
-                    return {
-                        success: false,
-                        providerMappingRequired: {
-                            missingProviders: familyResult.missingProviders,
-                            familyAlternatives: familyResult.alternatives,
-                            canImport: familyResult.canImport,
-                        },
-                    };
-                }
-            }
-            if (!familyResult.canImport) {
-                return {
-                    success: false,
-                    providerMappingRequired: {
-                        missingProviders: familyResult.missingProviders,
-                        familyAlternatives: familyResult.alternatives,
-                        canImport: false,
-                    },
-                };
-            }
-        }
-        const providerNames = new Set((payload.profiles ?? []).map((p) => p.provider.name.trim().toLowerCase()));
-        const { available } = await this.resolveProviders(providerNames);
-        if (available.size === 0 && (payload.profiles ?? []).length > 0) {
-            throw new error_types_1.ValidationError('No providers are installed. At least one provider is required to create a project from a template.');
-        }
-        const selectedProfilesByFamily = this.selectProfilesForFamilies(payload.profiles, payload.agents, effectiveFamilyProviderMappings, available, { presetCoveredAgentNames, presetAgentResolvedProviders });
-        const warnings = [];
-        for (const [, substitution] of selectedProfilesByFamily.providerSubstitutions) {
-            warnings.push({
-                type: 'provider_mismatch',
-                originalProvider: substitution.originalProvider,
-                substituteProvider: substitution.substituteProvider,
-                agentNames: substitution.agentNames,
-            });
-        }
-        const templatePayload = {
-            prompts: payload.prompts.map((p) => ({
-                id: p.id,
-                title: p.title,
-                content: p.content,
-                version: p.version,
-                tags: p.tags,
-            })),
-            profiles: selectedProfilesByFamily.profilesToCreate.map((prof) => {
-                const providerId = available.get(prof.provider.name.trim().toLowerCase());
-                if (!providerId) {
-                    throw new error_types_1.NotFoundError('Provider', prof.provider.name);
-                }
-                return {
-                    id: prof.id,
-                    name: prof.name,
-                    providerId,
-                    familySlug: prof.familySlug ?? null,
-                    options: this.normalizeProfileOptions(prof.options),
-                    instructions: prof.instructions ?? null,
-                    temperature: prof.temperature ?? null,
-                    maxTokens: prof.maxTokens ?? null,
-                };
-            }),
-            agents: payload.agents.map((a) => {
-                const remappedProfileId = selectedProfilesByFamily.agentProfileMap.get(a.id ?? '') ?? a.profileId;
-                return {
-                    id: a.id,
-                    name: a.name,
-                    profileId: remappedProfileId,
-                    description: a.description,
-                };
-            }),
-            statuses: payload.statuses.map((s) => ({
-                id: s.id,
-                label: s.label,
-                color: s.color,
-                position: s.position,
-                mcpHidden: s.mcpHidden,
-            })),
-            initialPrompt: payload.initialPrompt,
-        };
-        const result = input.projectId
-            ? await this.storage.createProjectWithTemplate({
-                name: input.name,
-                description: input.description ?? null,
-                rootPath: input.rootPath,
-                isTemplate: false,
-            }, templatePayload, {
-                projectId: input.projectId,
-            })
-            : await this.storage.createProjectWithTemplate({
-                name: input.name,
-                description: input.description ?? null,
-                rootPath: input.rootPath,
-                isTemplate: false,
-            }, templatePayload);
-        const { agentNameToId: agentNameToNewId, profileNameToId: profileNameToNewId } = this.buildNameToIdMaps(templatePayload, result.mappings);
-        const configLookupMap = new Map();
-        for (const prof of selectedProfilesByFamily.profilesToCreate) {
-            if (!prof.id)
-                continue;
-            const newProfileId = result.mappings.profileIdMap[prof.id];
-            if (!newProfileId)
-                continue;
-            const providerConfigs = prof.providerConfigs;
-            if (providerConfigs && providerConfigs.length > 0) {
-                for (const config of providerConfigs) {
-                    const configProviderId = available.get(config.providerName.trim().toLowerCase());
-                    if (!configProviderId) {
-                        logger.warn({ profileName: prof.name, providerName: config.providerName }, 'Provider not found for config in createFromTemplate, skipping');
-                        continue;
-                    }
-                    const createdConfig = await this.storage.createProfileProviderConfig({
-                        profileId: newProfileId,
-                        providerId: configProviderId,
-                        name: config.name,
-                        options: config.options ?? null,
-                        env: config.env ?? null,
-                    });
-                    const lookupKey = `${newProfileId}:${config.name.trim().toLowerCase()}`;
-                    configLookupMap.set(lookupKey, createdConfig.id);
-                }
-            }
-        }
-        const profilesWithProviderConfigs = new Map();
-        for (const prof of selectedProfilesByFamily.profilesToCreate) {
-            if (!prof.id)
-                continue;
-            const newProfileId = result.mappings.profileIdMap[prof.id];
-            if (!newProfileId)
-                continue;
-            const providerConfigs = prof.providerConfigs;
-            if (providerConfigs && providerConfigs.length > 0) {
-                profilesWithProviderConfigs.set(newProfileId, {
-                    profileName: prof.name,
-                    configNames: new Set(providerConfigs.map((pc) => pc.name.trim().toLowerCase())),
-                });
-            }
-        }
-        for (const a of payload.agents) {
-            const agentWithConfig = a;
-            if (!agentWithConfig.providerConfigName || !a.id)
-                continue;
-            const newAgentId = result.mappings.agentIdMap[a.id];
-            if (!newAgentId)
-                continue;
-            const remappedProfileId = selectedProfilesByFamily.agentProfileMap.get(a.id) ?? a.profileId;
-            const newProfileId = remappedProfileId
-                ? result.mappings.profileIdMap[remappedProfileId]
-                : null;
-            if (!newProfileId)
-                continue;
-            const lookupKey = `${newProfileId}:${agentWithConfig.providerConfigName.trim().toLowerCase()}`;
-            const providerConfigId = configLookupMap.get(lookupKey);
-            if (providerConfigId) {
-                await this.storage.updateAgent(newAgentId, { providerConfigId });
-                logger.debug({ agentName: a.name, providerConfigId }, 'Updated agent with providerConfigId');
-            }
-            else {
-                const fallbackKey = Array.from(configLookupMap.keys()).find((key) => key.startsWith(`${newProfileId}:`));
-                if (fallbackKey) {
-                    const fallbackConfigId = configLookupMap.get(fallbackKey);
-                    await this.storage.updateAgent(newAgentId, { providerConfigId: fallbackConfigId });
-                    logger.warn({
-                        agentName: a.name,
-                        providerConfigName: agentWithConfig.providerConfigName,
-                        fallbackConfigId,
-                    }, 'Agent providerConfigName unavailable, fell back to first available config');
-                }
-                else {
-                    logger.warn({ agentName: a.name, providerConfigName: agentWithConfig.providerConfigName }, 'No provider config available for agent in createFromTemplate');
-                }
-            }
-        }
-        for (const [newProfileId, { profileName, configNames }] of profilesWithProviderConfigs) {
-            const existingConfigs = await this.storage.listProfileProviderConfigsByProfile(newProfileId);
-            for (const existingConfig of existingConfigs) {
-                const isFromProviderConfigs = configNames.has(existingConfig.name.trim().toLowerCase());
-                if (!isFromProviderConfigs && existingConfig.name === profileName) {
-                    try {
-                        await this.storage.deleteProfileProviderConfig(existingConfig.id);
-                        logger.debug({ profileName, configId: existingConfig.id }, 'Deleted duplicate config created by storage layer');
-                    }
-                    catch {
-                        logger.debug({ profileName, configId: existingConfig.id }, 'Skipped deleting default config — still referenced by agents');
-                    }
-                }
-            }
-        }
-        let mergedInitialPromptTitle;
-        if (payload.initialPrompt?.title) {
-            mergedInitialPromptTitle = payload.initialPrompt.title;
-        }
-        else if (payload.initialPrompt?.promptId) {
-            const matchingPrompt = payload.prompts.find((p) => p.id === payload.initialPrompt.promptId);
-            if (matchingPrompt) {
-                mergedInitialPromptTitle = matchingPrompt.title;
-            }
-        }
-        else if (payload.projectSettings?.initialPromptTitle) {
-            mergedInitialPromptTitle = payload.projectSettings.initialPromptTitle;
-        }
-        const mergedSettings = payload.projectSettings
-            ? { ...payload.projectSettings, initialPromptTitle: mergedInitialPromptTitle }
-            : mergedInitialPromptTitle
-                ? { initialPromptTitle: mergedInitialPromptTitle }
-                : undefined;
-        const promptTitleToId = new Map();
-        for (const p of payload.prompts) {
-            if (p.id && result.mappings.promptIdMap[p.id]) {
-                promptTitleToId.set(p.title.toLowerCase(), result.mappings.promptIdMap[p.id]);
-            }
-        }
-        const statusLabelToId = new Map();
-        for (const s of templatePayload.statuses) {
-            if (s.id && result.mappings.statusIdMap[s.id]) {
-                statusLabelToId.set(s.label.toLowerCase(), result.mappings.statusIdMap[s.id]);
-            }
-        }
-        const archiveTemplateStatus = templatePayload.statuses.find((s) => s.label.toLowerCase() === 'archive');
-        const archiveStatusId = archiveTemplateStatus?.id
-            ? (result.mappings.statusIdMap[archiveTemplateStatus.id] ?? null)
-            : null;
-        const settingsResult = await this.applyProjectSettings(result.project.id, mergedSettings, { promptTitleToId, statusLabelToId }, archiveStatusId);
-        const initialPromptSet = settingsResult.initialPromptSet;
-        const { created: watchersCreated } = await this.createWatchersFromPayload(result.project.id, payload.watchers, {
-            agentNameToId: agentNameToNewId,
-            profileNameToId: profileNameToNewId,
-            providerNameToId: available,
-            profileNameRemapMap: selectedProfilesByFamily.profileNameRemapMap,
-        });
-        const { created: subscribersCreated } = await this.createSubscribersFromPayload(result.project.id, payload.subscribers);
-        const manifestVersion = payload._manifest?.version ?? null;
-        const installedVersion = templateResult.version ?? manifestVersion;
-        const registryConfig = this.settings.getRegistryConfig();
-        await this.settings.setProjectTemplateMetadata(result.project.id, {
-            templateSlug,
-            source: templateResult.source,
-            installedVersion,
-            registryUrl: templateResult.source === 'registry' ? registryConfig.url : null,
-            installedAt: new Date().toISOString(),
+        return (0, template_loader_1.createFromTemplateWithHelper)(input, {
+            storage: this.storage,
+            settings: this.settings,
+            unifiedTemplateService: this.unifiedTemplateService,
+            deriveSlugFromPath: template_file_helpers_1.deriveSlugFromPath,
+            computeFamilyAlternatives: (profiles, agents) => this.computeFamilyAlternatives(profiles, agents),
+            normalizeProfileOptions: project_runtime_helpers_1.normalizeProfileOptions,
+            applyProjectSettings: (projectId, projectSettings, maps, archiveStatusId) => (0, project_runtime_helpers_1.applyProjectSettingsWithHelper)(projectId, projectSettings, maps, archiveStatusId, this.settings),
+            createWatchersFromPayload: (projectId, watchers, maps) => (0, project_runtime_helpers_1.createWatchersFromPayloadWithHelper)(projectId, watchers, maps, this.watchersService),
+            createSubscribersFromPayload: (projectId, subscribers) => (0, project_runtime_helpers_1.createSubscribersFromPayloadWithHelper)(projectId, subscribers, this.storage),
+            applyPreset: (projectId, presetName, nameMaps) => (0, project_presets_helpers_1.applyPresetWithHelper)(projectId, presetName, { storage: this.storage, settings: this.settings }, nameMaps),
         });
-        logger.info({
-            projectId: result.project.id,
-            slug: templateSlug,
-            source: templateResult.source,
-            version: installedVersion,
-        }, 'Template metadata set for project');
-        const rawPresets = payload.presets;
-        const templatePresets = Array.isArray(rawPresets) ? rawPresets : [];
-        if (templatePresets.length > 0) {
-            await this.settings.setProjectPresets(result.project.id, templatePresets);
-            logger.info({ projectId: result.project.id, presetCount: templatePresets.length }, 'Presets stored for project');
-        }
-        if (input.presetName) {
-            const selectedPreset = templatePresets.find((p) => typeof p === 'object' && p !== null && 'name' in p && p.name === input.presetName);
-            if (!selectedPreset) {
-                logger.warn({ projectId: result.project.id, presetName: input.presetName }, 'Selected preset not found in template');
-            }
-            else {
-                await this.applyPreset(result.project.id, input.presetName, {
-                    agentNameToId: agentNameToNewId,
-                    configLookupMap,
-                });
-                logger.info({ projectId: result.project.id, presetName: input.presetName }, 'Applied preset to project');
-            }
-        }
-        return {
-            success: true,
-            project: result.project,
-            imported: {
-                ...result.imported,
-                watchers: watchersCreated,
-                subscribers: subscribersCreated,
-            },
-            mappings: result.mappings,
-            initialPromptSet,
-            message: 'Project created from template successfully.',
-            ...(warnings.length > 0 ? { warnings } : {}),
-        };
     }
     async exportProject(projectId, opts) {
-        logger.info({ projectId }, 'exportProject');
-        const { manifestOverrides, presets: presetsOverride } = opts ?? {};
-        const [project, promptsRes, profilesRes, agentsRes, statusesRes, initialPrompt, settings, watchersRes, subscribersRes,] = await Promise.all([
-            this.storage.getProject(projectId),
-            this.storage.listPrompts({ projectId, limit: 1000, offset: 0 }),
-            this.storage.listAgentProfiles({ projectId, limit: 1000, offset: 0 }),
-            this.storage.listAgents(projectId, { limit: 1000, offset: 0 }),
-            this.storage.listStatuses(projectId, { limit: 1000, offset: 0 }),
-            this.storage.getInitialSessionPrompt(projectId),
-            Promise.resolve(this.settings.getSettings()),
-            this.storage.listWatchers(projectId),
-            this.storage.listSubscribers(projectId),
-        ]);
-        const secretKeys = new Set([
-            'apikey',
-            'api_key',
-            'api-key',
-            'api_key_id',
-            'api-secret',
-            'api_secret',
-            'token',
-            'access_token',
-            'access-token',
-            'refresh_token',
-            'refresh-token',
-            'secret',
-            'client_secret',
-            'clientsecret',
-            'password',
-            'openaiapikey',
-            'anthropicapikey',
-            'azureapikey',
-            'googleapikey',
-            'geminiapikey',
-        ]);
-        const _sanitize = (value) => {
-            if (Array.isArray(value)) {
-                return value.map((v) => _sanitize(v));
-            }
-            if (value && typeof value === 'object') {
-                const out = {};
-                for (const [k, v] of Object.entries(value)) {
-                    const keyLc = k.toLowerCase();
-                    if (secretKeys.has(keyLc)) {
-                        out[k] = '***';
-                    }
-                    else {
-                        out[k] = _sanitize(v);
-                    }
-                }
-                return out;
-            }
-            return value;
-        };
-        const fullPrompts = await Promise.all(promptsRes.items.map((p) => this.storage.getPrompt(p.id)));
-        const prompts = fullPrompts.map((p) => ({
-            id: p.id,
-            title: p.title,
-            content: p.content,
-            version: p.version,
-            tags: p.tags,
-        }));
-        const configIdToInfo = new Map();
-        const profileIds = profilesRes.items.map((p) => p.id);
-        const allConfigsByProfile = new Map();
-        await Promise.all(profileIds.map(async (profileId) => {
-            const configs = await this.storage.listProfileProviderConfigsByProfile(profileId);
-            allConfigsByProfile.set(profileId, configs);
-        }));
-        const allProviderIds = new Set();
-        for (const configs of allConfigsByProfile.values()) {
-            for (const config of configs) {
-                allProviderIds.add(config.providerId);
-            }
-        }
-        const providersArray = await this.storage.listProvidersByIds([...allProviderIds]);
-        const providersMap = new Map(providersArray.map((p) => [p.id, p]));
-        const profiles = profilesRes.items.map((prof) => {
-            const configs = allConfigsByProfile.get(prof.id) || [];
-            let primaryProvider = null;
-            const providerConfigs = configs.map((config) => {
-                const configProvider = providersMap.get(config.providerId);
-                if (!primaryProvider && configProvider) {
-                    primaryProvider = { id: configProvider.id, name: configProvider.name };
-                }
-                const configName = config.name;
-                configIdToInfo.set(config.id, { name: configName, profileId: prof.id });
-                return {
-                    name: configName,
-                    providerName: configProvider?.name || 'unknown',
-                    options: config.options,
-                    env: config.env,
-                    position: config.position,
-                };
-            });
-            return {
-                id: prof.id,
-                name: prof.name,
-                provider: primaryProvider,
-                familySlug: prof.familySlug,
-                instructions: prof.instructions,
-                temperature: prof.temperature,
-                maxTokens: prof.maxTokens,
-                ...(providerConfigs.length > 0 && { providerConfigs }),
-            };
+        return (0, project_export_1.exportProjectWithHelper)(projectId, opts, {
+            storage: this.storage,
+            settings: this.settings,
+            slugify: template_file_helpers_1.slugify,
         });
-        const agents = agentsRes.items.map((a) => {
-            let providerConfigName = null;
-            if (a.providerConfigId) {
-                const configInfo = configIdToInfo.get(a.providerConfigId);
-                if (configInfo) {
-                    providerConfigName = configInfo.name;
-                }
-            }
-            return {
-                id: a.id,
-                name: a.name,
-                profileId: a.profileId,
-                description: a.description,
-                ...(providerConfigName && { providerConfigName }),
-            };
-        });
-        const statuses = statusesRes.items.map((s) => ({
-            id: s.id,
-            label: s.label,
-            color: s.color,
-            position: s.position,
-            mcpHidden: s.mcpHidden,
-        }));
-        const projectSettings = {};
-        if (initialPrompt?.title) {
-            projectSettings.initialPromptTitle = initialPrompt.title;
-        }
-        const autoCleanStatusIds = settings.autoClean?.statusIds?.[projectId] ?? [];
-        if (autoCleanStatusIds.length > 0) {
-            const statusMap = new Map(statusesRes.items.map((s) => [s.id, s.label]));
-            const autoCleanLabels = autoCleanStatusIds
-                .map((id) => statusMap.get(id))
-                .filter((label) => !!label);
-            if (autoCleanLabels.length > 0) {
-                projectSettings.autoCleanStatusLabels = autoCleanLabels;
-            }
-        }
-        const epicAssignedTemplate = settings.events?.epicAssigned?.template;
-        if (epicAssignedTemplate) {
-            projectSettings.epicAssignedTemplate = epicAssignedTemplate;
-        }
-        const poolSettings = settings.messagePool?.projects?.[projectId];
-        if (poolSettings && Object.keys(poolSettings).length > 0) {
-            projectSettings.messagePoolSettings = poolSettings;
-        }
-        const watchers = await Promise.all(watchersRes.map(async (w) => {
-            let scopeFilterName = null;
-            if (w.scopeFilterId) {
-                switch (w.scope) {
-                    case 'agent': {
-                        const agent = agentsRes.items.find((a) => a.id === w.scopeFilterId);
-                        scopeFilterName = agent?.name ?? null;
-                        break;
-                    }
-                    case 'profile': {
-                        const profile = profilesRes.items.find((p) => p.id === w.scopeFilterId);
-                        scopeFilterName = profile?.name ?? null;
-                        break;
-                    }
-                    case 'provider': {
-                        try {
-                            const provider = await this.storage.getProvider(w.scopeFilterId);
-                            scopeFilterName = provider?.name ?? null;
-                        }
-                        catch {
-                            scopeFilterName = null;
-                        }
-                        break;
-                    }
-                }
-            }
-            return {
-                id: w.id,
-                name: w.name,
-                description: w.description,
-                enabled: w.enabled,
-                scope: w.scope,
-                scopeFilterName,
-                pollIntervalMs: w.pollIntervalMs,
-                viewportLines: w.viewportLines,
-                idleAfterSeconds: w.idleAfterSeconds,
-                condition: w.condition,
-                cooldownMs: w.cooldownMs,
-                cooldownMode: w.cooldownMode,
-                eventName: w.eventName,
-            };
-        }));
-        const subscribers = subscribersRes.map((s) => ({
-            id: s.id,
-            name: s.name,
-            description: s.description,
-            enabled: s.enabled,
-            eventName: s.eventName,
-            eventFilter: s.eventFilter,
-            actionType: s.actionType,
-            actionInputs: s.actionInputs,
-            delayMs: s.delayMs,
-            cooldownMs: s.cooldownMs,
-            retryOnError: s.retryOnError,
-            groupName: s.groupName,
-            position: s.position,
-            priority: s.priority,
-        }));
-        const providerSettings = [];
-        for (const prov of providersMap.values()) {
-            if (prov.autoCompactThreshold != null) {
-                providerSettings.push({
-                    name: prov.name,
-                    autoCompactThreshold: prov.autoCompactThreshold,
-                });
-            }
-        }
-        const existingMetadata = this.settings.getProjectTemplateMetadata(projectId);
-        const manifest = {
-            slug: existingMetadata?.templateSlug || this.slugify(project.name),
-            name: project.name,
-            description: project.description || null,
-            version: existingMetadata?.installedVersion || '1.0.0',
-            ...manifestOverrides,
-            publishedAt: new Date().toISOString(),
-        };
-        const exportPayload = {
-            _manifest: manifest,
-            version: 1,
-            exportedAt: new Date().toISOString(),
-            prompts,
-            profiles,
-            agents,
-            statuses,
-            initialPrompt: initialPrompt
-                ? { promptId: initialPrompt.id, title: initialPrompt.title }
-                : null,
-            ...(Object.keys(projectSettings).length > 0 && { projectSettings }),
-            ...(providerSettings.length > 0 && { providerSettings }),
-            watchers,
-            subscribers,
-            ...(presetsOverride !== undefined
-                ? { presets: presetsOverride }
-                : this.settings.getProjectPresets(projectId).length > 0
-                    ? { presets: this.settings.getProjectPresets(projectId) }
-                    : {}),
-        };
-        return exportPayload;
     }
     async doesProjectMatchPreset(projectId, preset) {
-        const agentsRes = await this.storage.listAgents(projectId, { limit: 1000, offset: 0 });
-        const agentsByName = new Map(agentsRes.items.map((a) => [a.name.toLowerCase(), a]));
-        const uniqueProviderConfigIds = new Set();
-        for (const agent of agentsRes.items) {
-            if (agent.providerConfigId) {
-                uniqueProviderConfigIds.add(agent.providerConfigId);
-            }
-        }
-        const allProviderConfigs = uniqueProviderConfigIds.size > 0
-            ? await this.storage.listProfileProviderConfigsByIds(Array.from(uniqueProviderConfigIds))
-            : [];
-        const providerConfigNames = new Map(allProviderConfigs.map((c) => [c.id, c.name]));
-        for (const agentConfig of preset.agentConfigs) {
-            const agentNameLower = agentConfig.agentName.trim().toLowerCase();
-            const providerConfigNameLower = agentConfig.providerConfigName.trim().toLowerCase();
-            const agent = agentsByName.get(agentNameLower);
-            if (!agent) {
-                return false;
-            }
-            const currentProviderConfigName = providerConfigNames.get(agent.providerConfigId ?? '');
-            if (currentProviderConfigName?.toLowerCase() !== providerConfigNameLower) {
-                return false;
-            }
-        }
-        return true;
+        return (0, project_presets_helpers_1.doesProjectMatchPresetWithHelper)(projectId, preset, { storage: this.storage });
     }
     async applyPreset(projectId, presetName, nameMaps) {
-        logger.info({ projectId, presetName }, 'applyPreset');
-        const warnings = [];
-        const presets = this.settings.getProjectPresets(projectId);
-        const selectedPreset = presets.find((p) => p.name === presetName);
-        if (!selectedPreset) {
-            throw new error_types_1.NotFoundError('Preset', presetName);
-        }
-        if (!selectedPreset.agentConfigs || !Array.isArray(selectedPreset.agentConfigs)) {
-            throw new error_types_1.ValidationError(`Preset "${presetName}" has invalid or missing agentConfigs`, {
-                presetName,
-            });
-        }
-        const agentsRes = await this.storage.listAgents(projectId, { limit: 1000, offset: 0 });
-        let agentNameToId;
-        if (nameMaps?.agentNameToId) {
-            agentNameToId = nameMaps.agentNameToId;
-        }
-        else {
-            agentNameToId = new Map();
-            for (const agent of agentsRes.items) {
-                agentNameToId.set(agent.name.toLowerCase(), agent.id);
-            }
-        }
-        let configLookupMap;
-        if (nameMaps?.configLookupMap) {
-            configLookupMap = nameMaps.configLookupMap;
-        }
-        else {
-            configLookupMap = new Map();
-            const profilesRes = await this.storage.listAgentProfiles({
-                projectId,
-                limit: 1000,
-                offset: 0,
-            });
-            for (const profile of profilesRes.items) {
-                const configs = await this.storage.listProfileProviderConfigsByProfile(profile.id);
-                for (const config of configs) {
-                    const lookupKey = `${profile.id}:${config.name.trim().toLowerCase()}`;
-                    configLookupMap.set(lookupKey, config.id);
-                }
-            }
-        }
-        let applied = 0;
-        const agentsById = new Map(agentsRes.items.map((a) => [a.id, a]));
-        for (const agentConfig of selectedPreset.agentConfigs) {
-            const agentId = agentNameToId.get(agentConfig.agentName.trim().toLowerCase());
-            if (!agentId) {
-                warnings.push(`Agent "${agentConfig.agentName}" not found in project`);
-                continue;
-            }
-            const agent = agentsById.get(agentId);
-            if (!agent)
-                continue;
-            const profileId = agent.profileId;
-            const lookupKey = `${profileId}:${agentConfig.providerConfigName.trim().toLowerCase()}`;
-            const providerConfigId = configLookupMap.get(lookupKey);
-            if (!providerConfigId) {
-                warnings.push(`Provider config "${agentConfig.providerConfigName}" not found for agent "${agentConfig.agentName}"`);
-                continue;
-            }
-            await this.storage.updateAgent(agentId, { providerConfigId });
-            applied++;
-            logger.debug({ projectId, agentId, agentName: agentConfig.agentName, providerConfigId }, 'Applied preset: updated agent provider config');
-        }
-        const fullMatch = warnings.length === 0 && applied === selectedPreset.agentConfigs.length;
-        if (fullMatch) {
-            await this.settings.setProjectActivePreset(projectId, presetName);
-            logger.info({ projectId, presetName }, 'Active preset set (full match)');
-        }
-        logger.info({ projectId, presetName, applied, warnings: warnings.length }, 'Preset applied');
-        return { applied, warnings };
+        return (0, project_presets_helpers_1.applyPresetWithHelper)(projectId, presetName, { storage: this.storage, settings: this.settings }, nameMaps);
     }
     async importProject(input) {
-        logger.info({ projectId: input.projectId, dryRun: input.dryRun }, 'importProject');
-        const isDryRun = input.dryRun ?? false;
-        const payload = shared_1.ExportSchema.parse(input.payload ?? {});
-        const familyResult = await this.computeFamilyAlternatives(payload.profiles, payload.agents);
-        const needsMapping = familyResult.alternatives.some((alt) => !alt.defaultProviderAvailable);
-        const providerNames = new Set((payload.profiles ?? []).map((p) => p.provider.name.trim().toLowerCase()));
-        const { available, missing: missingProviders } = await this.resolveProviders(providerNames);
-        if (!isDryRun && available.size === 0 && (payload.profiles ?? []).length > 0) {
-            throw new error_types_1.ValidationError('No providers are installed. At least one provider is required to create a project from a template.');
-        }
-        const selectedProfilesByFamily = this.selectProfilesForFamilies(payload.profiles, payload.agents, input.familyProviderMappings, available);
-        const [existingPrompts, existingProfiles, existingAgents, existingStatuses, existingWatchers, existingSubscribers,] = await Promise.all([
-            this.storage.listPrompts({ projectId: input.projectId, limit: 10000, offset: 0 }),
-            this.storage.listAgentProfiles({ projectId: input.projectId, limit: 10000, offset: 0 }),
-            this.storage.listAgents(input.projectId, { limit: 10000, offset: 0 }),
-            this.storage.listStatuses(input.projectId, { limit: 10000, offset: 0 }),
-            this.storage.listWatchers(input.projectId),
-            this.storage.listSubscribers(input.projectId),
-        ]);
-        const templateStatusLabels = new Set(payload.statuses.map((s) => s.label.trim().toLowerCase()));
-        const unmatchedStatuses = [];
-        for (const s of existingStatuses.items) {
-            const labelKey = s.label.trim().toLowerCase();
-            if (!templateStatusLabels.has(labelKey)) {
-                const epicCount = await this.storage.countEpicsByStatus(s.id);
-                if (epicCount > 0) {
-                    unmatchedStatuses.push({
-                        id: s.id,
-                        label: s.label,
-                        color: s.color,
-                        epicCount,
-                    });
-                }
-            }
-        }
-        if (isDryRun) {
-            const dryRunResponse = {
-                dryRun: true,
-                missingProviders,
-                unmatchedStatuses,
-                templateStatuses: payload.statuses.map((s) => ({
-                    label: s.label,
-                    color: s.color,
-                })),
-                counts: {
-                    toImport: {
-                        prompts: payload.prompts.length,
-                        profiles: selectedProfilesByFamily.profilesToCreate.length,
-                        agents: payload.agents.length,
-                        statuses: payload.statuses.length,
-                        watchers: payload.watchers.length,
-                        subscribers: payload.subscribers.length,
-                    },
-                    toDelete: {
-                        prompts: existingPrompts.total,
-                        profiles: existingProfiles.total,
-                        agents: existingAgents.total,
-                        statuses: existingStatuses.total,
-                        watchers: existingWatchers.length,
-                        subscribers: existingSubscribers.length,
-                    },
-                },
-            };
-            if (needsMapping && !input.familyProviderMappings) {
-                dryRunResponse.providerMappingRequired = {
-                    missingProviders: familyResult.missingProviders,
-                    familyAlternatives: familyResult.alternatives,
-                    canImport: familyResult.canImport,
-                };
-            }
-            return dryRunResponse;
-        }
-        if (needsMapping && !input.familyProviderMappings) {
-            return {
-                success: false,
-                providerMappingRequired: {
-                    missingProviders: familyResult.missingProviders,
-                    familyAlternatives: familyResult.alternatives,
-                    canImport: familyResult.canImport,
-                },
-            };
-        }
-        if (!familyResult.canImport) {
-            throw new error_types_1.ValidationError('Cannot import: some profile families have no available providers', {
-                hint: 'Install the required providers or use a different template',
-                missingProviders: familyResult.missingProviders,
-                familyAlternatives: familyResult.alternatives,
-            });
-        }
-        const selectedProviderNames = new Set(selectedProfilesByFamily.profilesToCreate.map((p) => p.provider.name.trim().toLowerCase()));
-        const unavailableSelectedProviders = Array.from(selectedProviderNames).filter((name) => !available.has(name));
-        if (unavailableSelectedProviders.length > 0) {
-            throw new error_types_1.ValidationError('Import aborted: missing providers', {
-                missingProviders: unavailableSelectedProviders,
-                hint: 'Install/configure providers by name before importing profiles.',
-            });
-        }
-        const activeSessions = this.sessions.getActiveSessionsForProject(input.projectId);
-        if (activeSessions.length > 0) {
-            throw new error_types_1.ConflictError('Import aborted: active agent sessions detected', {
-                activeSessions: activeSessions.map((s) => ({ id: s.id, agentId: s.agentId })),
-                hint: 'Terminate all running sessions for this project before importing.',
-            });
-        }
-        try {
-            const oldAgentIdToName = new Map();
-            for (const a of existingAgents.items) {
-                oldAgentIdToName.set(a.id, a.name.trim().toLowerCase());
-            }
-            for (const a of existingAgents.items) {
-                await this.storage.deleteAgent(a.id);
-            }
-            for (const p of existingProfiles.items) {
-                await this.storage.deleteAgentProfile(p.id);
-            }
-            for (const pr of existingPrompts.items) {
-                await this.storage.deletePrompt(pr.id);
-            }
-            for (const w of existingWatchers) {
-                await this.watchersService.deleteWatcher(w.id);
-            }
-            for (const s of existingSubscribers) {
-                await this.storage.deleteSubscriber(s.id);
-            }
-            await this.settings.updateSettings({
-                projectId: input.projectId,
-                initialSessionPromptId: null,
-            });
-            const statusIdMap = {};
-            const promptIdMap = {};
-            const profileIdMap = {};
-            const agentIdMap = {};
-            const existingStatusByLabel = new Map();
-            for (const s of existingStatuses.items) {
-                existingStatusByLabel.set(s.label.trim().toLowerCase(), s);
-            }
-            const TEMP_POSITION_OFFSET = 100000;
-            for (const s of existingStatuses.items) {
-                await this.storage.updateStatus(s.id, { position: s.position + TEMP_POSITION_OFFSET });
-            }
-            for (const s of payload.statuses.sort((a, b) => a.position - b.position)) {
-                const labelKey = s.label.trim().toLowerCase();
-                const existing = existingStatusByLabel.get(labelKey);
-                if (existing) {
-                    const updated = await this.storage.updateStatus(existing.id, {
-                        color: s.color,
-                        position: s.position,
-                        mcpHidden: s.mcpHidden,
-                    });
-                    if (s.id)
-                        statusIdMap[s.id] = updated.id;
-                    existingStatusByLabel.delete(labelKey);
-                }
-                else {
-                    const created = await this.storage.createStatus({
-                        projectId: input.projectId,
-                        label: s.label,
-                        color: s.color,
-                        position: s.position,
-                        mcpHidden: s.mcpHidden,
-                    });
-                    if (s.id)
-                        statusIdMap[s.id] = created.id;
-                }
-            }
-            const templateLabelToStatusId = new Map();
-            const allStatuses = await this.storage.listStatuses(input.projectId, {
-                limit: 10000,
-                offset: 0,
-            });
-            for (const s of allStatuses.items) {
-                templateLabelToStatusId.set(s.label.trim().toLowerCase(), s.id);
-            }
-            if (input.statusMappings && Object.keys(input.statusMappings).length > 0) {
-                let epicsMapped = 0;
-                let statusesDeleted = 0;
-                for (const [oldStatusId, targetLabel] of Object.entries(input.statusMappings)) {
-                    const targetStatusId = templateLabelToStatusId.get(targetLabel.trim().toLowerCase());
-                    if (targetStatusId) {
-                        const remapped = await this.storage.updateEpicsStatus(oldStatusId, targetStatusId);
-                        epicsMapped += remapped;
-                        await this.storage.deleteStatus(oldStatusId);
-                        statusesDeleted++;
-                    }
-                }
-                logger.info({ epicsMapped, statusesDeleted }, 'Applied status mappings: epics remapped and old statuses deleted');
-            }
-            const createdPrompts = [];
-            for (const p of payload.prompts) {
-                const created = await this.storage.createPrompt({
-                    projectId: input.projectId,
-                    title: p.title,
-                    content: p.content,
-                    tags: p.tags ?? [],
-                });
-                if (p.id)
-                    promptIdMap[p.id] = created.id;
-                createdPrompts.push({ id: created.id, title: created.title });
-            }
-            for (const prof of selectedProfilesByFamily.profilesToCreate) {
-                const created = await this.storage.createAgentProfile({
-                    projectId: input.projectId,
-                    name: prof.name,
-                    familySlug: prof.familySlug ?? null,
-                    systemPrompt: null,
-                    instructions: prof.instructions ?? null,
-                    temperature: prof.temperature ?? null,
-                    maxTokens: prof.maxTokens ?? null,
-                });
-                const profKey = prof.id || `name:${prof.name.trim().toLowerCase()}`;
-                profileIdMap[profKey] = created.id;
-            }
-            const configLookupMap = new Map();
-            const configIdMap = {};
-            for (const prof of selectedProfilesByFamily.profilesToCreate) {
-                const profKey = prof.id || `name:${prof.name.trim().toLowerCase()}`;
-                const newProfileId = profileIdMap[profKey];
-                if (!newProfileId)
-                    continue;
-                const providerConfigs = prof.providerConfigs;
-                if (providerConfigs && providerConfigs.length > 0) {
-                    for (const config of providerConfigs) {
-                        const configProviderId = available.get(config.providerName.trim().toLowerCase());
-                        if (!configProviderId) {
-                            logger.warn({ profileName: prof.name, providerName: config.providerName }, 'Provider not found for config, skipping');
-                            continue;
-                        }
-                        const createdConfig = await this.storage.createProfileProviderConfig({
-                            profileId: newProfileId,
-                            providerId: configProviderId,
-                            name: config.name,
-                            options: config.options ?? null,
-                            env: config.env ?? null,
-                        });
-                        const lookupKey = `${newProfileId}:${config.name.trim().toLowerCase()}`;
-                        configLookupMap.set(lookupKey, createdConfig.id);
-                        configIdMap[`${profKey}:${config.name}`] = createdConfig.id;
-                    }
-                }
-                else {
-                    const providerName = prof.provider.name.trim().toLowerCase();
-                    const configProviderId = available.get(providerName);
-                    if (configProviderId) {
-                        const options = prof.options != null
-                            ? typeof prof.options === 'string'
-                                ? prof.options
-                                : JSON.stringify(prof.options)
-                            : null;
-                        const createdConfig = await this.storage.createProfileProviderConfig({
-                            profileId: newProfileId,
-                            providerId: configProviderId,
-                            name: 'default',
-                            options,
-                            env: null,
-                        });
-                        const lookupKey = `${newProfileId}:default`;
-                        configLookupMap.set(lookupKey, createdConfig.id);
-                        configIdMap[`${profKey}:default`] = createdConfig.id;
-                    }
-                }
-            }
-            for (const a of payload.agents) {
-                const remappedProfileId = selectedProfilesByFamily.agentProfileMap.get(a.id ?? '');
-                const oldProfileId = remappedProfileId ?? 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,
-                    });
-                }
-                let providerConfigId;
-                const agentWithConfig = a;
-                if (agentWithConfig.providerConfigName && newProfileId) {
-                    const lookupKey = `${newProfileId}:${agentWithConfig.providerConfigName.trim().toLowerCase()}`;
-                    providerConfigId = configLookupMap.get(lookupKey);
-                }
-                if (!providerConfigId && newProfileId) {
-                    const profilePrefix = `${newProfileId}:`;
-                    for (const [key, configId] of configLookupMap.entries()) {
-                        if (key.startsWith(profilePrefix)) {
-                            providerConfigId = configId;
-                            break;
-                        }
-                    }
-                }
-                if (!providerConfigId) {
-                    throw new error_types_1.ValidationError(`No provider config available for agent ${a.name}`, {
-                        profileId: newProfileId,
-                        providerConfigName: agentWithConfig.providerConfigName || null,
-                    });
-                }
-                const created = await this.storage.createAgent({
-                    projectId: input.projectId,
-                    name: a.name,
-                    profileId: newProfileId,
-                    description: a.description ?? null,
-                    providerConfigId,
-                });
-                const agentKey = a.id || `name:${a.name.trim().toLowerCase()}`;
-                agentIdMap[agentKey] = created.id;
-            }
-            const augmentedPayload = {
-                agents: payload.agents.map((a) => ({
-                    ...a,
-                    id: a.id || `name:${a.name.trim().toLowerCase()}`,
-                })),
-                profiles: selectedProfilesByFamily.profilesToCreate.map((p) => ({
-                    ...p,
-                    id: p.id || `name:${p.name.trim().toLowerCase()}`,
-                })),
-            };
-            const { agentNameToId: agentNameToNewId, profileNameToId: profileNameToNewId } = this.buildNameToIdMaps(augmentedPayload, { agentIdMap, profileIdMap });
-            const { watcherIdMap } = await this.createWatchersFromPayload(input.projectId, payload.watchers, {
-                agentNameToId: agentNameToNewId,
-                profileNameToId: profileNameToNewId,
-                providerNameToId: available,
-                profileNameRemapMap: selectedProfilesByFamily.profileNameRemapMap,
-            });
-            const { subscriberIdMap } = await this.createSubscribersFromPayload(input.projectId, payload.subscribers);
-            logger.info({
-                watchersCreated: payload.watchers.length,
-                subscribersCreated: payload.subscribers.length,
-            }, 'Watchers and subscribers imported');
-            const existingEpics = await this.storage.listEpics(input.projectId, {
-                limit: 100000,
-                offset: 0,
-            });
-            let epicsRemapped = 0;
-            let epicsCleared = 0;
-            for (const epic of existingEpics.items) {
-                if (epic.agentId) {
-                    const oldAgentName = oldAgentIdToName.get(epic.agentId);
-                    if (oldAgentName) {
-                        const newAgentId = agentNameToNewId.get(oldAgentName);
-                        if (newAgentId) {
-                            await this.storage.updateEpic(epic.id, { agentId: newAgentId }, epic.version);
-                            epicsRemapped++;
-                        }
-                        else {
-                            await this.storage.updateEpic(epic.id, { agentId: null }, epic.version);
-                            epicsCleared++;
-                        }
-                    }
-                    else {
-                        await this.storage.updateEpic(epic.id, { agentId: null }, epic.version);
-                        epicsCleared++;
-                    }
-                }
-            }
-            logger.info({ epicsRemapped, epicsCleared }, 'Epic agent references updated after import');
-            let mergedInitialPromptTitle;
-            if (payload.initialPrompt?.title) {
-                mergedInitialPromptTitle = payload.initialPrompt.title;
-            }
-            else if (payload.initialPrompt?.promptId) {
-                const matchingPrompt = payload.prompts.find((p) => p.id === payload.initialPrompt.promptId);
-                if (matchingPrompt) {
-                    mergedInitialPromptTitle = matchingPrompt.title;
-                }
-            }
-            else if (payload.projectSettings?.initialPromptTitle) {
-                mergedInitialPromptTitle = payload.projectSettings.initialPromptTitle;
-            }
-            const mergedSettings = payload.projectSettings
-                ? { ...payload.projectSettings, initialPromptTitle: mergedInitialPromptTitle }
-                : mergedInitialPromptTitle
-                    ? { initialPromptTitle: mergedInitialPromptTitle }
-                    : undefined;
-            const promptTitleToId = new Map();
-            for (const cp of createdPrompts) {
-                promptTitleToId.set(cp.title.toLowerCase(), cp.id);
-            }
-            const archiveStatusId = templateLabelToStatusId.get('archive') ?? null;
-            const settingsResult = await this.applyProjectSettings(input.projectId, mergedSettings, { promptTitleToId, statusLabelToId: templateLabelToStatusId }, archiveStatusId);
-            const initialPromptSet = settingsResult.initialPromptSet;
-            if (payload._manifest?.slug) {
-                let templateSource = 'registry';
-                try {
-                    this.unifiedTemplateService.getBundledTemplate(payload._manifest.slug);
-                    templateSource = 'bundled';
-                }
-                catch {
-                    templateSource = 'registry';
-                }
-                await this.settings.setProjectTemplateMetadata(input.projectId, {
-                    templateSlug: payload._manifest.slug,
-                    source: templateSource,
-                    installedVersion: payload._manifest.version ?? null,
-                    registryUrl: null,
-                    installedAt: new Date().toISOString(),
-                });
-                logger.info({ projectId: input.projectId, slug: payload._manifest.slug, source: templateSource }, 'Updated template metadata after import');
-            }
-            const rawPresets = payload.presets;
-            const templatePresets = Array.isArray(rawPresets) ? rawPresets : [];
-            if (templatePresets.length > 0) {
-                await this.settings.setProjectPresets(input.projectId, templatePresets);
-                logger.info({ projectId: input.projectId, presetCount: templatePresets.length }, 'Presets replaced from template during import');
-            }
-            else {
-                await this.settings.clearProjectPresets(input.projectId);
-                logger.info({ projectId: input.projectId }, 'Presets cleared during import (template has none)');
-            }
-            const importedProviderSettings = payload.providerSettings;
-            if (importedProviderSettings && importedProviderSettings.length > 0) {
-                const allProviders = await this.storage.listProviders();
-                const providersByName = new Map(allProviders.items.map((p) => [p.name.trim().toLowerCase(), p]));
-                for (const setting of importedProviderSettings) {
-                    const localProvider = providersByName.get(setting.name.trim().toLowerCase());
-                    if (!localProvider) {
-                        continue;
-                    }
-                    if (localProvider.autoCompactThreshold != null) {
-                        logger.debug({ providerName: setting.name, existing: localProvider.autoCompactThreshold }, 'Skipping providerSettings import: local threshold already set');
-                        continue;
-                    }
-                    if (setting.autoCompactThreshold != null) {
-                        await this.storage.updateProvider(localProvider.id, {
-                            autoCompactThreshold: setting.autoCompactThreshold,
-                        });
-                        logger.info({ providerName: setting.name, threshold: setting.autoCompactThreshold }, 'Applied autoCompactThreshold from template import');
-                    }
-                }
-            }
-            return {
-                success: true,
-                mode: 'replace',
-                replaced: true,
-                missingProviders: [],
-                counts: {
-                    imported: {
-                        prompts: payload.prompts.length,
-                        profiles: payload.profiles.length,
-                        agents: payload.agents.length,
-                        statuses: payload.statuses.length,
-                        watchers: payload.watchers.length,
-                        subscribers: payload.subscribers.length,
-                    },
-                    deleted: {
-                        prompts: existingPrompts.total,
-                        profiles: existingProfiles.total,
-                        agents: existingAgents.total,
-                        statuses: 0,
-                        watchers: existingWatchers.length,
-                        subscribers: existingSubscribers.length,
-                    },
-                    epics: {
-                        preserved: existingEpics.total,
-                        agentRemapped: epicsRemapped,
-                        agentCleared: epicsCleared,
-                    },
-                },
-                mappings: {
-                    promptIdMap,
-                    profileIdMap,
-                    agentIdMap,
-                    statusIdMap,
-                    watcherIdMap,
-                    subscriberIdMap,
-                },
-                initialPromptSet,
-                message: 'Project configuration replaced. Epics preserved.',
-            };
-        }
-        catch (error) {
-            logger.error({ error, projectId: input.projectId }, 'Import failed');
-            const message = this.getImportErrorMessage(error);
-            throw new error_types_1.StorageError(message);
-        }
-    }
-    async resolveProviders(providerNames) {
-        const providers = await this.storage.listProviders();
-        const available = new Map();
-        for (const prov of providers.items) {
-            available.set(prov.name.trim().toLowerCase(), prov.id);
-        }
-        const missing = Array.from(providerNames).filter((n) => !available.has(n));
-        return { available, missing };
+        return (0, project_import_1.importProjectWithHelper)(input, {
+            storage: this.storage,
+            settings: this.settings,
+            watchersService: this.watchersService,
+            sessions: this.sessions,
+            unifiedTemplateService: this.unifiedTemplateService,
+            computeFamilyAlternatives: (templateProfiles, templateAgents) => this.computeFamilyAlternatives(templateProfiles, templateAgents),
+            createWatchersFromPayload: (projectId, watchers, maps) => (0, project_runtime_helpers_1.createWatchersFromPayloadWithHelper)(projectId, watchers, maps, this.watchersService),
+            createSubscribersFromPayload: (projectId, subscribers) => (0, project_runtime_helpers_1.createSubscribersFromPayloadWithHelper)(projectId, subscribers, this.storage),
+            applyProjectSettings: (projectId, projectSettings, maps, archiveStatusId) => (0, project_runtime_helpers_1.applyProjectSettingsWithHelper)(projectId, projectSettings, maps, archiveStatusId, this.settings),
+            getImportErrorMessage: project_runtime_helpers_1.getImportErrorMessage,
+        });
     }
     async computeFamilyAlternatives(templateProfiles, templateAgents) {
-        const localProviders = await this.storage.listProviders();
-        const availableProviderNames = new Set(localProviders.items.map((p) => p.name.trim().toLowerCase()));
-        const profileById = new Map();
-        for (const prof of templateProfiles) {
-            if (prof.id) {
-                profileById.set(prof.id, prof);
-            }
-        }
-        const usedFamilySlugs = new Set();
-        for (const agent of templateAgents) {
-            if (agent.profileId) {
-                const profile = profileById.get(agent.profileId);
-                if (profile?.familySlug) {
-                    usedFamilySlugs.add(profile.familySlug);
-                }
-            }
-        }
-        const familyProviders = new Map();
-        for (const prof of templateProfiles) {
-            const familySlug = prof.familySlug;
-            if (!familySlug)
-                continue;
-            if (!familyProviders.has(familySlug)) {
-                familyProviders.set(familySlug, new Map());
-            }
-            const providerName = prof.provider.name.trim().toLowerCase();
-            const familyMap = familyProviders.get(familySlug);
-            if (!familyMap.has(providerName)) {
-                familyMap.set(providerName, []);
-            }
-            familyMap.get(providerName).push(prof.name);
-            if (prof.providerConfigs) {
-                for (const config of prof.providerConfigs) {
-                    const configProviderName = config.providerName.trim().toLowerCase();
-                    if (!familyMap.has(configProviderName)) {
-                        familyMap.set(configProviderName, []);
-                    }
-                    if (!familyMap.get(configProviderName).includes(prof.name)) {
-                        familyMap.get(configProviderName).push(prof.name);
-                    }
-                }
-            }
-        }
-        const alternatives = [];
-        const allMissingProviders = new Set();
-        let canImport = true;
-        for (const familySlug of usedFamilySlugs) {
-            const providersForFamily = familyProviders.get(familySlug);
-            if (!providersForFamily || providersForFamily.size === 0) {
-                logger.warn({ familySlug }, 'Family used by agent has no profiles');
-                continue;
-            }
-            const providerNamesForFamily = Array.from(providersForFamily.keys());
-            const defaultProvider = providerNamesForFamily[0];
-            const defaultProviderAvailable = availableProviderNames.has(defaultProvider);
-            const availableForFamily = providerNamesForFamily.filter((name) => availableProviderNames.has(name));
-            for (const provName of providerNamesForFamily) {
-                if (!availableProviderNames.has(provName)) {
-                    allMissingProviders.add(provName);
-                }
-            }
-            const hasAlternatives = availableForFamily.length > 0;
-            if (!hasAlternatives) {
-                canImport = false;
-            }
-            alternatives.push({
-                familySlug,
-                defaultProvider,
-                defaultProviderAvailable,
-                availableProviders: availableForFamily.sort(),
-                hasAlternatives,
-            });
-        }
-        return {
-            alternatives,
-            missingProviders: Array.from(allMissingProviders).sort(),
-            canImport,
-        };
-    }
-    selectProfilesForFamilies(templateProfiles, templateAgents, familyProviderMappings, availableProviders, options) {
-        const profileById = new Map();
-        for (const prof of templateProfiles) {
-            if (prof.id) {
-                profileById.set(prof.id, prof);
-            }
-        }
-        const templateAgentResolvedProviders = new Map();
-        for (const agent of templateAgents) {
-            if (!agent.providerConfigName || !agent.profileId)
-                continue;
-            const profile = profileById.get(agent.profileId);
-            if (!profile?.providerConfigs)
-                continue;
-            const configName = agent.providerConfigName.trim().toLowerCase();
-            const config = profile.providerConfigs.find((pc) => pc.name.trim().toLowerCase() === configName);
-            if (config) {
-                templateAgentResolvedProviders.set(agent.name.trim().toLowerCase(), config.providerName.trim().toLowerCase());
-            }
-        }
-        const profilesByFamilyAndProvider = new Map();
-        for (const prof of templateProfiles) {
-            if (!prof.familySlug)
-                continue;
-            const family = prof.familySlug;
-            const providerName = prof.provider.name.trim().toLowerCase();
-            if (!profilesByFamilyAndProvider.has(family)) {
-                profilesByFamilyAndProvider.set(family, new Map());
-            }
-            const familyMap = profilesByFamilyAndProvider.get(family);
-            if (!familyMap.has(providerName)) {
-                familyMap.set(providerName, prof);
-            }
-        }
-        const familyOriginalProviders = new Map();
-        for (const agent of templateAgents) {
-            if (!agent.profileId)
-                continue;
-            const profile = profileById.get(agent.profileId);
-            if (!profile?.familySlug)
-                continue;
-            const providerName = profile.provider.name.trim().toLowerCase();
-            familyOriginalProviders.set(profile.familySlug, providerName);
-        }
-        const selectedProfileIdsByFamily = new Map();
-        for (const [familySlug, providerMap] of profilesByFamilyAndProvider) {
-            let selectedProvider;
-            if (familyProviderMappings?.[familySlug]) {
-                selectedProvider = familyProviderMappings[familySlug].trim().toLowerCase();
-            }
-            else {
-                const originalProvider = familyOriginalProviders.get(familySlug);
-                if (originalProvider &&
-                    availableProviders.has(originalProvider) &&
-                    providerMap.has(originalProvider)) {
-                    selectedProvider = originalProvider;
-                }
-                else {
-                    for (const provName of providerMap.keys()) {
-                        if (availableProviders.has(provName)) {
-                            selectedProvider = provName;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (selectedProvider && providerMap.has(selectedProvider)) {
-                const profile = providerMap.get(selectedProvider);
-                if (profile.id) {
-                    selectedProfileIdsByFamily.set(familySlug, profile.id);
-                }
-            }
-        }
-        const coveredAgents = options?.presetCoveredAgentNames ?? new Set();
-        const profilesToCreate = [];
-        const usedProfileIds = new Set();
-        const providerSubstitutions = new Map();
-        const fallbackProviderName = availableProviders.size > 0 ? [...availableProviders.keys()][0] : undefined;
-        const profileAgentNames = new Map();
-        for (const agent of templateAgents) {
-            if (!agent.profileId)
-                continue;
-            const names = profileAgentNames.get(agent.profileId) ?? [];
-            names.push(agent.name);
-            profileAgentNames.set(agent.profileId, names);
-        }
-        for (const prof of templateProfiles) {
-            if (!prof.id || usedProfileIds.has(prof.id))
-                continue;
-            const providerName = prof.provider.name.trim().toLowerCase();
-            if (availableProviders.has(providerName)) {
-                usedProfileIds.add(prof.id);
-                profilesToCreate.push(prof);
-            }
-            else if (fallbackProviderName) {
-                if (prof.familySlug) {
-                    const selectedId = selectedProfileIdsByFamily.get(prof.familySlug);
-                    if (selectedId && selectedId !== prof.id)
-                        continue;
-                }
-                usedProfileIds.add(prof.id);
-                const allAgents = profileAgentNames.get(prof.id) ?? [];
-                const uncoveredAgents = allAgents.filter((name) => {
-                    const agentKey = name.trim().toLowerCase();
-                    if (coveredAgents.has(agentKey))
-                        return false;
-                    const templateResolved = templateAgentResolvedProviders.get(agentKey);
-                    if (templateResolved && availableProviders.has(templateResolved))
-                        return false;
-                    return true;
-                });
-                if (uncoveredAgents.length > 0) {
-                    const presetResolved = options?.presetAgentResolvedProviders;
-                    const agentsByMissingProvider = new Map();
-                    for (const agentName of uncoveredAgents) {
-                        const agentKey = agentName.trim().toLowerCase();
-                        const missing = presetResolved?.get(agentKey) ??
-                            templateAgentResolvedProviders.get(agentKey) ??
-                            providerName;
-                        const list = agentsByMissingProvider.get(missing) ?? [];
-                        list.push(agentName);
-                        agentsByMissingProvider.set(missing, list);
-                    }
-                    for (const [missingProvider, agents] of agentsByMissingProvider) {
-                        const key = agentsByMissingProvider.size > 1 ? `${prof.name}:${missingProvider}` : prof.name;
-                        providerSubstitutions.set(key, {
-                            originalProvider: missingProvider,
-                            substituteProvider: fallbackProviderName,
-                            agentNames: agents,
-                        });
-                    }
-                }
-                profilesToCreate.push({
-                    ...prof,
-                    provider: { name: fallbackProviderName },
-                    options: null,
-                });
-            }
-        }
-        const agentProfileMap = new Map();
-        for (const agent of templateAgents) {
-            if (!agent.id || !agent.profileId)
-                continue;
-            const originalProfile = profileById.get(agent.profileId);
-            if (!originalProfile) {
-                agentProfileMap.set(agent.id, agent.profileId);
-                continue;
-            }
-            if (originalProfile.familySlug) {
-                const selectedProfileId = selectedProfileIdsByFamily.get(originalProfile.familySlug);
-                agentProfileMap.set(agent.id, selectedProfileId ?? agent.profileId);
-            }
-            else {
-                agentProfileMap.set(agent.id, agent.profileId);
-            }
-        }
-        const profileNameRemapMap = new Map();
-        for (const [familySlug, providerMap] of profilesByFamilyAndProvider) {
-            const selectedProfileId = selectedProfileIdsByFamily.get(familySlug);
-            const selectedProfile = selectedProfileId
-                ? templateProfiles.find((p) => p.id === selectedProfileId)
-                : undefined;
-            if (selectedProfile) {
-                const selectedNameLower = selectedProfile.name.trim().toLowerCase();
-                for (const profile of providerMap.values()) {
-                    const profileNameLower = profile.name.trim().toLowerCase();
-                    if (profileNameLower !== selectedNameLower) {
-                        profileNameRemapMap.set(profileNameLower, selectedNameLower);
-                    }
-                }
-            }
-        }
-        return { profilesToCreate, agentProfileMap, profileNameRemapMap, providerSubstitutions };
-    }
-    buildNameToIdMaps(payload, mappings) {
-        const agentNameToId = new Map();
-        for (const a of payload.agents) {
-            if (a.id && mappings.agentIdMap[a.id]) {
-                const nameLower = a.name.trim().toLowerCase();
-                if (agentNameToId.has(nameLower)) {
-                    logger.warn({
-                        name: a.name,
-                        existingId: agentNameToId.get(nameLower),
-                        newId: mappings.agentIdMap[a.id],
-                    }, 'Duplicate agent name detected, using last occurrence');
-                }
-                agentNameToId.set(nameLower, mappings.agentIdMap[a.id]);
-            }
-        }
-        const profileNameToId = new Map();
-        for (const prof of payload.profiles) {
-            if (prof.id && mappings.profileIdMap[prof.id]) {
-                const nameLower = prof.name.trim().toLowerCase();
-                if (profileNameToId.has(nameLower)) {
-                    logger.warn({
-                        name: prof.name,
-                        existingId: profileNameToId.get(nameLower),
-                        newId: mappings.profileIdMap[prof.id],
-                    }, 'Duplicate profile name detected, using last occurrence');
-                }
-                profileNameToId.set(nameLower, mappings.profileIdMap[prof.id]);
-            }
-        }
-        return { agentNameToId, profileNameToId };
-    }
-    async createWatchersFromPayload(projectId, watchers, maps) {
-        const watcherIdMap = {};
-        let created = 0;
-        for (const w of watchers) {
-            let scopeFilterId = null;
-            if (w.scopeFilterName && w.scope !== 'all') {
-                const scopeFilterNameLower = w.scopeFilterName.trim().toLowerCase();
-                switch (w.scope) {
-                    case 'agent': {
-                        scopeFilterId = maps.agentNameToId.get(scopeFilterNameLower) ?? null;
-                        break;
-                    }
-                    case 'profile': {
-                        scopeFilterId = maps.profileNameToId.get(scopeFilterNameLower) ?? null;
-                        if (!scopeFilterId && maps.profileNameRemapMap) {
-                            const remappedName = maps.profileNameRemapMap.get(scopeFilterNameLower);
-                            if (remappedName) {
-                                scopeFilterId = maps.profileNameToId.get(remappedName) ?? null;
-                                if (scopeFilterId) {
-                                    logger.info({
-                                        projectId,
-                                        watcherName: w.name,
-                                        originalProfile: w.scopeFilterName,
-                                        remappedProfile: remappedName,
-                                    }, 'Watcher profile scope remapped due to provider family selection');
-                                }
-                            }
-                        }
-                        break;
-                    }
-                    case 'provider': {
-                        scopeFilterId = maps.providerNameToId.get(scopeFilterNameLower) ?? null;
-                        break;
-                    }
-                }
-                if (!scopeFilterId) {
-                    logger.warn({ projectId, watcherName: w.name, scope: w.scope, scopeFilterName: w.scopeFilterName }, 'Could not resolve scope filter, setting scope to "all"');
-                }
-            }
-            const createdWatcher = await this.watchersService.createWatcher({
-                projectId,
-                name: w.name,
-                description: w.description ?? null,
-                enabled: w.enabled,
-                scope: scopeFilterId ? w.scope : 'all',
-                scopeFilterId,
-                pollIntervalMs: w.pollIntervalMs,
-                viewportLines: w.viewportLines,
-                idleAfterSeconds: w.idleAfterSeconds ?? 0,
-                condition: w.condition,
-                cooldownMs: w.cooldownMs,
-                cooldownMode: w.cooldownMode,
-                eventName: w.eventName,
-            });
-            if (w.id)
-                watcherIdMap[w.id] = createdWatcher.id;
-            created++;
-        }
-        return { created, watcherIdMap };
-    }
-    async createSubscribersFromPayload(projectId, subscribers) {
-        const subscriberIdMap = {};
-        let created = 0;
-        for (const s of subscribers) {
-            const createdSubscriber = await this.storage.createSubscriber({
-                projectId,
-                name: s.name,
-                description: s.description ?? null,
-                enabled: s.enabled,
-                eventName: s.eventName,
-                eventFilter: s.eventFilter ?? null,
-                actionType: s.actionType,
-                actionInputs: s.actionInputs,
-                delayMs: s.delayMs,
-                cooldownMs: s.cooldownMs,
-                retryOnError: s.retryOnError,
-                groupName: s.groupName ?? null,
-                position: s.position ?? 0,
-                priority: s.priority ?? 0,
-            });
-            if (s.id)
-                subscriberIdMap[s.id] = createdSubscriber.id;
-            created++;
-        }
-        return { created, subscriberIdMap };
-    }
-    async applyProjectSettings(projectId, projectSettings, maps, archiveStatusId) {
-        let initialPromptSet = false;
-        if (projectSettings) {
-            const ps = projectSettings;
-            if (ps.initialPromptTitle) {
-                const promptId = maps.promptTitleToId.get(ps.initialPromptTitle.toLowerCase());
-                if (promptId) {
-                    await this.settings.updateSettings({
-                        projectId,
-                        initialSessionPromptId: promptId,
-                    });
-                    initialPromptSet = true;
-                    logger.info({ projectId, promptTitle: ps.initialPromptTitle }, 'Applied initial prompt from projectSettings');
-                }
-            }
-            if (ps.autoCleanStatusLabels && ps.autoCleanStatusLabels.length > 0) {
-                const autoCleanStatusIds = ps.autoCleanStatusLabels
-                    .map((label) => maps.statusLabelToId.get(label.toLowerCase()))
-                    .filter((id) => !!id);
-                if (autoCleanStatusIds.length > 0) {
-                    const currentSettings = this.settings.getSettings();
-                    const existingAutoClean = currentSettings.autoClean?.statusIds ?? {};
-                    await this.settings.updateSettings({
-                        autoClean: {
-                            statusIds: { ...existingAutoClean, [projectId]: autoCleanStatusIds },
-                        },
-                    });
-                    logger.info({ projectId, autoCleanStatusIds }, 'Applied autoClean statuses from projectSettings');
-                }
-            }
-            else if (archiveStatusId) {
-                const currentSettings = this.settings.getSettings();
-                const existingAutoClean = currentSettings.autoClean?.statusIds ?? {};
-                await this.settings.updateSettings({
-                    autoClean: {
-                        statusIds: { ...existingAutoClean, [projectId]: [archiveStatusId] },
-                    },
-                });
-                logger.info({ projectId, archiveStatusId }, 'Auto-configured Archive status for auto-clean (fallback)');
-            }
-            if (ps.epicAssignedTemplate) {
-                await this.settings.updateSettings({
-                    events: {
-                        epicAssigned: { template: ps.epicAssignedTemplate },
-                    },
-                });
-                logger.info({ projectId }, 'Applied epicAssigned template from projectSettings');
-            }
-            if (ps.messagePoolSettings) {
-                await this.settings.setProjectPoolSettings(projectId, ps.messagePoolSettings);
-                logger.info({ projectId, poolSettings: ps.messagePoolSettings }, 'Applied message pool settings from projectSettings');
-            }
-        }
-        else if (archiveStatusId) {
-            const currentSettings = this.settings.getSettings();
-            const existingAutoClean = currentSettings.autoClean?.statusIds ?? {};
-            await this.settings.updateSettings({
-                autoClean: {
-                    statusIds: { ...existingAutoClean, [projectId]: [archiveStatusId] },
-                },
-            });
-            logger.info({ projectId, archiveStatusId }, 'Auto-configured Archive status for auto-clean');
-        }
-        return { initialPromptSet };
-    }
-    normalizeProfileOptions(options) {
-        if (typeof options === 'string') {
-            return options;
-        }
-        if (options && typeof options === 'object') {
-            try {
-                return JSON.stringify(options);
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    getImportErrorMessage(error) {
-        const errorCode = error?.code;
-        if (errorCode === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
-            return 'Import failed: Cannot delete items that are still referenced. Check for cross-project agents using these profiles.';
-        }
-        if (errorCode === 'SQLITE_CONSTRAINT_UNIQUE') {
-            return 'Import failed: Duplicate entry detected.';
-        }
-        if (error instanceof Error) {
-            if (error.message.includes('FOREIGN KEY constraint failed')) {
-                return 'Import failed: Cannot delete items that are still referenced. Check for cross-project agents using these profiles.';
-            }
-            if (error.message.includes('UNIQUE constraint failed')) {
-                return 'Import failed: Duplicate entry detected.';
-            }
-            if (error.message.startsWith('Import failed')) {
-                return error.message;
-            }
-            return `Import failed: ${error.message}`;
-        }
-        return 'Import failed: An unexpected error occurred.';
-    }
-    slugify(name) {
-        return name
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/(^-|-$)/g, '');
-    }
-    deriveSlugFromPath(filePath) {
-        const filename = (0, path_1.basename)(filePath);
-        const nameWithoutExt = filename.replace(/\.json$/i, '');
-        return this.slugify(nameWithoutExt);
+        return (0, profile_mapping_helpers_1.computeFamilyAlternativesFromStorage)(this.storage, templateProfiles, templateAgents);
     }
     async getTemplateManifestForProject(projectId) {
-        const metadata = this.settings.getProjectTemplateMetadata(projectId);
-        if (!metadata?.templateSlug) {
-            logger.debug({ projectId }, 'No template metadata for project');
-            return null;
-        }
-        try {
-            if (metadata.source === 'file') {
-                logger.debug({ projectId, templateSlug: metadata.templateSlug }, 'File-based template - no manifest available');
-                return null;
-            }
-            if (metadata.source === 'bundled') {
-                const template = this.unifiedTemplateService.getBundledTemplate(metadata.templateSlug);
-                return template.content._manifest ?? null;
-            }
-            else {
-                const template = await this.unifiedTemplateService.getTemplate(metadata.templateSlug, metadata.installedVersion ?? undefined);
-                if (template.source !== 'registry') {
-                    logger.debug({
-                        projectId,
-                        templateSlug: metadata.templateSlug,
-                        expectedSource: 'registry',
-                        actualSource: template.source,
-                    }, 'Template source mismatch - registry template not available, rejecting bundled fallback');
-                    return null;
-                }
-                return template.content._manifest ?? null;
-            }
-        }
-        catch (error) {
-            logger.debug({ projectId, templateSlug: metadata.templateSlug, error }, 'Failed to fetch template manifest for project');
-            return null;
-        }
+        return (0, project_template_manifest_helpers_1.getTemplateManifestForProjectWithHelper)(projectId, {
+            settings: this.settings,
+            unifiedTemplateService: this.unifiedTemplateService,
+        });
     }
     getBundledUpgradeVersion(templateSlug, installedVersion) {
-        if (!installedVersion) {
-            return null;
-        }
-        try {
-            const bundled = this.unifiedTemplateService.getBundledTemplate(templateSlug);
-            const manifest = bundled.content._manifest;
-            const bundledVersion = manifest?.version;
-            if (!bundledVersion) {
-                return null;
-            }
-            if (!(0, shared_1.isValidSemVer)(installedVersion) || !(0, shared_1.isValidSemVer)(bundledVersion)) {
-                logger.warn({ templateSlug, installedVersion, bundledVersion }, 'Invalid semver version detected, skipping upgrade check');
-                return null;
-            }
-            if ((0, shared_1.isLessThan)(installedVersion, bundledVersion)) {
-                return bundledVersion;
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
+        return (0, project_template_manifest_helpers_1.getBundledUpgradeVersionWithHelper)(templateSlug, installedVersion, this.unifiedTemplateService);
     }
     getBundledUpgradesForProjects(projects) {
-        const result = new Map();
-        const bundledVersionCache = new Map();
-        for (const project of projects) {
-            if (project.source !== 'bundled' || !project.templateSlug) {
-                result.set(project.projectId, null);
-                continue;
-            }
-            if (!bundledVersionCache.has(project.templateSlug)) {
-                try {
-                    const bundled = this.unifiedTemplateService.getBundledTemplate(project.templateSlug);
-                    const manifest = bundled.content._manifest;
-                    bundledVersionCache.set(project.templateSlug, manifest?.version ?? null);
-                }
-                catch {
-                    bundledVersionCache.set(project.templateSlug, null);
-                }
-            }
-            const bundledVersion = bundledVersionCache.get(project.templateSlug);
-            if (!bundledVersion || !project.installedVersion) {
-                result.set(project.projectId, null);
-                continue;
-            }
-            if (!(0, shared_1.isValidSemVer)(project.installedVersion) || !(0, shared_1.isValidSemVer)(bundledVersion)) {
-                logger.warn({
-                    projectId: project.projectId,
-                    templateSlug: project.templateSlug,
-                    installedVersion: project.installedVersion,
-                    bundledVersion,
-                }, 'Invalid semver version detected, skipping upgrade check');
-                result.set(project.projectId, null);
-                continue;
-            }
-            if ((0, shared_1.isLessThan)(project.installedVersion, bundledVersion)) {
-                result.set(project.projectId, bundledVersion);
-            }
-            else {
-                result.set(project.projectId, null);
-            }
-        }
-        return result;
+        return (0, project_template_manifest_helpers_1.getBundledUpgradesForProjectsWithHelper)(projects, this.unifiedTemplateService);
     }
 };
 exports.ProjectsService = ProjectsService;