@telora/daemon 0.12.33

package/dist/unified-shell.js

@@ -0,0 +1,682 @@
+/**
+ * Unified daemon process shell -- the single entry point for telora-daemon.
+ *
+ * Composes daemon-core's lifecycle primitives (PID locking, signal handling,
+ * config loading) with one or more ExecutionEngine adapters (StrategyEngine,
+ * FactoryEngine). The CLI in index.ts creates engine instances based on the
+ * unified config and passes them here.
+ *
+ * Lifecycle sequence:
+ *   1. Load unified config via loadUnifiedConfig()
+ *   2. Apply engine filter (--engine flag) if provided
+ *   3. Acquire PID lock at .telora/daemon.pid
+ *   4. Register uncaughtException / unhandledRejection handlers
+ *   5. Set up signal handlers (SIGTERM, SIGINT)
+ *   6. For each enabled engine: build config, create instance, init, recover, start
+ *   7. Register SIGUSR1 (status) and SIGUSR2 (circuit breaker reset) handlers
+ *   8. Keep the process running indefinitely
+ *
+ * On shutdown (SIGTERM/SIGINT):
+ *   1. Stop all engines (stop accepting new work)
+ *   2. Shut down all engines in parallel (graceful cleanup)
+ *   3. Release PID lock
+ *   4. Exit
+ */
+import { readFileSync, openSync, closeSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { networkInterfaces } from 'node:os';
+import { spawn } from 'node:child_process';
+import { loadUnifiedConfig, buildEngineConfig, acquirePidLock, releasePidLock, setupSignalHandlers, PidLockError, forceCloseAllCircuitBreakers, ResourceGovernor, } from '@telora/daemon-core';
+import { StrategyEngine } from './strategy-engine.js';
+import { startAutoUpdateLoop } from './auto-update.js';
+import { setDaemonShuttingDown } from './shutdown-state.js';
+import { rotateDaemonLog, setupCanonicalLogTee, writeDaemonMeta, removeDaemonMeta, resolveDaemonLogPath, resolvePidFilePath, ensureGlobalStateDir } from './daemon-process.js';
+// ---------------------------------------------------------------------------
+// LAN host detection (mirrored from daemon's config.ts to avoid circular deps)
+// ---------------------------------------------------------------------------
+/**
+ * Auto-detect the first non-internal IPv4 address for LAN-accessible URLs.
+ * Falls back to 'localhost' if no suitable address is found.
+ */
+function detectLanHost() {
+    const interfaces = networkInterfaces();
+    for (const ifaceEntries of Object.values(interfaces)) {
+        if (!ifaceEntries)
+            continue;
+        for (const iface of ifaceEntries) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+// ---------------------------------------------------------------------------
+// Numeric env-var helpers (mirrored from daemon/config.ts)
+// ---------------------------------------------------------------------------
+function resolveInt(envVal, fileVal, defaultVal) {
+    if (envVal !== undefined && envVal !== '') {
+        return parseInt(envVal, 10);
+    }
+    if (typeof fileVal === 'number') {
+        return fileVal;
+    }
+    return defaultVal;
+}
+function resolveFloat(envVal, fileVal, defaultVal) {
+    if (envVal !== undefined && envVal !== '') {
+        return parseFloat(envVal);
+    }
+    if (typeof fileVal === 'number') {
+        return fileVal;
+    }
+    return defaultVal;
+}
+// ---------------------------------------------------------------------------
+// Engine config builders
+// ---------------------------------------------------------------------------
+/**
+ * Build a complete strategy engine config (DaemonConfig) from the unified
+ * base config and the strategy engine section. Applies the same defaults
+ * and env-var overrides as daemon/src/config.ts loadConfig().
+ */
+function buildStrategyConfig(base, section, env = process.env) {
+    // Start with the flat merge from daemon-core
+    const flat = buildEngineConfig(base, section);
+    const fields = section.fields;
+    const repoPath = flat.repoPath || process.cwd();
+    const claudeCodePath = flat.claudeCodePath || 'claude';
+    const logDir = flat.logDir || resolve(repoPath, '.telora', 'logs');
+    const sessionTimeoutMs = flat.sessionTimeoutMs ?? 3600000;
+    const mcpConfigPath = flat.mcpConfigPath ?? null;
+    // Strategy-specific fields with env overrides
+    const worktreeDir = env.TELORA_WORKTREE_DIR
+        || (typeof fields.worktreeDir === 'string' ? fields.worktreeDir : '')
+        || resolve(repoPath, '.telora', 'worktrees');
+    const integrationBranch = env.TELORA_INTEGRATION_BRANCH
+        || (typeof fields.integrationBranch === 'string' ? fields.integrationBranch : '')
+        || 'integration';
+    const maxTotalSessions = resolveInt(env.MAX_TOTAL_SESSIONS, fields.maxTotalSessions, 5);
+    const tokenLimit = resolveInt(env.TOKEN_LIMIT, fields.tokenLimit, 200000);
+    const costLimit = resolveFloat(env.COST_LIMIT, fields.costLimit, 10.0);
+    const mergeLockTimeoutMs = resolveInt(env.MERGE_LOCK_TIMEOUT_MS, fields.mergeLockTimeoutMs, 300000);
+    const mergeLockContentionWarningMs = resolveInt(env.MERGE_LOCK_CONTENTION_WARNING_MS, fields.mergeLockContentionWarningMs, 30000);
+    // Guard failure mode
+    const rawPolicyFailureMode = env.TELORA_POLICY_FAILURE_MODE
+        || (typeof fields.policyFailureMode === 'string' ? fields.policyFailureMode : '')
+        || 'fail-open';
+    if (rawPolicyFailureMode !== 'fail-open' && rawPolicyFailureMode !== 'fail-closed') {
+        throw new Error(`Invalid TELORA_POLICY_FAILURE_MODE: "${rawPolicyFailureMode}". Must be "fail-open" or "fail-closed".`);
+    }
+    // Log retention
+    const logMaxAgeDays = resolveInt(env.LOG_MAX_AGE_DAYS, fields.logMaxAgeDays, 7);
+    const logMaxTotalBytes = resolveInt(env.LOG_MAX_TOTAL_BYTES, fields.logMaxTotalBytes, 1073741824);
+    const logMaxFiles = resolveInt(env.LOG_MAX_FILES, fields.logMaxFiles, 500);
+    // Telemetry
+    const telemetryFile = (typeof fields.telemetry === 'object' && fields.telemetry !== null)
+        ? fields.telemetry
+        : {};
+    const telemetry = {
+        enabled: env.TELORA_TELEMETRY_ENABLED !== undefined
+            ? env.TELORA_TELEMETRY_ENABLED !== '0' && env.TELORA_TELEMETRY_ENABLED !== 'false'
+            : (typeof telemetryFile.enabled === 'boolean' ? telemetryFile.enabled : true),
+        port: resolveInt(env.TELORA_TELEMETRY_PORT, telemetryFile.port, 4318),
+        flushIntervalMs: resolveInt(env.TELORA_TELEMETRY_FLUSH_INTERVAL_MS, telemetryFile.flushIntervalMs, 5000),
+        retentionDays: resolveInt(env.TELORA_TELEMETRY_RETENTION_DAYS, telemetryFile.retentionDays, 30),
+    };
+    // QA environment
+    const qaPortRangeStart = resolveInt(env.TELORA_QA_PORT_RANGE_START, fields.qaPortRangeStart, 9100);
+    const qaPortRangeEnd = resolveInt(env.TELORA_QA_PORT_RANGE_END, fields.qaPortRangeEnd, 9199);
+    const qaHost = env.TELORA_QA_HOST
+        || (typeof fields.qaHost === 'string' ? fields.qaHost : '')
+        || detectLanHost();
+    // Local Supabase
+    const localSupabaseUrl = env.TELORA_LOCAL_SUPABASE_URL
+        || (typeof fields.localSupabaseUrl === 'string' ? fields.localSupabaseUrl : '')
+        || 'http://127.0.0.1:54321';
+    const localSupabaseAnonKey = env.TELORA_LOCAL_SUPABASE_ANON_KEY
+        || (typeof fields.localSupabaseAnonKey === 'string' ? fields.localSupabaseAnonKey : '')
+        || null;
+    // Products array from base config (already resolved by loadUnifiedConfig)
+    const products = flat.products ?? [];
+    return {
+        // Base fields
+        teloraUrl: flat.teloraUrl,
+        trackerId: flat.trackerId,
+        organizationId: flat.organizationId,
+        productId: flat.productId,
+        repoPath,
+        products,
+        claudeCodePath,
+        logDir,
+        sessionTimeoutMs,
+        mcpConfigPath,
+        // Strategy-specific fields
+        worktreeDir,
+        integrationBranch,
+        maxTotalSessions,
+        tokenLimit,
+        costLimit,
+        mergeLockTimeoutMs,
+        mergeLockContentionWarningMs,
+        policyFailureMode: rawPolicyFailureMode,
+        logMaxAgeDays,
+        logMaxTotalBytes,
+        logMaxFiles,
+        telemetry,
+        qaPortRangeStart,
+        qaPortRangeEnd,
+        qaHost,
+        localSupabaseUrl,
+        localSupabaseAnonKey,
+    };
+}
+/**
+ * Build a complete factory engine config (FactoryConfig) from the unified
+ * base config and the factory engine section. Applies the same defaults
+ * and env-var overrides as factory/src/config.ts loadConfig().
+ */
+function buildFactoryConfig(base, section, env = process.env) {
+    const flat = buildEngineConfig(base, section);
+    const fields = section.fields;
+    const repoPath = flat.repoPath || process.cwd();
+    const claudeCodePath = flat.claudeCodePath || 'claude';
+    // Factory uses a separate log directory by default
+    const logDir = flat.logDir || resolve(repoPath, '.telora', 'factory-logs');
+    const sessionTimeoutMs = flat.sessionTimeoutMs ?? 3600000;
+    const mcpConfigPath = flat.mcpConfigPath ?? null;
+    // Factory-specific fields with env overrides
+    const factoryWorktreeDir = env.TELORA_FACTORY_WORKTREE_DIR
+        || (typeof fields.factoryWorktreeDir === 'string' ? fields.factoryWorktreeDir : '')
+        || resolve(repoPath, '.telora', 'factory-worktrees');
+    const maxConcurrentInstances = env.FACTORY_MAX_CONCURRENT_INSTANCES
+        ? parseInt(env.FACTORY_MAX_CONCURRENT_INSTANCES, 10)
+        : (typeof fields.maxConcurrentInstances === 'number' ? fields.maxConcurrentInstances : 3);
+    // Telemetry: inherit from flat config (resolved by buildEngineConfig) or default
+    const telemetry = (flat.telemetry && typeof flat.telemetry === 'object')
+        ? flat.telemetry
+        : { enabled: true, port: 4318 };
+    // Products array from base config (already resolved by loadUnifiedConfig)
+    const products = flat.products ?? [];
+    return {
+        // Base fields
+        teloraUrl: flat.teloraUrl,
+        trackerId: flat.trackerId,
+        organizationId: flat.organizationId,
+        productId: flat.productId,
+        repoPath,
+        products,
+        claudeCodePath,
+        logDir,
+        sessionTimeoutMs,
+        mcpConfigPath,
+        // Factory-specific fields
+        factoryWorktreeDir,
+        maxConcurrentInstances,
+        telemetry,
+    };
+}
+// ---------------------------------------------------------------------------
+// Status reporting
+// ---------------------------------------------------------------------------
+/**
+ * Print aggregated status from all active engines.
+ */
+function printAggregatedStatus(engines, governor) {
+    console.log('\n=== Unified Daemon Status ===');
+    console.log(`Engines: ${engines.map(e => e.name).join(', ')}`);
+    console.log(`PID: ${process.pid}`);
+    console.log(`Uptime: ${Math.round(process.uptime())}s`);
+    // Resource governor utilization
+    if (governor) {
+        const util = governor.getUtilization();
+        console.log(`\n--- Resource Governor ---`);
+        console.log(`  Global slots: ${util.total}/${util.max} in use`);
+        for (const [engine, count] of Object.entries(util.perEngine)) {
+            console.log(`  ${engine}: ${count} slots`);
+        }
+        if (util.queueDepth > 0) {
+            console.log(`  Queue depth: ${util.queueDepth}`);
+            for (const [engine, depth] of Object.entries(util.queueDepthPerEngine)) {
+                console.log(`    ${engine}: ${depth} waiting`);
+            }
+        }
+    }
+    for (const engine of engines) {
+        const health = engine.healthCheck();
+        const resources = engine.getResourceUsage();
+        console.log(`\n--- ${engine.name} engine ---`);
+        console.log(`  Status: ${health.status}`);
+        console.log(`  Active work items: ${health.activeWorkItems}`);
+        console.log(`  Claude processes: ${resources.activeClaudeProcesses}`);
+        console.log(`  Active worktrees: ${resources.activeWorktrees}`);
+        // Print engine-specific details
+        const details = health.details;
+        for (const [key, value] of Object.entries(details)) {
+            if (Array.isArray(value)) {
+                if (value.length > 0) {
+                    console.log(`  ${key}:`);
+                    for (const item of value) {
+                        if (typeof item === 'object' && item !== null) {
+                            const parts = Object.entries(item)
+                                .map(([k, v]) => `${k}: ${String(v)}`)
+                                .join(' | ');
+                            console.log(`    - ${parts}`);
+                        }
+                        else {
+                            console.log(`    - ${String(item)}`);
+                        }
+                    }
+                }
+            }
+            else if (typeof value === 'object' && value !== null) {
+                const entries = Object.entries(value);
+                if (entries.length > 0) {
+                    console.log(`  ${key}:`);
+                    for (const [k, v] of entries) {
+                        console.log(`    ${k}: ${String(v)}`);
+                    }
+                }
+            }
+            else {
+                console.log(`  ${key}: ${String(value)}`);
+            }
+        }
+    }
+    console.log('');
+}
+/**
+ * Print a dry-run summary of the unified config.
+ */
+function printUnifiedConfigSummary(config) {
+    console.log('Unified Daemon Configuration:');
+    console.log(`  Telora URL: ${config.base.teloraUrl ?? '[not set]'}`);
+    console.log(`  Tracker ID: ${config.base.trackerId ? '[configured]' : '[not set]'}`);
+    console.log(`  Organization ID: ${config.base.organizationId ?? '[not set]'}`);
+    const products = config.base.products ?? [];
+    if (products.length > 0) {
+        console.log(`  Products: ${products.length}`);
+        for (const p of products) {
+            console.log(`    - ${p.id} -> ${p.repoPath}`);
+        }
+    }
+    else {
+        console.log(`  Product ID: ${config.base.productId ?? '[not set]'}`);
+        console.log(`  Repository Path: ${config.base.repoPath ?? '[cwd]'}`);
+    }
+    console.log(`  Claude Code Path: ${config.base.claudeCodePath ?? 'claude'}`);
+    console.log(`  Log Directory: ${config.base.logDir ?? '[default]'}`);
+    console.log(`  Session Timeout: ${config.base.sessionTimeoutMs ?? 3600000}ms`);
+    console.log(`  MCP Config Path: ${config.base.mcpConfigPath ?? '[not set]'}`);
+    console.log(`\n  Strategy engine: ${config.strategy.enabled ? 'enabled' : 'disabled'}`);
+    if (config.strategy.enabled) {
+        const sf = config.strategy.fields;
+        console.log(`    worktreeDir: ${String(sf.worktreeDir ?? '[default]')}`);
+        console.log(`    integrationBranch: ${String(sf.integrationBranch ?? 'integration')}`);
+        console.log(`    maxTotalSessions: ${String(sf.maxTotalSessions ?? 5)}`);
+    }
+    console.log(`\n  Factory engine: ${config.factory.enabled ? 'enabled' : 'disabled'}`);
+    if (config.factory.enabled) {
+        const ff = config.factory.fields;
+        console.log(`    factoryWorktreeDir: ${String(ff.factoryWorktreeDir ?? '[default]')}`);
+        console.log(`    maxConcurrentInstances: ${String(ff.maxConcurrentInstances ?? 3)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Auto-update config resolution
+// ---------------------------------------------------------------------------
+const DEFAULT_AUTO_UPDATE_INTERVAL_MS = 3_600_000; // 1 hour
+/**
+ * Resolve whether auto-update is enabled from env vars and config file.
+ * Env var TELORA_AUTO_UPDATE takes precedence over config file autoUpdate.enabled.
+ * Default: true.
+ */
+function resolveAutoUpdateEnabled(config) {
+    const envVal = process.env.TELORA_AUTO_UPDATE;
+    if (envVal !== undefined && envVal !== '') {
+        return envVal !== '0' && envVal !== 'false';
+    }
+    const fileConfig = config.rawFileConfig;
+    if (typeof fileConfig.autoUpdate === 'object' && fileConfig.autoUpdate !== null) {
+        const au = fileConfig.autoUpdate;
+        if (typeof au.enabled === 'boolean')
+            return au.enabled;
+    }
+    return true;
+}
+/**
+ * Resolve auto-update check interval from env vars and config file.
+ * Env var TELORA_AUTO_UPDATE_INTERVAL_MS takes precedence.
+ * Default: 3600000 (1 hour).
+ */
+function resolveAutoUpdateIntervalMs(config) {
+    const envVal = process.env.TELORA_AUTO_UPDATE_INTERVAL_MS;
+    if (envVal !== undefined && envVal !== '') {
+        const parsed = parseInt(envVal, 10);
+        if (!isNaN(parsed) && parsed > 0)
+            return parsed;
+    }
+    const fileConfig = config.rawFileConfig;
+    if (typeof fileConfig.autoUpdate === 'object' && fileConfig.autoUpdate !== null) {
+        const au = fileConfig.autoUpdate;
+        if (typeof au.intervalMs === 'number' && au.intervalMs > 0)
+            return au.intervalMs;
+    }
+    return DEFAULT_AUTO_UPDATE_INTERVAL_MS;
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+/**
+ * Run the unified daemon process shell.
+ *
+ * This function loads configuration, acquires a PID lock, creates and
+ * initializes execution engines, runs crash recovery, starts the engines,
+ * and keeps the process running until a shutdown signal is received.
+ *
+ * @param opts  CLI options (verbose, config path, dry-run, skip-recovery, engine filter).
+ */
+export async function runUnifiedDaemon(opts) {
+    // ── 1. Load unified config ───────────────────────────────────────────────
+    const config = loadUnifiedConfig(opts.config);
+    // ── 2. Apply engine filter ───────────────────────────────────────────────
+    if (opts.engineFilter) {
+        if (opts.engineFilter === 'strategy') {
+            config.factory = { enabled: false, fields: {} };
+        }
+        else if (opts.engineFilter === 'factory') {
+            config.strategy = { enabled: false, fields: {} };
+        }
+        console.log(`Engine filter active: only '${opts.engineFilter}' engine enabled`);
+    }
+    // ── 3. Dry run / verbose ─────────────────────────────────────────────────
+    if (opts.verbose || opts.dryRun) {
+        printUnifiedConfigSummary(config);
+    }
+    if (opts.dryRun) {
+        console.log('\nDry run mode -- exiting');
+        return;
+    }
+    // ── 4. Resolve repo path ─────────────────────────────────────────────────
+    const repoPath = config.base.repoPath || process.cwd();
+    // ── 5. Acquire PID lock ──────────────────────────────────────────────────
+    ensureGlobalStateDir();
+    const pidFilePath = resolvePidFilePath();
+    try {
+        acquirePidLock(pidFilePath);
+    }
+    catch (err) {
+        if (err instanceof PidLockError) {
+            console.error(err.message);
+            process.exit(1);
+        }
+        throw err;
+    }
+    // ── 5a. Canonical log setup ─────────────────────────────────────────────
+    // In foreground mode (TTY), rotate the log and tee stdout/stderr to it.
+    // In background mode, startDaemonBackground already rotated and redirected
+    // stdio to the log file, so we skip rotation to avoid renaming the file
+    // out from under our own fd.
+    const logPath = resolveDaemonLogPath();
+    let cleanupLogTee = null;
+    if (process.stdout.isTTY) {
+        rotateDaemonLog();
+        cleanupLogTee = setupCanonicalLogTee();
+    }
+    writeDaemonMeta(logPath);
+    // ── 5b. Register top-level error handlers (early, before engine init) ──
+    let isShuttingDown = false;
+    // shutdown is assigned later in this scope once engines and governor exist.
+    // It will be set before the event loop yields, so async handlers will see it.
+    let shutdown = null;
+    process.on('uncaughtException', (err) => {
+        console.error('[FATAL] Uncaught exception:', err);
+        if (isShuttingDown)
+            return;
+        if (shutdown) {
+            void shutdown('uncaughtException').finally(() => process.exit(1));
+        }
+        else {
+            // Exception during init before shutdown is wired up
+            releasePidLock(pidFilePath);
+            process.exit(1);
+        }
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error('[FATAL] Unhandled rejection:', reason);
+        if (isShuttingDown)
+            return;
+        if (shutdown) {
+            void shutdown('unhandledRejection');
+        }
+    });
+    // ── 6. Create engine instances ───────────────────────────────────────────
+    const engines = [];
+    if (config.strategy.enabled) {
+        engines.push(new StrategyEngine());
+    }
+    if (config.factory.enabled) {
+        try {
+            // Dynamic import: @telora/factory may not be installed in all deployments.
+            // The specifier is constructed via a variable so TypeScript does not attempt
+            // static module resolution (the factory dist/ may not exist at typecheck time).
+            const factoryModulePath = '@telora/factory/factory-engine';
+            const factoryModule = await import(/* webpackIgnore: true */ factoryModulePath);
+            engines.push(new factoryModule.FactoryEngine());
+        }
+        catch (err) {
+            console.warn(`Factory engine is enabled but @telora/factory could not be loaded: ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+            console.warn('The factory engine will be skipped. Install @telora/factory to enable it.');
+        }
+    }
+    if (engines.length === 0) {
+        console.error('No engines are enabled. Enable at least one engine in the config or remove --engine filter.');
+        releasePidLock(pidFilePath);
+        process.exit(1);
+    }
+    // ── 6b. Create and inject resource governor ─────────────────────────────
+    // Compute per-engine limits from config (using resolved defaults)
+    const engineLimits = {};
+    if (config.strategy.enabled && engines.some(e => e.name === 'strategy')) {
+        const strategyMax = typeof config.strategy.fields.maxTotalSessions === 'number'
+            ? config.strategy.fields.maxTotalSessions : 5;
+        engineLimits.strategy = strategyMax;
+    }
+    if (config.factory.enabled && engines.some(e => e.name === 'factory')) {
+        const factoryMax = typeof config.factory.fields.maxConcurrentInstances === 'number'
+            ? config.factory.fields.maxConcurrentInstances : 3;
+        engineLimits.factory = factoryMax;
+    }
+    // Global max: sum of per-engine limits (or env override)
+    const env = process.env;
+    const defaultGlobalMax = Object.values(engineLimits).reduce((sum, v) => sum + v, 0) || 8;
+    const maxGlobalSessions = env.TELORA_MAX_GLOBAL_SESSIONS
+        ? parseInt(env.TELORA_MAX_GLOBAL_SESSIONS, 10)
+        : (typeof config.rawFileConfig.maxGlobalSessions === 'number'
+            ? config.rawFileConfig.maxGlobalSessions : defaultGlobalMax);
+    const governor = new ResourceGovernor({
+        maxGlobalSessions,
+        engineLimits,
+    });
+    // Inject governor into engines via the ExecutionEngine interface
+    for (const engine of engines) {
+        engine.setGovernor?.(governor);
+    }
+    console.log(`Resource governor: max ${maxGlobalSessions} global sessions ` +
+        `(${Object.entries(engineLimits).map(([k, v]) => `${k}: ${v}`).join(', ')})`);
+    // ── 7. Set up shutdown handler ───────────────────────────────────────────
+    shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        setDaemonShuttingDown();
+        console.log(`\nReceived ${signal}, shutting down gracefully...`);
+        // Shut down the resource governor (reject pending acquires)
+        governor.shutdown();
+        // Phase 1: Stop all engines (stop accepting new work)
+        for (const engine of engines) {
+            try {
+                engine.stop();
+                console.log(`[${engine.name}] Stopped accepting new work`);
+            }
+            catch (err) {
+                console.warn(`[${engine.name}] Error during stop: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Phase 2: Shut down all engines in parallel (graceful cleanup)
+        const shutdownResults = await Promise.allSettled(engines.map(async (engine) => {
+            try {
+                await engine.shutdown();
+                console.log(`[${engine.name}] Shutdown complete`);
+            }
+            catch (err) {
+                console.warn(`[${engine.name}] Error during shutdown: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }));
+        // Log any rejected promises
+        for (let i = 0; i < shutdownResults.length; i++) {
+            const result = shutdownResults[i];
+            if (result && result.status === 'rejected') {
+                console.warn(`[${engines[i]?.name ?? 'unknown'}] Shutdown promise rejected: ${String(result.reason)}`);
+            }
+        }
+        // Phase 3: Release PID lock and clean up
+        cleanupLogTee?.();
+        removeDaemonMeta();
+        releasePidLock(pidFilePath);
+        console.log('Shutdown complete');
+        process.exit(0);
+    };
+    async function shutdownForUpdate() {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        setDaemonShuttingDown();
+        console.log('\n[auto-update] Shutting down for restart...');
+        governor.shutdown();
+        for (const engine of engines) {
+            try {
+                engine.stop();
+            }
+            catch { /* best effort */ }
+        }
+        await Promise.allSettled(engines.map(async (engine) => {
+            try {
+                await engine.shutdown();
+            }
+            catch { /* best effort */ }
+        }));
+        cleanupLogTee?.();
+        removeDaemonMeta();
+        releasePidLock(pidFilePath);
+        // Re-exec: spawn a new daemon process with the updated code.
+        // The old approach (exit code 75) required an external wrapper script
+        // or systemd config that was never present in normal `telora-daemon start`
+        // usage, so the daemon just died after a successful update.
+        console.log('[auto-update] Spawning new daemon process with updated code...');
+        const logPath = resolveDaemonLogPath();
+        const logFd = openSync(logPath, 'a');
+        const thisDir = dirname(fileURLToPath(import.meta.url));
+        const entryPoint = resolve(thisDir, 'index.js');
+        const child = spawn(process.execPath, [entryPoint, 'run'], {
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+            cwd: repoPath,
+            env: { ...process.env },
+        });
+        child.unref();
+        closeSync(logFd);
+        console.log(`[auto-update] New daemon spawned (PID ${child.pid}), exiting old process`);
+        process.exit(0);
+    }
+    // Register signal handlers (debounced by setupSignalHandlers)
+    // shutdown is guaranteed non-null here (assigned above)
+    setupSignalHandlers(shutdown);
+    // ── 8. Initialize and start engines ──────────────────────────────────────
+    try {
+        for (const engine of engines) {
+            console.log(`\n--- Initializing ${engine.name} engine ---`);
+            // Build the full config for this engine with all defaults applied
+            let engineConfig;
+            if (engine.name === 'strategy') {
+                engineConfig = buildStrategyConfig(config.base, config.strategy);
+            }
+            else if (engine.name === 'factory') {
+                engineConfig = buildFactoryConfig(config.base, config.factory);
+            }
+            else {
+                // Unknown engine type -- pass a basic merged config
+                const section = engine.name === 'strategy' ? config.strategy : config.factory;
+                engineConfig = buildEngineConfig(config.base, section);
+            }
+            // Init
+            await engine.init(engineConfig);
+            console.log(`[${engine.name}] Initialized`);
+            // Crash recovery
+            if (opts.skipRecovery) {
+                console.log(`[${engine.name}] Skipping crash recovery (--skip-recovery flag)`);
+            }
+            else {
+                await engine.recoverFromCrash();
+                console.log(`[${engine.name}] Crash recovery complete`);
+            }
+            // Start
+            await engine.start();
+            console.log(`[${engine.name}] Started`);
+        }
+    }
+    catch (err) {
+        console.error('Failed to initialize engines:', err instanceof Error ? err.message : String(err));
+        // Clean up: stop any engines that already started
+        for (const engine of engines) {
+            try {
+                engine.stop();
+            }
+            catch {
+                // Best effort
+            }
+        }
+        releasePidLock(pidFilePath);
+        process.exit(1);
+    }
+    // ── 9. Register SIGUSR1 (status) and SIGUSR2 (circuit breaker reset) ──
+    process.on('SIGUSR1', () => {
+        printAggregatedStatus(engines, governor);
+    });
+    process.on('SIGUSR2', () => {
+        forceCloseAllCircuitBreakers();
+    });
+    // ── 10. Print startup message ────────────────────────────────────────────
+    const engineNames = engines.map(e => e.name).join(', ');
+    let currentVersion = '0.0.0';
+    try {
+        const thisDir = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(thisDir, '..', 'package.json'), 'utf-8'));
+        if (pkg.version)
+            currentVersion = pkg.version;
+    }
+    catch { /* dev mode -- no package.json next to dist */ }
+    console.log(`\n[unified-daemon] v${currentVersion} Started at ${new Date().toISOString()} (PID ${process.pid})`);
+    console.log(`Engines: ${engineNames}`);
+    console.log('Press Ctrl+C to stop\n');
+    // ── 11. Start auto-update loop ──────────────────────────────────────────
+    const autoUpdateEnabled = !opts.noAutoUpdate && resolveAutoUpdateEnabled(config);
+    if (autoUpdateEnabled) {
+        const autoUpdateIntervalMs = resolveAutoUpdateIntervalMs(config);
+        startAutoUpdateLoop({
+            currentVersion,
+            intervalMs: autoUpdateIntervalMs,
+            isIdle: () => engines.every((e) => e.getResourceUsage().activeClaudeProcesses === 0),
+            onUpdateReady: () => {
+                console.log('[auto-update] Update installed, initiating restart...');
+                // Trigger graceful shutdown, then exit with code 75
+                void shutdownForUpdate();
+            },
+        });
+    }
+    // ── 12. Keep process alive ─────────────────────────────────────────────
+    await new Promise(() => { });
+}
+//# sourceMappingURL=unified-shell.js.map