devchain-cli 0.12.4 → 0.13.0

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

@@ -16,481 +16,77 @@ exports.SettingsService = exports.DEFAULT_SKILLS_SYNC_ON_STARTUP = exports.DEFAU
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
 const logger_1 = require("../../../common/logging/logger");
-const error_types_1 = require("../../../common/errors/error-types");
-const settings_dto_1 = require("../dtos/settings.dto");
 const db_provider_1 = require("../../storage/db/db.provider");
-const better_sqlite3_1 = require("drizzle-orm/better-sqlite3");
 const sqlite_raw_1 = require("../../storage/db/sqlite-raw");
-const crypto_1 = require("crypto");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const terminal_1 = require("../../../common/constants/terminal");
-Object.defineProperty(exports, "DEFAULT_TERMINAL_SCROLLBACK", { enumerable: true, get: function () { return terminal_1.DEFAULT_TERMINAL_SCROLLBACK; } });
-Object.defineProperty(exports, "MIN_TERMINAL_SCROLLBACK", { enumerable: true, get: function () { return terminal_1.MIN_TERMINAL_SCROLLBACK; } });
-Object.defineProperty(exports, "MAX_TERMINAL_SCROLLBACK", { enumerable: true, get: function () { return terminal_1.MAX_TERMINAL_SCROLLBACK; } });
-const catalog_1 = require("../../events/catalog");
+const preset_settings_delegate_1 = require("../local/delegates/preset-settings.delegate");
+const core_settings_delegate_1 = require("../local/delegates/core-settings.delegate");
+const message_pool_settings_delegate_1 = require("../local/delegates/message-pool-settings.delegate");
+const registry_settings_delegate_1 = require("../local/delegates/registry-settings.delegate");
+const skills_settings_delegate_1 = require("../local/delegates/skills-settings.delegate");
+var settings_constants_1 = require("./settings.constants");
+Object.defineProperty(exports, "DEFAULT_TERMINAL_SCROLLBACK", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_TERMINAL_SCROLLBACK; } });
+Object.defineProperty(exports, "MIN_TERMINAL_SCROLLBACK", { enumerable: true, get: function () { return settings_constants_1.MIN_TERMINAL_SCROLLBACK; } });
+Object.defineProperty(exports, "MAX_TERMINAL_SCROLLBACK", { enumerable: true, get: function () { return settings_constants_1.MAX_TERMINAL_SCROLLBACK; } });
+Object.defineProperty(exports, "DEFAULT_TERMINAL_SEED_MAX_BYTES", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_TERMINAL_SEED_MAX_BYTES; } });
+Object.defineProperty(exports, "MIN_TERMINAL_SEED_MAX_BYTES", { enumerable: true, get: function () { return settings_constants_1.MIN_TERMINAL_SEED_MAX_BYTES; } });
+Object.defineProperty(exports, "MAX_TERMINAL_SEED_MAX_BYTES", { enumerable: true, get: function () { return settings_constants_1.MAX_TERMINAL_SEED_MAX_BYTES; } });
+Object.defineProperty(exports, "DEFAULT_TERMINAL_INPUT_MODE", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_TERMINAL_INPUT_MODE; } });
+Object.defineProperty(exports, "DEFAULT_MESSAGE_POOL_ENABLED", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_MESSAGE_POOL_ENABLED; } });
+Object.defineProperty(exports, "DEFAULT_MESSAGE_POOL_DELAY_MS", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_MESSAGE_POOL_DELAY_MS; } });
+Object.defineProperty(exports, "MIN_MESSAGE_POOL_DELAY_MS", { enumerable: true, get: function () { return settings_constants_1.MIN_MESSAGE_POOL_DELAY_MS; } });
+Object.defineProperty(exports, "MAX_MESSAGE_POOL_DELAY_MS", { enumerable: true, get: function () { return settings_constants_1.MAX_MESSAGE_POOL_DELAY_MS; } });
+Object.defineProperty(exports, "DEFAULT_MESSAGE_POOL_MAX_WAIT_MS", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_MESSAGE_POOL_MAX_WAIT_MS; } });
+Object.defineProperty(exports, "MIN_MESSAGE_POOL_MAX_WAIT_MS", { enumerable: true, get: function () { return settings_constants_1.MIN_MESSAGE_POOL_MAX_WAIT_MS; } });
+Object.defineProperty(exports, "MAX_MESSAGE_POOL_MAX_WAIT_MS", { enumerable: true, get: function () { return settings_constants_1.MAX_MESSAGE_POOL_MAX_WAIT_MS; } });
+Object.defineProperty(exports, "DEFAULT_MESSAGE_POOL_MAX_MESSAGES", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_MESSAGE_POOL_MAX_MESSAGES; } });
+Object.defineProperty(exports, "MIN_MESSAGE_POOL_MAX_MESSAGES", { enumerable: true, get: function () { return settings_constants_1.MIN_MESSAGE_POOL_MAX_MESSAGES; } });
+Object.defineProperty(exports, "MAX_MESSAGE_POOL_MAX_MESSAGES", { enumerable: true, get: function () { return settings_constants_1.MAX_MESSAGE_POOL_MAX_MESSAGES; } });
+Object.defineProperty(exports, "DEFAULT_MESSAGE_POOL_SEPARATOR", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_MESSAGE_POOL_SEPARATOR; } });
+Object.defineProperty(exports, "DEFAULT_SKILLS_SYNC_ON_STARTUP", { enumerable: true, get: function () { return settings_constants_1.DEFAULT_SKILLS_SYNC_ON_STARTUP; } });
 const logger = (0, logger_1.createLogger)('SettingsService');
-exports.DEFAULT_TERMINAL_SEED_MAX_BYTES = 1024 * 1024;
-exports.MIN_TERMINAL_SEED_MAX_BYTES = 64 * 1024;
-exports.MAX_TERMINAL_SEED_MAX_BYTES = 4 * 1024 * 1024;
-exports.DEFAULT_TERMINAL_INPUT_MODE = 'tty';
-exports.DEFAULT_MESSAGE_POOL_ENABLED = true;
-exports.DEFAULT_MESSAGE_POOL_DELAY_MS = 10000;
-exports.MIN_MESSAGE_POOL_DELAY_MS = 1000;
-exports.MAX_MESSAGE_POOL_DELAY_MS = 60000;
-exports.DEFAULT_MESSAGE_POOL_MAX_WAIT_MS = 30000;
-exports.MIN_MESSAGE_POOL_MAX_WAIT_MS = 5000;
-exports.MAX_MESSAGE_POOL_MAX_WAIT_MS = 120000;
-exports.DEFAULT_MESSAGE_POOL_MAX_MESSAGES = 10;
-exports.MIN_MESSAGE_POOL_MAX_MESSAGES = 1;
-exports.MAX_MESSAGE_POOL_MAX_MESSAGES = 100;
-exports.DEFAULT_MESSAGE_POOL_SEPARATOR = '\n---\n';
-exports.DEFAULT_SKILLS_SYNC_ON_STARTUP = true;
 let SettingsService = class SettingsService {
     constructor(db, eventEmitter) {
         this.db = db;
         this.eventEmitter = eventEmitter;
-        this.DEFAULT_REGISTRY_URL = 'https://a1-devchain.twitechlab.com';
-        this.sqlite = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        const sqlite = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        this.coreDelegate = new core_settings_delegate_1.CoreSettingsDelegate({ sqlite, eventEmitter });
+        this.presetDelegate = new preset_settings_delegate_1.PresetSettingsDelegate({ sqlite });
+        this.skillsDelegate = new skills_settings_delegate_1.SkillsSettingsDelegate({ sqlite });
+        this.messagePoolDelegate = new message_pool_settings_delegate_1.MessagePoolSettingsDelegate({
+            getSettings: () => this.getSettings(),
+            updateSettings: (s) => this.updateSettings(s),
+        });
+        this.registryDelegate = new registry_settings_delegate_1.RegistrySettingsDelegate({
+            getSettings: () => this.getSettings(),
+            updateSettings: (s) => this.updateSettings(s),
+        });
         logger.info('SettingsService initialized');
     }
     getSettings() {
-        const rows = this.sqlite.prepare('SELECT key, value FROM settings').all();
-        const settings = {};
-        for (const row of rows) {
-            if (row.key === 'instanceMode' || row.key === 'apiKey') {
-            }
-            else if (row.key === 'registry.url') {
-                const valueStr = this.decodeStringSetting(row.value);
-                settings.registry = settings.registry ?? {};
-                settings.registry.url = valueStr || undefined;
-            }
-            else if (row.key === 'registry.cacheDir') {
-                const valueStr = this.decodeStringSetting(row.value);
-                settings.registry = settings.registry ?? {};
-                settings.registry.cacheDir = valueStr || undefined;
-            }
-            else if (row.key === 'registry.checkUpdatesOnStartup') {
-                const valueStr = this.decodeStringSetting(row.value);
-                settings.registry = settings.registry ?? {};
-                settings.registry.checkUpdatesOnStartup = valueStr === 'true';
-            }
-            else if (row.key === 'skills.syncOnStartup') {
-                const valueStr = this.decodeStringSetting(row.value);
-                settings.skills = settings.skills ?? {};
-                settings.skills.syncOnStartup = valueStr === 'true';
-            }
-            else if (row.key === 'skills.sources') {
-                try {
-                    const parsed = JSON.parse(row.value);
-                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                        settings.skills = settings.skills ?? {};
-                        settings.skills.sources = this.normalizeSkillSourcesMap(parsed);
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse skills.sources');
-                }
-            }
-            else if (row.key === 'claudeBinaryPath') {
-                settings.claudeBinaryPath = row.value;
-            }
-            else if (row.key === 'codexBinaryPath') {
-                settings.codexBinaryPath = row.value;
-            }
-            else if (row.key === 'dbPath') {
-                settings.dbPath = row.value;
-            }
-            else if (row.key === 'initialSessionPromptId') {
-                const promptId = this.extractPromptId(row.value);
-                settings.initialSessionPromptId = promptId ?? null;
-            }
-            else if (row.key === 'initialSessionPromptIds') {
-                try {
-                    const map = JSON.parse(row.value);
-                    if (typeof map === 'object' && map !== null) {
-                        settings.initialSessionPromptIds = map;
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse initialSessionPromptIds');
-                }
-            }
-            else if (row.key === 'terminal.seeding.mode') {
-            }
-            else if (row.key === 'terminal.scrollback.lines') {
-                const valueStr = this.decodeStringSetting(row.value);
-                const parsed = Number(valueStr);
-                if (Number.isFinite(parsed)) {
-                    const clamped = Math.max(terminal_1.MIN_TERMINAL_SCROLLBACK, Math.min(parsed, terminal_1.MAX_TERMINAL_SCROLLBACK));
-                    settings.terminal = settings.terminal ?? {};
-                    settings.terminal.scrollbackLines = clamped;
-                }
-                else {
-                    logger.warn({ stored: valueStr }, 'Ignoring invalid terminal scrollback value');
-                }
-            }
-            else if (row.key === 'terminal.seeding.maxBytes') {
-                const valueStr = this.decodeStringSetting(row.value);
-                const parsed = Number(valueStr);
-                if (Number.isFinite(parsed)) {
-                    const clamped = Math.max(exports.MIN_TERMINAL_SEED_MAX_BYTES, Math.min(parsed, exports.MAX_TERMINAL_SEED_MAX_BYTES));
-                    settings.terminal = settings.terminal ?? {};
-                    settings.terminal.seedingMaxBytes = clamped;
-                }
-                else {
-                    logger.warn({ stored: valueStr }, 'Ignoring invalid terminal seed max bytes value');
-                }
-            }
-            else if (row.key === 'events.epicAssigned.template') {
-                const template = this.decodeStringSetting(row.value);
-                settings.events = settings.events ?? {};
-                const currentEpicAssigned = settings.events.epicAssigned ?? {};
-                settings.events.epicAssigned = {
-                    ...currentEpicAssigned,
-                    template,
-                };
-            }
-            else if (row.key === 'terminal.engine') {
-            }
-            else if (row.key === 'terminal.inputMode') {
-                const inputMode = this.decodeStringSetting(row.value);
-                if (settings_dto_1.TERMINAL_INPUT_MODES.includes(inputMode)) {
-                    settings.terminal = settings.terminal ?? {};
-                    settings.terminal.inputMode = inputMode;
-                }
-                else {
-                }
-            }
-            else if (row.key === 'activity.idleTimeoutMs') {
-                const valueStr = this.decodeStringSetting(row.value);
-                const parsed = Number(valueStr);
-                const idleTimeoutMs = Number.isFinite(parsed) && parsed > 0 ? parsed : 30000;
-                settings.activity = settings.activity ?? {};
-                settings.activity.idleTimeoutMs = idleTimeoutMs;
-            }
-            else if (row.key === 'autoClean.statusIds') {
-                try {
-                    const map = JSON.parse(row.value);
-                    if (typeof map === 'object' && map !== null) {
-                        settings.autoClean = settings.autoClean ?? {};
-                        settings.autoClean.statusIds = map;
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse autoClean.statusIds');
-                }
-            }
-            else if (row.key === 'messagePool.enabled') {
-                const valueStr = this.decodeStringSetting(row.value);
-                settings.messagePool = settings.messagePool ?? {};
-                settings.messagePool.enabled = valueStr === 'true';
-            }
-            else if (row.key === 'messagePool.delayMs') {
-                const valueStr = this.decodeStringSetting(row.value);
-                const parsed = Number(valueStr);
-                if (Number.isFinite(parsed) && parsed > 0) {
-                    settings.messagePool = settings.messagePool ?? {};
-                    settings.messagePool.delayMs = Math.max(exports.MIN_MESSAGE_POOL_DELAY_MS, Math.min(parsed, exports.MAX_MESSAGE_POOL_DELAY_MS));
-                }
-            }
-            else if (row.key === 'messagePool.maxWaitMs') {
-                const valueStr = this.decodeStringSetting(row.value);
-                const parsed = Number(valueStr);
-                if (Number.isFinite(parsed) && parsed > 0) {
-                    settings.messagePool = settings.messagePool ?? {};
-                    settings.messagePool.maxWaitMs = Math.max(exports.MIN_MESSAGE_POOL_MAX_WAIT_MS, Math.min(parsed, exports.MAX_MESSAGE_POOL_MAX_WAIT_MS));
-                }
-            }
-            else if (row.key === 'messagePool.maxMessages') {
-                const valueStr = this.decodeStringSetting(row.value);
-                const parsed = Number(valueStr);
-                if (Number.isFinite(parsed) && parsed > 0) {
-                    settings.messagePool = settings.messagePool ?? {};
-                    settings.messagePool.maxMessages = Math.max(exports.MIN_MESSAGE_POOL_MAX_MESSAGES, Math.min(parsed, exports.MAX_MESSAGE_POOL_MAX_MESSAGES));
-                }
-            }
-            else if (row.key === 'messagePool.separator') {
-                const valueStr = this.decodeStringSetting(row.value);
-                settings.messagePool = settings.messagePool ?? {};
-                settings.messagePool.separator = valueStr;
-            }
-            else if (row.key === 'messagePool.projects') {
-                try {
-                    const map = JSON.parse(row.value);
-                    if (typeof map === 'object' && map !== null) {
-                        settings.messagePool = settings.messagePool ?? {};
-                        settings.messagePool.projects = map;
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse messagePool.projects');
-                }
-            }
-            else if (row.key === 'registryTemplates') {
-                try {
-                    const map = JSON.parse(row.value);
-                    if (typeof map === 'object' && map !== null) {
-                        settings.registryTemplates = map;
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse registryTemplates');
-                }
-            }
-            else if (row.key === 'projectPresets') {
-                try {
-                    const map = JSON.parse(row.value);
-                    if (typeof map === 'object' && map !== null) {
-                        settings.projectPresets = map;
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse projectPresets');
-                }
-            }
-            else if (row.key === 'projectActivePresets') {
-                try {
-                    const map = JSON.parse(row.value);
-                    if (typeof map === 'object' && map !== null) {
-                        settings.projectActivePresets = map;
-                    }
-                }
-                catch (error) {
-                    logger.warn({ error }, 'Failed to parse projectActivePresets');
-                }
-            }
-        }
-        const terminalSettings = settings.terminal ?? {};
-        const storedScrollback = terminalSettings.scrollbackLines ?? terminal_1.DEFAULT_TERMINAL_SCROLLBACK;
-        const storedSeedMaxBytes = terminalSettings.seedingMaxBytes ?? exports.DEFAULT_TERMINAL_SEED_MAX_BYTES;
-        const effectiveScrollback = Math.max(terminal_1.MIN_TERMINAL_SCROLLBACK, Math.min(storedScrollback, terminal_1.MAX_TERMINAL_SCROLLBACK));
-        const effectiveSeedMaxBytes = Math.max(exports.MIN_TERMINAL_SEED_MAX_BYTES, Math.min(storedSeedMaxBytes, exports.MAX_TERMINAL_SEED_MAX_BYTES));
-        const storedInputMode = terminalSettings.inputMode ?? exports.DEFAULT_TERMINAL_INPUT_MODE;
-        const inputMode = settings_dto_1.TERMINAL_INPUT_MODES.includes(storedInputMode)
-            ? storedInputMode
-            : exports.DEFAULT_TERMINAL_INPUT_MODE;
-        settings.terminal = {
-            scrollbackLines: effectiveScrollback,
-            seedingMaxBytes: effectiveSeedMaxBytes,
-            inputMode,
-        };
-        logger.debug({ settings }, 'Retrieved settings');
-        return settings;
+        return this.coreDelegate.getSettings();
     }
     async updateSettings(settings) {
-        if (settings.claudeBinaryPath !== undefined && settings.claudeBinaryPath !== '') {
-            await this.validateBinaryPath(settings.claudeBinaryPath, 'claude');
-        }
-        if (settings.codexBinaryPath !== undefined && settings.codexBinaryPath !== '') {
-            await this.validateBinaryPath(settings.codexBinaryPath, 'codex');
-        }
-        const now = new Date().toISOString();
-        const stmt = this.sqlite.prepare(`
-      INSERT INTO settings (id, key, value, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(key) DO UPDATE SET
-        value = excluded.value,
-        updated_at = excluded.updated_at
-    `);
-        this.sqlite.transaction(() => {
-            if (settings.claudeBinaryPath !== undefined) {
-                const normalizedPath = settings.claudeBinaryPath === '' ? '' : (0, path_1.resolve)(settings.claudeBinaryPath);
-                stmt.run((0, crypto_1.randomUUID)(), 'claudeBinaryPath', normalizedPath, now, now);
-            }
-            if (settings.codexBinaryPath !== undefined) {
-                const normalizedPath = settings.codexBinaryPath === '' ? '' : (0, path_1.resolve)(settings.codexBinaryPath);
-                stmt.run((0, crypto_1.randomUUID)(), 'codexBinaryPath', normalizedPath, now, now);
-            }
-            if (settings.dbPath !== undefined) {
-                stmt.run((0, crypto_1.randomUUID)(), 'dbPath', settings.dbPath, now, now);
-            }
-            if (settings.initialSessionPromptIds) {
-                const encodedMap = JSON.stringify(settings.initialSessionPromptIds);
-                stmt.run((0, crypto_1.randomUUID)(), 'initialSessionPromptIds', encodedMap, now, now);
-            }
-            if (settings.initialSessionPromptId !== undefined) {
-                const normalized = settings.initialSessionPromptId && settings.initialSessionPromptId.trim().length > 0
-                    ? settings.initialSessionPromptId.trim()
-                    : '';
-                if (settings.projectId) {
-                    const existing = this.getSetting('initialSessionPromptIds');
-                    let map = {};
-                    try {
-                        if (existing)
-                            map = JSON.parse(existing);
-                    }
-                    catch {
-                        map = {};
-                    }
-                    map[settings.projectId] = normalized || null;
-                    const encodedMap = JSON.stringify(map);
-                    stmt.run((0, crypto_1.randomUUID)(), 'initialSessionPromptIds', encodedMap, now, now);
-                }
-                else {
-                    const encoded = JSON.stringify(normalized);
-                    stmt.run((0, crypto_1.randomUUID)(), 'initialSessionPromptId', encoded, now, now);
-                }
-            }
-            const eventTemplate = settings.events?.epicAssigned?.template;
-            if (eventTemplate !== undefined) {
-                const normalized = eventTemplate ?? '';
-                const encoded = JSON.stringify(normalized);
-                stmt.run((0, crypto_1.randomUUID)(), 'events.epicAssigned.template', encoded, now, now);
-            }
-            const idleTimeoutMs = settings.activity?.idleTimeoutMs;
-            if (idleTimeoutMs !== undefined) {
-                const coerced = Math.max(1000, Math.min(idleTimeoutMs, 24 * 60 * 60 * 1000));
-                stmt.run((0, crypto_1.randomUUID)(), 'activity.idleTimeoutMs', String(coerced), now, now);
-            }
-            const scrollbackLines = settings.terminal?.scrollbackLines;
-            if (scrollbackLines !== undefined) {
-                const numeric = Math.max(terminal_1.MIN_TERMINAL_SCROLLBACK, Math.min(scrollbackLines, terminal_1.MAX_TERMINAL_SCROLLBACK));
-                stmt.run((0, crypto_1.randomUUID)(), 'terminal.scrollback.lines', String(numeric), now, now);
-            }
-            const seedingMaxBytes = settings.terminal?.seedingMaxBytes;
-            if (seedingMaxBytes !== undefined) {
-                const numeric = Math.max(exports.MIN_TERMINAL_SEED_MAX_BYTES, Math.min(seedingMaxBytes, exports.MAX_TERMINAL_SEED_MAX_BYTES));
-                stmt.run((0, crypto_1.randomUUID)(), 'terminal.seeding.maxBytes', String(numeric), now, now);
-            }
-            const inputMode = settings.terminal?.inputMode;
-            if (inputMode !== undefined) {
-                const inputModeToStore = settings_dto_1.TERMINAL_INPUT_MODES.includes(inputMode)
-                    ? inputMode
-                    : exports.DEFAULT_TERMINAL_INPUT_MODE;
-                stmt.run((0, crypto_1.randomUUID)(), 'terminal.inputMode', inputModeToStore, now, now);
-            }
-            if (settings.autoClean?.statusIds !== undefined) {
-                const encodedMap = JSON.stringify(settings.autoClean.statusIds);
-                stmt.run((0, crypto_1.randomUUID)(), 'autoClean.statusIds', encodedMap, now, now);
-            }
-            if (settings.messagePool !== undefined) {
-                if (settings.messagePool.enabled !== undefined) {
-                    stmt.run((0, crypto_1.randomUUID)(), 'messagePool.enabled', String(settings.messagePool.enabled), now, now);
-                }
-                if (settings.messagePool.delayMs !== undefined) {
-                    const clamped = Math.max(exports.MIN_MESSAGE_POOL_DELAY_MS, Math.min(settings.messagePool.delayMs, exports.MAX_MESSAGE_POOL_DELAY_MS));
-                    stmt.run((0, crypto_1.randomUUID)(), 'messagePool.delayMs', String(clamped), now, now);
-                }
-                if (settings.messagePool.maxWaitMs !== undefined) {
-                    const clamped = Math.max(exports.MIN_MESSAGE_POOL_MAX_WAIT_MS, Math.min(settings.messagePool.maxWaitMs, exports.MAX_MESSAGE_POOL_MAX_WAIT_MS));
-                    stmt.run((0, crypto_1.randomUUID)(), 'messagePool.maxWaitMs', String(clamped), now, now);
-                }
-                if (settings.messagePool.maxMessages !== undefined) {
-                    const clamped = Math.max(exports.MIN_MESSAGE_POOL_MAX_MESSAGES, Math.min(settings.messagePool.maxMessages, exports.MAX_MESSAGE_POOL_MAX_MESSAGES));
-                    stmt.run((0, crypto_1.randomUUID)(), 'messagePool.maxMessages', String(clamped), now, now);
-                }
-                if (settings.messagePool.separator !== undefined) {
-                    stmt.run((0, crypto_1.randomUUID)(), 'messagePool.separator', JSON.stringify(settings.messagePool.separator), now, now);
-                }
-                if (settings.messagePool.projects !== undefined) {
-                    const encodedMap = JSON.stringify(settings.messagePool.projects);
-                    stmt.run((0, crypto_1.randomUUID)(), 'messagePool.projects', encodedMap, now, now);
-                }
-            }
-            if (settings.registry !== undefined) {
-                if (settings.registry.url !== undefined) {
-                    stmt.run((0, crypto_1.randomUUID)(), 'registry.url', JSON.stringify(settings.registry.url), now, now);
-                }
-                if (settings.registry.cacheDir !== undefined) {
-                    stmt.run((0, crypto_1.randomUUID)(), 'registry.cacheDir', JSON.stringify(settings.registry.cacheDir), now, now);
-                }
-                if (settings.registry.checkUpdatesOnStartup !== undefined) {
-                    stmt.run((0, crypto_1.randomUUID)(), 'registry.checkUpdatesOnStartup', String(settings.registry.checkUpdatesOnStartup), now, now);
-                }
-            }
-            if (settings.skills !== undefined) {
-                if (settings.skills.syncOnStartup !== undefined) {
-                    stmt.run((0, crypto_1.randomUUID)(), 'skills.syncOnStartup', String(settings.skills.syncOnStartup), now, now);
-                }
-                if (settings.skills.sources !== undefined) {
-                    const encodedMap = JSON.stringify(this.normalizeSkillSourcesMap(settings.skills.sources));
-                    stmt.run((0, crypto_1.randomUUID)(), 'skills.sources', encodedMap, now, now);
-                }
-            }
-            if (settings.registryTemplates !== undefined) {
-                const encodedMap = JSON.stringify(settings.registryTemplates);
-                stmt.run((0, crypto_1.randomUUID)(), 'registryTemplates', encodedMap, now, now);
-            }
-            if (settings.projectPresets !== undefined) {
-                const encodedMap = JSON.stringify(settings.projectPresets);
-                stmt.run((0, crypto_1.randomUUID)(), 'projectPresets', encodedMap, now, now);
-            }
-            if (settings.projectActivePresets !== undefined) {
-                const encodedMap = JSON.stringify(settings.projectActivePresets);
-                stmt.run((0, crypto_1.randomUUID)(), 'projectActivePresets', encodedMap, now, now);
-            }
-        })();
-        logger.info('Settings updated');
-        if (settings.terminal?.scrollbackLines !== undefined) {
-            const clampedScrollback = Math.max(terminal_1.MIN_TERMINAL_SCROLLBACK, Math.min(settings.terminal.scrollbackLines, terminal_1.MAX_TERMINAL_SCROLLBACK));
-            const payload = { scrollbackLines: clampedScrollback };
-            try {
-                catalog_1.settingsTerminalChangedEvent.schema.parse(payload);
-                this.eventEmitter.emit('settings.terminal.changed', payload);
-                logger.debug({ scrollbackLines: clampedScrollback }, 'Emitted settings.terminal.changed event');
-            }
-            catch (error) {
-                logger.error({ scrollbackLines: clampedScrollback, error }, 'Failed to validate/emit settings.terminal.changed event');
-            }
-        }
-        return this.getSettings();
+        return this.coreDelegate.updateSettings(settings);
     }
     getSetting(key) {
-        const row = this.sqlite.prepare('SELECT value FROM settings WHERE key = ?').get(key);
-        return row ? this.decodeStringSetting(row.value) : undefined;
+        return this.coreDelegate.getSetting(key);
     }
     getScrollbackLines() {
-        const value = this.getSetting('terminal.scrollback.lines');
-        const parsed = value ? parseInt(value, 10) : terminal_1.DEFAULT_TERMINAL_SCROLLBACK;
-        if (!Number.isFinite(parsed)) {
-            return terminal_1.DEFAULT_TERMINAL_SCROLLBACK;
-        }
-        return Math.max(terminal_1.MIN_TERMINAL_SCROLLBACK, Math.min(terminal_1.MAX_TERMINAL_SCROLLBACK, parsed));
+        return this.coreDelegate.getScrollbackLines();
     }
     getSkillsSyncOnStartup() {
-        const value = this.getSetting('skills.syncOnStartup');
-        if (value === undefined || value.trim().length === 0) {
-            return exports.DEFAULT_SKILLS_SYNC_ON_STARTUP;
-        }
-        return value === 'true';
+        return this.skillsDelegate.getSkillsSyncOnStartup();
     }
     getSkillSourcesEnabled() {
-        const raw = this.getSetting('skills.sources');
-        if (!raw || raw.trim().length === 0) {
-            return {};
-        }
-        try {
-            const parsed = JSON.parse(raw);
-            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-                return {};
-            }
-            return this.normalizeSkillSourcesMap(parsed);
-        }
-        catch (error) {
-            logger.warn({ error }, 'Failed to parse skills.sources setting');
-            return {};
-        }
+        return this.skillsDelegate.getSkillSourcesEnabled();
     }
     async setSkillSourceEnabled(sourceName, enabled) {
-        const normalizedSourceName = sourceName.trim().toLowerCase();
-        if (!normalizedSourceName) {
-            throw new error_types_1.ValidationError('sourceName is required.', { fieldName: 'sourceName' });
-        }
-        const current = this.getSkillSourcesEnabled();
-        current[normalizedSourceName] = enabled;
-        await this.updateSettings({
-            skills: {
-                sources: current,
-            },
-        });
-        logger.info({ sourceName: normalizedSourceName, enabled }, 'Skill source enablement updated');
+        return this.skillsDelegate.setSkillSourceEnabled(sourceName, enabled);
     }
     getAutoCleanStatusIds(projectId) {
         const raw = this.getSetting('autoClean.statusIds');
-        if (!raw) {
+        if (!raw)
             return [];
-        }
         try {
             const map = JSON.parse(raw);
             return map[projectId] ?? [];
@@ -501,523 +97,115 @@ let SettingsService = class SettingsService {
         }
     }
     getMessagePoolConfig() {
-        const settings = this.getSettings();
-        const pool = settings.messagePool ?? {};
-        return {
-            enabled: pool.enabled ?? exports.DEFAULT_MESSAGE_POOL_ENABLED,
-            delayMs: pool.delayMs ?? exports.DEFAULT_MESSAGE_POOL_DELAY_MS,
-            maxWaitMs: pool.maxWaitMs ?? exports.DEFAULT_MESSAGE_POOL_MAX_WAIT_MS,
-            maxMessages: pool.maxMessages ?? exports.DEFAULT_MESSAGE_POOL_MAX_MESSAGES,
-            separator: pool.separator ?? exports.DEFAULT_MESSAGE_POOL_SEPARATOR,
-        };
+        return this.messagePoolDelegate.getMessagePoolConfig();
     }
     getMessagePoolConfigForProject(projectId) {
-        const globalConfig = this.getMessagePoolConfig();
-        const settings = this.getSettings();
-        const projectOverrides = settings.messagePool?.projects?.[projectId];
-        if (!projectOverrides) {
-            return globalConfig;
-        }
-        return {
-            enabled: projectOverrides.enabled ?? globalConfig.enabled,
-            delayMs: projectOverrides.delayMs ?? globalConfig.delayMs,
-            maxWaitMs: projectOverrides.maxWaitMs ?? globalConfig.maxWaitMs,
-            maxMessages: projectOverrides.maxMessages ?? globalConfig.maxMessages,
-            separator: projectOverrides.separator ?? globalConfig.separator,
-        };
+        return this.messagePoolDelegate.getMessagePoolConfigForProject(projectId);
     }
     getProjectPoolSettings(projectId) {
-        const settings = this.getSettings();
-        return settings.messagePool?.projects?.[projectId];
+        return this.messagePoolDelegate.getProjectPoolSettings(projectId);
     }
     async setProjectPoolSettings(projectId, poolSettings) {
-        const currentSettings = this.getSettings();
-        const existingProjects = currentSettings.messagePool?.projects ?? {};
-        if (poolSettings === null) {
-            const remaining = { ...existingProjects };
-            delete remaining[projectId];
-            await this.updateSettings({
-                messagePool: {
-                    projects: remaining,
-                },
-            });
-        }
-        else {
-            await this.updateSettings({
-                messagePool: {
-                    projects: {
-                        ...existingProjects,
-                        [projectId]: poolSettings,
-                    },
-                },
-            });
-        }
-        logger.info({ projectId, poolSettings }, 'Project pool settings updated');
+        return this.messagePoolDelegate.setProjectPoolSettings(projectId, poolSettings);
     }
     getProjectSettings(projectId) {
         const settings = this.getSettings();
         const result = {};
         const promptId = settings.initialSessionPromptIds?.[projectId];
-        if (promptId !== undefined) {
+        if (promptId !== undefined)
             result.initialSessionPromptId = promptId;
-        }
         const autoCleanIds = settings.autoClean?.statusIds?.[projectId];
-        if (autoCleanIds && autoCleanIds.length > 0) {
+        if (autoCleanIds && autoCleanIds.length > 0)
             result.autoCleanStatusIds = autoCleanIds;
-        }
         const epicTemplate = settings.events?.epicAssigned?.template;
-        if (epicTemplate) {
+        if (epicTemplate)
             result.epicAssignedTemplate = epicTemplate;
-        }
         const poolSettings = settings.messagePool?.projects?.[projectId];
-        if (poolSettings) {
+        if (poolSettings)
             result.messagePoolSettings = poolSettings;
-        }
         return result;
     }
-    async setProjectSettings(projectId, projectSettings) {
+    async setProjectSettings(projectId, ps) {
         const updates = {};
-        if (projectSettings.initialSessionPromptId !== undefined) {
+        if (ps.initialSessionPromptId !== undefined) {
             updates.projectId = projectId;
-            updates.initialSessionPromptId = projectSettings.initialSessionPromptId;
+            updates.initialSessionPromptId = ps.initialSessionPromptId;
         }
-        if (projectSettings.autoCleanStatusIds !== undefined) {
-            const currentSettings = this.getSettings();
-            const existingMap = currentSettings.autoClean?.statusIds ?? {};
-            updates.autoClean = {
-                statusIds: {
-                    ...existingMap,
-                    [projectId]: projectSettings.autoCleanStatusIds,
-                },
-            };
+        if (ps.autoCleanStatusIds !== undefined) {
+            const existing = this.getSettings().autoClean?.statusIds ?? {};
+            updates.autoClean = { statusIds: { ...existing, [projectId]: ps.autoCleanStatusIds } };
         }
-        if (projectSettings.epicAssignedTemplate !== undefined) {
-            updates.events = {
-                epicAssigned: { template: projectSettings.epicAssignedTemplate },
-            };
+        if (ps.epicAssignedTemplate !== undefined) {
+            updates.events = { epicAssigned: { template: ps.epicAssignedTemplate } };
         }
-        if (projectSettings.messagePoolSettings !== undefined) {
-            const currentSettings = this.getSettings();
-            const existingProjects = currentSettings.messagePool?.projects ?? {};
-            updates.messagePool = {
-                projects: {
-                    ...existingProjects,
-                    [projectId]: projectSettings.messagePoolSettings,
-                },
-            };
+        if (ps.messagePoolSettings !== undefined) {
+            const existing = this.getSettings().messagePool?.projects ?? {};
+            updates.messagePool = { projects: { ...existing, [projectId]: ps.messagePoolSettings } };
         }
         if (Object.keys(updates).length > 0) {
             await this.updateSettings(updates);
             logger.info({ projectId, updates: Object.keys(updates) }, 'Project settings updated');
         }
     }
-    async validateBinaryPath(binaryPath, providerName) {
-        if (process.platform === 'win32') {
-            logger.warn({ binaryPath, providerName }, 'Binary validation skipped on Windows');
-            return;
-        }
-        const absolutePath = (0, path_1.resolve)(binaryPath);
-        try {
-            await (0, promises_1.access)(absolutePath, promises_1.constants.F_OK | promises_1.constants.R_OK);
-            await (0, promises_1.access)(absolutePath, promises_1.constants.X_OK);
-            logger.info({ binaryPath, absolutePath, providerName }, 'Binary path validated successfully');
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error && 'code' in error && error.code === 'ENOENT'
-                ? `Binary not found: ${absolutePath}`
-                : `Binary not executable: ${absolutePath}`;
-            logger.error({ binaryPath, absolutePath, providerName, error }, 'Binary validation failed');
-            throw new error_types_1.ValidationError(errorMsg, {
-                provider: providerName,
-                path: absolutePath,
-                hint: `The ${providerName} binary path must point to an existing executable file. Please check the path and file permissions.`,
-            });
-        }
-    }
-    decodeStringSetting(value) {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return '';
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (typeof parsed === 'string') {
-                return parsed;
-            }
-        }
-        catch {
-        }
-        return trimmed;
-    }
-    normalizeSkillSourcesMap(rawMap) {
-        const normalized = {};
-        for (const [rawKey, rawValue] of Object.entries(rawMap)) {
-            if (typeof rawValue !== 'boolean') {
-                continue;
-            }
-            const normalizedKey = rawKey.trim().toLowerCase();
-            if (!normalizedKey) {
-                continue;
-            }
-            normalized[normalizedKey] = rawValue;
-        }
-        return normalized;
-    }
-    extractPromptId(value) {
-        if (value === undefined || value === null) {
-            return null;
-        }
-        if (typeof value === 'object') {
-            if ('initialSessionPromptId' in value) {
-                return this.extractPromptId(value.initialSessionPromptId);
-            }
-            if ('value' in value) {
-                return this.extractPromptId(value.value);
-            }
-            return null;
-        }
-        const stringValue = typeof value === 'number' || typeof value === 'boolean' ? String(value) : value;
-        let candidate = stringValue.trim();
-        if (!candidate) {
-            return null;
-        }
-        try {
-            const parsed = JSON.parse(candidate);
-            if (typeof parsed === 'string' && parsed.trim().length > 0) {
-                candidate = parsed.trim();
-            }
-            else if (parsed && typeof parsed === 'object') {
-                return this.extractPromptId(parsed);
-            }
-        }
-        catch {
-        }
-        if (candidate.startsWith('"') && candidate.endsWith('"') && candidate.length >= 2) {
-            candidate = candidate.slice(1, -1).trim();
-        }
-        return candidate.length > 0 ? candidate : null;
-    }
     getRegistryConfig() {
-        const settings = this.getSettings();
-        const registry = settings.registry ?? {};
-        const url = registry.url || process.env.REGISTRY_URL || this.DEFAULT_REGISTRY_URL;
-        return {
-            url,
-            cacheDir: registry.cacheDir ?? '',
-            checkUpdatesOnStartup: registry.checkUpdatesOnStartup ?? true,
-        };
+        return this.registryDelegate.getRegistryConfig();
     }
     async setRegistryConfig(config) {
-        const currentSettings = this.getSettings();
-        const existingRegistry = currentSettings.registry ?? {};
-        await this.updateSettings({
-            registry: {
-                ...existingRegistry,
-                ...config,
-            },
-        });
-        logger.info({ config }, 'Registry config updated');
+        return this.registryDelegate.setRegistryConfig(config);
     }
     getProjectTemplateMetadata(projectId) {
-        const settings = this.getSettings();
-        return settings.registryTemplates?.[projectId] ?? null;
+        return this.registryDelegate.getProjectTemplateMetadata(projectId);
     }
     async setProjectTemplateMetadata(projectId, metadata) {
-        const currentSettings = this.getSettings();
-        const existingTemplates = currentSettings.registryTemplates ?? {};
-        await this.updateSettings({
-            registryTemplates: {
-                ...existingTemplates,
-                [projectId]: metadata,
-            },
-        });
-        logger.info({ projectId, templateSlug: metadata.templateSlug, version: metadata.installedVersion }, 'Project template metadata updated');
+        return this.registryDelegate.setProjectTemplateMetadata(projectId, metadata);
     }
     async clearProjectTemplateMetadata(projectId) {
-        const currentSettings = this.getSettings();
-        const existingTemplates = currentSettings.registryTemplates ?? {};
-        const { [projectId]: _removed, ...remaining } = existingTemplates;
-        await this.updateSettings({
-            registryTemplates: remaining,
-        });
-        logger.info({ projectId }, 'Project template metadata cleared');
+        return this.registryDelegate.clearProjectTemplateMetadata(projectId);
     }
     getAllTrackedProjects() {
-        const settings = this.getSettings();
-        const templates = settings.registryTemplates ?? {};
-        return Object.entries(templates).map(([projectId, metadata]) => ({
-            projectId,
-            metadata,
-        }));
+        return this.registryDelegate.getAllTrackedProjects();
     }
     getAllProjectTemplateMetadataMap() {
-        const settings = this.getSettings();
-        const templates = settings.registryTemplates ?? {};
-        return new Map(Object.entries(templates));
+        return this.registryDelegate.getAllProjectTemplateMetadataMap();
     }
     async updateLastUpdateCheck(projectId) {
-        const existing = this.getProjectTemplateMetadata(projectId);
-        if (!existing) {
-            logger.warn({ projectId }, 'Cannot update lastUpdateCheckAt: project not tracked');
-            return;
-        }
-        await this.setProjectTemplateMetadata(projectId, {
-            ...existing,
-            lastUpdateCheckAt: new Date().toISOString(),
-        });
+        return this.registryDelegate.updateLastUpdateCheck(projectId);
     }
     getProjectPresets(projectId) {
-        const settings = this.getSettings();
-        const rawPresets = settings.projectPresets?.[projectId] ?? [];
-        const validatedPresets = [];
-        for (const preset of rawPresets) {
-            const result = settings_dto_1.TemplatePresetSchema.safeParse(preset);
-            if (result.success) {
-                validatedPresets.push(result.data);
-            }
-            else {
-                logger.warn({ projectId, preset, issues: result.error.issues }, 'Invalid preset found in storage, filtering out');
-            }
-        }
-        return validatedPresets;
+        return this.presetDelegate.getProjectPresets(projectId);
     }
     async setProjectPresets(projectId, presets) {
-        const validatedPresets = [];
-        const errors = [];
-        for (let i = 0; i < presets.length; i++) {
-            const preset = presets[i];
-            const result = settings_dto_1.TemplatePresetSchema.safeParse(preset);
-            if (result.success) {
-                validatedPresets.push(result.data);
-            }
-            else {
-                const errorIssues = result.error.issues
-                    .map((issue) => `[${issue.path.join('.')}] ${issue.message}`)
-                    .join('; ');
-                errors.push(`Preset at index ${i}: ${errorIssues}`);
-            }
-        }
-        if (errors.length > 0) {
-            throw new error_types_1.ValidationError('Invalid preset data', {
-                projectId,
-                errors,
-            });
-        }
-        const currentSettings = this.getSettings();
-        const existingPresets = currentSettings.projectPresets ?? {};
-        await this.updateSettings({
-            projectPresets: {
-                ...existingPresets,
-                [projectId]: validatedPresets,
-            },
-        });
-        logger.info({ projectId, presetCount: validatedPresets.length }, 'Project presets updated');
+        return this.presetDelegate.setProjectPresets(projectId, presets);
     }
     async clearProjectPresets(projectId) {
-        const currentSettings = this.getSettings();
-        const existingPresets = currentSettings.projectPresets ?? {};
-        const { [projectId]: _removed, ...remaining } = existingPresets;
-        await this.updateSettings({
-            projectPresets: remaining,
-        });
-        logger.info({ projectId }, 'Project presets cleared');
+        return this.presetDelegate.clearProjectPresets(projectId);
     }
     getAllProjectPresetsMap() {
-        const settings = this.getSettings();
-        const presets = settings.projectPresets ?? {};
-        return new Map(Object.entries(presets));
+        return this.presetDelegate.getAllProjectPresetsMap();
+    }
+    async renameProviderConfigInProjectPresets(projectId, input) {
+        return this.presetDelegate.renameProviderConfigInProjectPresets(projectId, input);
     }
     async createProjectPreset(projectId, preset) {
-        const result = settings_dto_1.TemplatePresetSchema.safeParse(preset);
-        if (!result.success) {
-            const errorIssues = result.error.issues
-                .map((issue) => `[${issue.path.join('.')}] ${issue.message}`)
-                .join('; ');
-            throw new error_types_1.ValidationError(`Invalid preset data: ${errorIssues}`, {
-                projectId,
-                issues: result.error.issues,
-            });
-        }
-        const validatedPreset = result.data;
-        const trimmedName = validatedPreset.name.trim();
-        if (!trimmedName) {
-            throw new error_types_1.ValidationError('Preset name cannot be empty or whitespace only', {
-                projectId,
-            });
-        }
-        const existingPresets = this.getProjectPresets(projectId);
-        const normalizedName = trimmedName.toLowerCase();
-        const nameExists = existingPresets.some((p) => p.name.toLowerCase() === normalizedName);
-        if (nameExists) {
-            throw new error_types_1.ValidationError(`Preset with name "${trimmedName}" already exists (case-insensitive)`, {
-                projectId,
-                presetName: trimmedName,
-                hint: 'Choose a different name or delete the existing preset first.',
-            });
-        }
-        const currentSettings = this.getSettings();
-        const existingPresetsMap = currentSettings.projectPresets ?? {};
-        await this.updateSettings({
-            projectPresets: {
-                ...existingPresetsMap,
-                [projectId]: [...existingPresets, { ...validatedPreset, name: trimmedName }],
-            },
-        });
-        logger.info({ projectId, presetName: trimmedName }, 'Preset created');
+        return this.presetDelegate.createProjectPreset(projectId, preset);
     }
     async updateProjectPreset(projectId, presetName, updates) {
-        const existingPresets = this.getProjectPresets(projectId);
-        const normalizedName = presetName.trim().toLowerCase();
-        const presetIndex = existingPresets.findIndex((p) => p.name.toLowerCase() === normalizedName);
-        if (presetIndex === -1) {
-            throw new error_types_1.ValidationError(`Preset "${presetName.trim()}" not found`, {
-                projectId,
-                presetName: presetName.trim(),
-            });
-        }
-        const existingPreset = existingPresets[presetIndex];
-        const mergedPreset = { ...existingPreset };
-        if (typeof updates === 'object' && updates !== null) {
-            const updateObj = updates;
-            if ('name' in updateObj) {
-                if (typeof updateObj.name !== 'string') {
-                    throw new error_types_1.ValidationError(`Invalid preset update: name must be a string`, {
-                        projectId,
-                        presetName,
-                    });
-                }
-                mergedPreset.name = updateObj.name;
-            }
-            if ('description' in updateObj) {
-                if (updateObj.description !== null && typeof updateObj.description !== 'string') {
-                    throw new error_types_1.ValidationError(`Invalid preset update: description must be a string or null`, {
-                        projectId,
-                        presetName,
-                    });
-                }
-                mergedPreset.description = updateObj.description;
-            }
-            if ('agentConfigs' in updateObj) {
-                if (!Array.isArray(updateObj.agentConfigs)) {
-                    throw new error_types_1.ValidationError(`Invalid preset update: agentConfigs must be an array`, {
-                        projectId,
-                        presetName,
-                    });
-                }
-                mergedPreset.agentConfigs = updateObj.agentConfigs;
-            }
-        }
-        const result = settings_dto_1.TemplatePresetSchema.safeParse(mergedPreset);
-        if (!result.success) {
-            const errorIssues = result.error.issues
-                .map((issue) => `[${issue.path.join('.')}] ${issue.message}`)
-                .join('; ');
-            throw new error_types_1.ValidationError(`Invalid preset update: ${errorIssues}`, {
-                projectId,
-                presetName,
-                issues: result.error.issues,
-            });
-        }
-        const validatedPreset = result.data;
-        const trimmedName = validatedPreset.name.trim();
-        validatedPreset.name = trimmedName;
-        if (trimmedName.toLowerCase() !== normalizedName) {
-            const nameExists = existingPresets.some((p, idx) => idx !== presetIndex && p.name.toLowerCase() === trimmedName.toLowerCase());
-            if (nameExists) {
-                throw new error_types_1.ValidationError(`Preset with name "${trimmedName}" already exists (case-insensitive)`, {
-                    projectId,
-                    presetName: trimmedName,
-                    hint: 'Choose a different name.',
-                });
-            }
-        }
-        const updatedPresets = [...existingPresets];
-        updatedPresets.splice(presetIndex, 1);
-        updatedPresets.push(validatedPreset);
-        const currentSettings = this.getSettings();
-        const existingPresetsMap = currentSettings.projectPresets ?? {};
-        const existingActivePresets = currentSettings.projectActivePresets ?? {};
-        const updatePayload = {
-            projectPresets: {
-                ...existingPresetsMap,
-                [projectId]: updatedPresets,
-            },
-        };
-        if (trimmedName.toLowerCase() !== normalizedName) {
-            const originalName = existingPreset.name;
-            const currentActivePreset = existingActivePresets[projectId];
-            if (currentActivePreset && currentActivePreset.toLowerCase() === originalName.toLowerCase()) {
-                updatePayload.projectActivePresets = {
-                    ...existingActivePresets,
-                    [projectId]: trimmedName,
-                };
-                logger.info({ projectId, oldName: currentActivePreset, newName: trimmedName }, 'Active preset migrated after rename (case-insensitive)');
-            }
-        }
-        await this.updateSettings(updatePayload);
-        logger.info({ projectId, presetName: trimmedName }, 'Preset updated');
+        return this.presetDelegate.updateProjectPreset(projectId, presetName, updates);
     }
     async deleteProjectPreset(projectId, presetName) {
-        const existingPresets = this.getProjectPresets(projectId);
-        const normalizedName = presetName.trim().toLowerCase();
-        const presetIndex = existingPresets.findIndex((p) => p.name.toLowerCase() === normalizedName);
-        if (presetIndex === -1) {
-            throw new error_types_1.ValidationError(`Preset "${presetName.trim()}" not found`, {
-                projectId,
-                presetName: presetName.trim(),
-            });
-        }
-        const deletedPreset = existingPresets[presetIndex];
-        const updatedPresets = existingPresets.filter((_, idx) => idx !== presetIndex);
-        const currentSettings = this.getSettings();
-        const existingPresetsMap = currentSettings.projectPresets ?? {};
-        const existingActivePresets = currentSettings.projectActivePresets ?? {};
-        const updatePayload = {
-            projectPresets: {
-                ...existingPresetsMap,
-                [projectId]: updatedPresets,
-            },
-        };
-        const currentActivePreset = existingActivePresets[projectId];
-        if (currentActivePreset &&
-            currentActivePreset.toLowerCase() === deletedPreset.name.toLowerCase()) {
-            const { [projectId]: _removed, ...remainingActivePresets } = existingActivePresets;
-            updatePayload.projectActivePresets = remainingActivePresets;
-            logger.info({ projectId, presetName: deletedPreset.name, activePreset: currentActivePreset }, 'Active preset cleared after preset deletion (case-insensitive)');
-        }
-        await this.updateSettings(updatePayload);
-        logger.info({ projectId, presetName: deletedPreset.name }, 'Preset deleted');
+        return this.presetDelegate.deleteProjectPreset(projectId, presetName);
     }
     getProjectActivePreset(projectId) {
-        const settings = this.getSettings();
-        return settings.projectActivePresets?.[projectId] ?? null;
+        return this.presetDelegate.getProjectActivePreset(projectId);
     }
     async setProjectActivePreset(projectId, presetName) {
-        const currentSettings = this.getSettings();
-        const existingActivePresets = currentSettings.projectActivePresets ?? {};
-        if (presetName === null) {
-            const { [projectId]: _removed, ...remaining } = existingActivePresets;
-            await this.updateSettings({
-                projectActivePresets: remaining,
-            });
-            logger.info({ projectId }, 'Project active preset cleared');
-        }
-        else {
-            await this.updateSettings({
-                projectActivePresets: {
-                    ...existingActivePresets,
-                    [projectId]: presetName,
-                },
-            });
-            logger.info({ projectId, presetName }, 'Project active preset set');
-        }
+        return this.presetDelegate.setProjectActivePreset(projectId, presetName);
     }
 };
 exports.SettingsService = SettingsService;
 exports.SettingsService = SettingsService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(db_provider_1.DB_CONNECTION)),
-    __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database,
-        event_emitter_1.EventEmitter2])
+    __metadata("design:paramtypes", [Function, event_emitter_1.EventEmitter2])
 ], SettingsService);
 //# sourceMappingURL=settings.service.js.map