@loom-framework/core 0.1.0-alpha.19 → 0.1.0-alpha.191

package/dist/backend/process/engine.js

@@ -0,0 +1,668 @@
+/**
+ * ProcessEngine - Core orchestration engine
+ *
+ * Manages process definitions, triggers, concurrent execution, AI calls, and logging.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { ClaudeCodeEngine } from '../ai/engine.js';
+import { generateId } from '../../utils/id.js';
+import { parseDuration } from '../../utils/duration.js';
+import { ProcessRegistry } from './registry.js';
+import { TriggerManager } from './trigger.js';
+import { ExecutionQueue } from './queue.js';
+import { ProcessLogger } from './logger.js';
+import { ProcessMetricsStore } from './metrics-store.js';
+import { issueServiceToken } from '../auth/service-token.js';
+import { mergeContentBlock } from '../ai/content-blocks.js';
+const FILE_SIZE_INLINE_LIMIT = 10 * 1024; // 10KB
+export class ProcessEngine {
+    registry;
+    triggerManager;
+    queue;
+    logger;
+    metricsStore;
+    engine;
+    sessionManager;
+    config;
+    paths;
+    defaultUserId;
+    eventBus;
+    eventRegistry;
+    authConfig;
+    userStore;
+    serverUrl;
+    isShutdown = false;
+    /** Tracks event subscriptions per process for pause/resume (processName → subscriptions) */
+    eventSubscriptionMap = new Map();
+    constructor(options) {
+        this.config = options.config;
+        this.engine = options.engine;
+        this.sessionManager = options.sessionManager;
+        this.paths = options.paths;
+        this.defaultUserId = options.defaultUserId ?? 'admin';
+        this.eventBus = options.eventBus;
+        this.eventRegistry = options.eventRegistry;
+        this.authConfig = options.authConfig;
+        this.userStore = options.userStore;
+        this.serverUrl = options.serverUrl;
+        this.registry = new ProcessRegistry(options.paths, this.defaultUserId);
+        this.logger = new ProcessLogger(options.paths, this.defaultUserId);
+        this.metricsStore = new ProcessMetricsStore(options.paths, this.defaultUserId);
+        this.queue = new ExecutionQueue(options.config.maxConcurrent ?? 5);
+        this.triggerManager = new TriggerManager((name, type, payload) => {
+            void this.runProcess(name, type, payload).catch(err => {
+                console.error(`[ProcessEngine] Error triggering process "${name}":`, err);
+            });
+        });
+    }
+    async initialize() {
+        await this.registry.initialize();
+        await this.logger.initialize();
+        await this.metricsStore.initialize();
+        // Crash recovery: mark stale 'running' entries as 'failed'
+        const recovered = await this.logger.recoverCrashedEntries();
+        if (recovered > 0) {
+            console.warn(`[ProcessEngine] Recovered ${recovered} crashed execution(s)`);
+        }
+        // Restore cron triggers from registry (skip paused processes; event subscriptions are NOT restored here —
+        // they are registered by the server startup loop in index.ts)
+        const processes = await this.registry.listProcesses();
+        const definitions = processes
+            .filter(p => !p.paused)
+            .map(p => ({
+            name: p.name,
+            cron: p.cron,
+            cronTimezone: p.cronTimezone,
+        }));
+        await this.triggerManager.restoreTriggers(definitions);
+        // Register process event patterns for discoverability
+        if (this.eventRegistry) {
+            for (const proc of processes) {
+                this.registerEventPatterns(proc.name);
+            }
+        }
+        const cronCount = processes.filter(p => p.cron).length;
+        console.log(`[ProcessEngine] Started, ${processes.length} process(es) registered, ${cronCount} cron trigger(s)`);
+    }
+    registerEventPatterns(name) {
+        if (!this.eventRegistry)
+            return;
+        this.eventRegistry.register(`process:started:${name}`, 'process', `Process ${name} started execution`, '{ runId, processName, triggerType }');
+        this.eventRegistry.register(`process:completed:${name}`, 'process', `Process ${name} completed successfully`, '{ runId, processName, durationMs }');
+        this.eventRegistry.register(`process:failed:${name}`, 'process', `Process ${name} failed`, '{ runId, processName, error }');
+    }
+    async addProcess(def) {
+        // Validate: exactly one of prompt or hasProcessFile must be set
+        if (!def.prompt && !def.hasProcessFile) {
+            throw new Error('Process must have either "prompt" (lightweight) or "hasProcessFile" (full)');
+        }
+        if (def.prompt && def.hasProcessFile) {
+            throw new Error('Process cannot have both "prompt" and "hasProcessFile" — choose one mode');
+        }
+        // Validate: if hasProcessFile, check PROCESS.md exists
+        if (def.hasProcessFile) {
+            const valid = await this.registry.validateProcessFile(def.name);
+            if (!valid) {
+                throw new Error(`PROCESS.md not found — run 'loom process generate ${def.name}' first`);
+            }
+        }
+        const process = await this.registry.addProcess(def);
+        // Start cron trigger (event subscriptions are managed externally via registerEventSubscription)
+        if (process.cron) {
+            this.triggerManager.startCron(process.name, process.cron, process.cronTimezone);
+        }
+        // Register event patterns
+        this.registerEventPatterns(process.name);
+        return process;
+    }
+    async removeProcess(name) {
+        const process = await this.registry.getProcess(name);
+        if (!process)
+            return false;
+        // Cancel queued entries
+        this.queue.cancelForProcess(name);
+        // Stop triggers
+        if (process.cron)
+            this.triggerManager.stopCron(name);
+        this.triggerManager.stopEventSubscription(name); // stops all patterns for this process
+        // Clean up event subscription map
+        this.eventSubscriptionMap.delete(name);
+        // Unregister process event patterns from registry
+        if (this.eventRegistry) {
+            this.eventRegistry.unregister(`process:started:${name}`);
+            this.eventRegistry.unregister(`process:completed:${name}`);
+            this.eventRegistry.unregister(`process:failed:${name}`);
+        }
+        return this.registry.removeProcess(name);
+    }
+    async pauseProcess(name) {
+        const process = await this.registry.getProcess(name);
+        if (!process)
+            throw new Error(`Process "${name}" not found`);
+        if (process.paused)
+            return;
+        const updated = await this.registry.updateProcess(name, { paused: true });
+        if (updated?.cron)
+            this.triggerManager.stopCron(name);
+        // Stop all event subscriptions for this process
+        this.triggerManager.stopEventSubscription(name);
+    }
+    async resumeProcess(name) {
+        const process = await this.registry.getProcess(name);
+        if (!process)
+            throw new Error(`Process "${name}" not found`);
+        if (!process.paused)
+            return;
+        const updated = await this.registry.updateProcess(name, { paused: false });
+        if (updated?.cron)
+            this.triggerManager.startCron(name, updated.cron, updated.cronTimezone);
+        // Resume all event subscriptions from eventSubscriptionMap
+        const subs = this.eventSubscriptionMap.get(name);
+        if (subs && this.eventBus) {
+            for (const sub of subs) {
+                this.triggerManager.startEventSubscription(name, this.eventBus, sub.pattern, sub.filter, sub.debounceMs);
+            }
+        }
+    }
+    async updateProcess(name, updates) {
+        const existing = await this.registry.getProcess(name);
+        if (!existing)
+            return undefined;
+        const updated = await this.registry.updateProcess(name, updates);
+        if (!updated)
+            return undefined;
+        // Re-register cron triggers if cron/cronTimezone changed
+        if ('cron' in updates || 'cronTimezone' in updates) {
+            if (existing.cron)
+                this.triggerManager.stopCron(name);
+            if (updated.cron)
+                this.triggerManager.startCron(name, updated.cron, updated.cronTimezone);
+        }
+        // Note: event subscriptions are managed via registerEventSubscription/unregisterEventSubscription
+        return updated;
+    }
+    /** Register an event subscription for a process (in-memory + TriggerManager) */
+    registerEventSubscription(processName, eventBus, pattern, filter, debounceMs, start = true) {
+        // Always track in eventSubscriptionMap (needed for resumeProcess)
+        let subs = this.eventSubscriptionMap.get(processName);
+        if (!subs) {
+            subs = [];
+            this.eventSubscriptionMap.set(processName, subs);
+        }
+        // Replace existing entry for same pattern, or add new
+        const existingIdx = subs.findIndex(s => s.pattern === pattern);
+        if (existingIdx !== -1) {
+            subs[existingIdx] = { pattern, filter, debounceMs };
+        }
+        else {
+            subs.push({ pattern, filter, debounceMs });
+        }
+        // Only start the TriggerManager subscription when start=true
+        // (start=false for paused processes: map is populated but trigger is not active)
+        if (start) {
+            this.triggerManager.startEventSubscription(processName, eventBus, pattern, filter, debounceMs);
+        }
+    }
+    /** Unregister an event subscription for a process */
+    unregisterEventSubscription(processName, pattern) {
+        this.triggerManager.stopEventSubscription(processName, pattern);
+        if (pattern) {
+            // Remove specific pattern from eventSubscriptionMap
+            const subs = this.eventSubscriptionMap.get(processName);
+            if (subs) {
+                const idx = subs.findIndex(s => s.pattern === pattern);
+                if (idx !== -1)
+                    subs.splice(idx, 1);
+                if (subs.length === 0)
+                    this.eventSubscriptionMap.delete(processName);
+            }
+        }
+        else {
+            // Remove all subscriptions for this process
+            this.eventSubscriptionMap.delete(processName);
+        }
+    }
+    /** Get event subscriptions for a process (for API responses) */
+    getEventSubscriptions(processName) {
+        return this.eventSubscriptionMap.get(processName)?.slice() ?? [];
+    }
+    async runProcess(name, triggerType, eventPayload) {
+        const definition = await this.registry.getProcess(name);
+        if (!definition)
+            throw new Error(`Process "${name}" not found`);
+        if (definition.paused && triggerType !== 'manual') {
+            throw new Error(`Process "${name}" is paused. Resume it before triggering.`);
+        }
+        // Manual run overrides pause, but we still queue it
+        const runId = generateId('proc-run');
+        const entry = {
+            runId,
+            processName: name,
+            enqueuedAt: new Date().toISOString(),
+            triggerType,
+            eventPayload,
+            state: 'queued',
+        };
+        this.queue.enqueue(entry);
+        // Try to execute if slot available
+        this.tryExecuteNext();
+        return runId;
+    }
+    /** Build AI prompt from process definition */
+    async buildProcessPrompt(definition, runId, triggerType, eventPayload) {
+        const sections = [];
+        const files = [];
+        let processContent = '';
+        let hasMetricsSection = false;
+        // 1. Read process definition (PROCESS.md or inline prompt)
+        if (definition.hasProcessFile) {
+            const processDir = this.paths.forUser(definition.owner).processDir(definition.name);
+            const processMd = path.join(processDir, 'PROCESS.md');
+            try {
+                processContent = await fs.readFile(processMd, 'utf-8');
+            }
+            catch {
+                throw new Error(`PROCESS.md not found at ${processMd}`);
+            }
+            hasMetricsSection = /^## Metrics\b/m.test(processContent);
+            sections.push(`=== Process Definition ===\n${processContent}`);
+            // Read references directory
+            const refsDir = path.join(processDir, 'references');
+            try {
+                const refFiles = await fs.readdir(refsDir);
+                for (const file of refFiles) {
+                    const refPath = path.join(refsDir, file);
+                    const stat = await fs.stat(refPath);
+                    if (stat.isFile()) {
+                        if (stat.size > FILE_SIZE_INLINE_LIMIT) {
+                            files.push({ name: file, path: refPath });
+                        }
+                        else {
+                            const content = await fs.readFile(refPath, 'utf-8');
+                            if (!sections.some(s => s.startsWith('=== References ==='))) {
+                                sections.push('=== References ===');
+                            }
+                            sections[sections.length - 1] += `\n\n--- ${file} ---\n${content}`;
+                        }
+                    }
+                }
+            }
+            catch {
+                // references dir doesn't exist, that's fine
+            }
+        }
+        else if (definition.prompt) {
+            processContent = definition.prompt;
+            hasMetricsSection = /^## Metrics\b/m.test(processContent);
+            sections.push(`=== Process Definition ===\n${processContent}`);
+        }
+        // 2. Event context
+        if (eventPayload && Object.keys(eventPayload).length > 0) {
+            sections.push(`=== Event Context ===\n${JSON.stringify(eventPayload, null, 2)}`);
+        }
+        // 3. Execution instruction
+        sections.push(this.buildExecutionInstruction(definition.name, runId, triggerType));
+        // 4. Metrics Protocol (if ## Metrics section exists in process definition)
+        if (hasMetricsSection) {
+            sections.push(this.buildMetricsProtocol(definition.name, processContent));
+        }
+        return { prompt: sections.join('\n\n'), files: files.length > 0 ? files : undefined };
+    }
+    /** Build the execution instruction telling the model to execute the process */
+    buildExecutionInstruction(processName, runId, triggerType) {
+        const triggerLabel = triggerType === 'cron' ? 'scheduled (cron)' : triggerType === 'event' ? 'event-triggered' : 'manual';
+        return `=== Execution Instruction ===
+You are executing process "${processName}" (run ID: ${runId}), triggered by ${triggerLabel}.
+
+Rules:
+- Follow the process Flow step by step
+- Respect Decision Points when conditions apply
+- Do NOT modify, create, or optimize the process definition itself — only execute it
+- Your run ID is ${runId} — use it when reporting metrics (via $LOOM_RUN_ID) or referencing this execution
+- Your session ID is available via $LOOM_SESSION_ID — use it when sending notifications to link back to this session
+- After completing all steps, summarize what was done`;
+    }
+    /** Build the Metrics Protocol injection for processes with ## Metrics section */
+    buildMetricsProtocol(processName, processContent) {
+        // Extract individual metric names from the ## Metrics section
+        const metricsSection = processContent.match(/^## Metrics\s*\n([\s\S]*?)(?=\n## |\n*$)/m)?.[1]?.trim() ?? '';
+        const metricLines = metricsSection
+            .split('\n')
+            .filter(line => /^\s*-\s*\*\*/.test(line))
+            .map(line => {
+            const match = line.match(/^\s*-\s*\*\*(.+?)\*\*/);
+            return match ? match[1].trim() : null;
+        })
+            .filter((name) => name !== null);
+        const metricList = metricLines.length > 0
+            ? `\nRequired metrics to report:\n${metricLines.map((name, i) => `${i + 1}. "${name}"`).join('\n')}\n`
+            : '';
+        return `=== Metrics Protocol ===
+This process defines business metrics. You MUST collect and report each metric value during execution.
+${metricList}
+Command to report a metric value (MUST call after computing each metric):
+   loom process metrics-report ${processName} --metric-name "指标名" --value <number> [--target <number>] [--unit "单位"] [--dimensions '{"key":"value"}']
+   - --run-id is auto-detected from $LOOM_RUN_ID environment variable
+
+Instructions:
+1. Read each metric definition in the ## Metrics section of the Process Definition above and understand what data it requires.
+2. Use \`loom data read\` to query relevant data and compute metric values.
+3. Report EACH metric using \`loom process metrics-report\` immediately after computing it — do not batch at the end.
+4. The --metric-name value MUST exactly match the bold name in the ## Metrics section (e.g., "${metricLines[0] ?? '指标名'}").`;
+    }
+    /**
+     * Consume AsyncGenerator<AIChunk> until completion or error.
+     * Timeout is handled by engine.call() internally.
+     * Returns claudeSessionId, usage, and contentBlocks for session persistence.
+     */
+    async consumeAIStream(stream) {
+        let resultSummary = '';
+        let claudeSessionId;
+        let usage;
+        let contentBlocks = [];
+        try {
+            for await (const chunk of stream) {
+                if (chunk.type === 'done') {
+                    return { success: true, timedOut: false, resultSummary: resultSummary.substring(0, 500), claudeSessionId, usage, contentBlocks };
+                }
+                if (chunk.type === 'error') {
+                    const msg = chunk.error ?? 'Unknown error';
+                    const timedOut = msg.toLowerCase().includes('timed out');
+                    return { success: false, timedOut, resultSummary: resultSummary.substring(0, 500), error: msg, claudeSessionId, usage, contentBlocks };
+                }
+                // Merge chunk into content blocks for session persistence
+                contentBlocks = mergeContentBlock(contentBlocks, chunk);
+                if (chunk.type === 'content') {
+                    const text = chunk.content ?? '';
+                    if (resultSummary.length < 500) {
+                        resultSummary += text;
+                    }
+                }
+                else if (chunk.type === 'session_info') {
+                    if (chunk.sessionId)
+                        claudeSessionId = chunk.sessionId;
+                    if (chunk.usage)
+                        usage = chunk.usage;
+                }
+            }
+            // Generator ended without 'done' — treat as success
+            return { success: true, timedOut: false, resultSummary: resultSummary.substring(0, 500), claudeSessionId, usage, contentBlocks };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const timedOut = msg.toLowerCase().includes('timed out');
+            return { success: false, timedOut, resultSummary: resultSummary.substring(0, 500), error: msg, claudeSessionId, usage, contentBlocks };
+        }
+    }
+    tryExecuteNext() {
+        while (this.queue.hasSlot()) {
+            const entry = this.queue.dequeue();
+            if (!entry)
+                break;
+            // Eagerly move to running map so getProcessStatus() sees 'running' immediately
+            this.queue.markRunningEager(entry);
+            void this.executeEntry(entry).catch(err => {
+                console.error(`[ProcessEngine] Unhandled error executing ${entry.runId}:`, err);
+            });
+        }
+    }
+    async executeEntry(entry) {
+        const definition = await this.registry.getProcess(entry.processName);
+        if (!definition) {
+            this.queue.markFailed(entry.runId, `Process "${entry.processName}" not found`);
+            return;
+        }
+        // Build prompt
+        let prompt;
+        let files;
+        try {
+            const built = await this.buildProcessPrompt(definition, entry.runId, entry.triggerType, entry.eventPayload);
+            prompt = built.prompt;
+            files = built.files;
+        }
+        catch (err) {
+            this.queue.markFailed(entry.runId, err instanceof Error ? err.message : String(err));
+            return;
+        }
+        const promptSummary = prompt.substring(0, 200);
+        // Resolve owner service token
+        let userToken;
+        if (definition.ownerToken) {
+            userToken = definition.ownerToken;
+        }
+        else if (this.authConfig && this.userStore) {
+            try {
+                const user = await this.userStore.findByUsername(definition.owner);
+                if (!user) {
+                    this.queue.markFailed(entry.runId, `Owner user "${definition.owner}" not found`);
+                    return;
+                }
+                userToken = issueServiceToken(user.userId, user.username, user.role, this.authConfig);
+            }
+            catch (err) {
+                this.queue.markFailed(entry.runId, `Failed to resolve service token: ${err instanceof Error ? err.message : String(err)}`);
+                return;
+            }
+        }
+        // Create session and mark running (each execution gets an isolated session)
+        let session;
+        try {
+            session = await this.sessionManager.createSession();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.queue.markFailed(entry.runId, `Failed to create session: ${msg}`);
+            this.tryExecuteNext();
+            return;
+        }
+        const sessionId = session.id;
+        this.queue.markRunning(entry.runId, sessionId);
+        // Persist user message to session (so the session has conversation history)
+        const userMsgId = generateId('msg');
+        const userMsg = {
+            id: userMsgId,
+            role: 'user',
+            content: prompt,
+            timestamp: new Date().toISOString(),
+        };
+        await this.sessionManager.addMessages(sessionId, [userMsg]);
+        // Write START log for crash recovery
+        const startLog = {
+            runId: entry.runId,
+            processName: entry.processName,
+            triggerType: entry.triggerType,
+            promptSummary,
+            sessionId,
+            owner: definition.owner,
+            status: 'running',
+            startedAt: new Date().toISOString(),
+            endedAt: '',
+            durationMs: 0,
+            eventPayload: entry.eventPayload,
+        };
+        await this.logger.writeLog(startLog);
+        // Emit process started event
+        this.eventBus?.emit(`process:started:${entry.processName}`, {
+            runId: entry.runId,
+            processName: entry.processName,
+            triggerType: entry.triggerType,
+            sessionId,
+        }, { source: 'server' });
+        // Execute AI call
+        const startTime = Date.now();
+        const timeout = parseDuration(this.config.executionTimeout ?? '30m');
+        try {
+            const options = {
+                sessionId,
+                resumeSessionId: session.claudeSessionId,
+                userToken,
+                timeout,
+                serverUrl: this.serverUrl,
+                processName: definition.name,
+                runId: entry.runId,
+                model: definition.model,
+            };
+            if (files && files.length > 0) {
+                options.files = files;
+            }
+            const stream = this.engine.call(prompt, options);
+            const result = await this.consumeAIStream(stream);
+            const durationMs = Date.now() - startTime;
+            const endedAt = new Date().toISOString();
+            // Persist assistant message to session (so the session has AI response history)
+            if (result.resultSummary || result.contentBlocks.length > 0) {
+                const assistantMsg = {
+                    id: `resp_${userMsgId}`,
+                    role: 'assistant',
+                    content: result.resultSummary || '(empty response)',
+                    timestamp: endedAt,
+                    ...(result.contentBlocks.length > 0 ? { contentBlocks: result.contentBlocks } : {}),
+                };
+                await this.sessionManager.addMessages(sessionId, [assistantMsg], result.claudeSessionId, result.usage);
+            }
+            else if (result.claudeSessionId || result.usage) {
+                // Even without content, update claudeSessionId/usage if available
+                await this.sessionManager.addMessages(sessionId, [], result.claudeSessionId, result.usage);
+            }
+            if (result.timedOut) {
+                // Safety net: kill session on timeout
+                if (this.engine instanceof ClaudeCodeEngine) {
+                    try {
+                        this.engine.killSession(sessionId);
+                    }
+                    catch { /* ignore */ }
+                }
+                this.queue.markTimeout(entry.runId);
+                await this.logger.writeLog({ ...startLog, status: 'timeout', endedAt, durationMs, error: result.error });
+                this.eventBus?.emit(`process:failed:${entry.processName}`, {
+                    runId: entry.runId, processName: entry.processName, error: result.error, timedOut: true, sessionId,
+                }, { source: 'server' });
+            }
+            else if (!result.success) {
+                this.queue.markFailed(entry.runId, result.error ?? 'Unknown error');
+                await this.logger.writeLog({ ...startLog, status: 'failed', endedAt, durationMs, error: result.error });
+                this.eventBus?.emit(`process:failed:${entry.processName}`, {
+                    runId: entry.runId, processName: entry.processName, error: result.error, sessionId,
+                }, { source: 'server' });
+            }
+            else {
+                this.queue.markCompleted(entry.runId);
+                await this.logger.writeLog({ ...startLog, status: 'completed', endedAt, durationMs });
+                this.eventBus?.emit(`process:completed:${entry.processName}`, {
+                    runId: entry.runId, processName: entry.processName, durationMs, sessionId,
+                }, { source: 'server' });
+            }
+        }
+        catch (err) {
+            const durationMs = Date.now() - startTime;
+            const endedAt = new Date().toISOString();
+            const error = err instanceof Error ? err.message : String(err);
+            this.queue.markFailed(entry.runId, error);
+            await this.logger.writeLog({ ...startLog, status: 'failed', endedAt, durationMs, error });
+            this.eventBus?.emit(`process:failed:${entry.processName}`, {
+                runId: entry.runId, processName: entry.processName, error, sessionId,
+            }, { source: 'server' });
+        }
+        // Try to execute next queued entry
+        this.tryExecuteNext();
+    }
+    // --- Public getters for routes ---
+    getQueueStatus() {
+        return this.queue.getQueueStatus();
+    }
+    getProcessStatus(name) {
+        const running = this.queue.getRunning().find(e => e.processName === name);
+        if (running)
+            return 'running';
+        // Check for queued entries (busy = waiting for execution slot)
+        const queued = this.queue.getQueued().find(e => e.processName === name);
+        if (queued)
+            return 'busy';
+        // Check if paused (sync lookup from registry cache)
+        const process = this.registry.getProcessSync(name);
+        if (!process)
+            return 'idle';
+        if (process.paused)
+            return 'paused';
+        return 'idle';
+    }
+    listProcesses(options) {
+        return this.registry.listProcesses(options);
+    }
+    /** Get all registry definitions (for config persistence by route layer) */
+    getRegistryDefinitions() {
+        return this.registry.getAllDefinitions();
+    }
+    getProcess(name) {
+        return this.registry.getProcess(name);
+    }
+    getRunning() {
+        return this.queue.getRunning();
+    }
+    getLogger() {
+        return this.logger;
+    }
+    async getLogs(processName, options) {
+        return this.logger.listLogs(processName, options);
+    }
+    async getLogCount(processName, options) {
+        return this.logger.countLogs(processName, options);
+    }
+    async getLog(processName, runId) {
+        return this.logger.readLog(processName, runId);
+    }
+    async getMetrics(processName) {
+        return this.logger.aggregateMetrics(processName);
+    }
+    // --- Business Metrics (agent-reported snapshots) ---
+    async reportMetric(processName, snapshot) {
+        const full = {
+            ...snapshot,
+            timestamp: snapshot.timestamp ?? new Date().toISOString(),
+        };
+        await this.metricsStore.writeSnapshot(processName, full);
+    }
+    async getMetricSnapshots(processName, options) {
+        return this.metricsStore.listSnapshots(processName, options);
+    }
+    async getMetricsViewConfig(processName) {
+        return this.metricsStore.readViewConfig(processName);
+    }
+    async setMetricsViewConfig(processName, config) {
+        await this.metricsStore.writeViewConfig(processName, config);
+    }
+    async deleteMetricsViewConfig(processName) {
+        await this.metricsStore.deleteViewConfig(processName);
+    }
+    async shutdown() {
+        this.isShutdown = true;
+        this.triggerManager.stopAll();
+        // Wait for running executions to complete (with 5s timeout)
+        const running = this.queue.getRunning();
+        if (running.length > 0) {
+            const timeout = new Promise(resolve => setTimeout(resolve, 5000));
+            await Promise.race([
+                Promise.all(running.map(async (entry) => {
+                    // Mark as failed since we're shutting down
+                    this.queue.markFailed(entry.runId, 'Server shutting down');
+                    await this.logger.writeLog({
+                        runId: entry.runId,
+                        processName: entry.processName,
+                        triggerType: entry.triggerType,
+                        promptSummary: entry.promptSummary ?? '',
+                        sessionId: entry.sessionId ?? '',
+                        owner: '',
+                        status: 'failed',
+                        startedAt: entry.startedAt ?? new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        durationMs: 0,
+                        error: 'Server shutting down',
+                    });
+                })),
+                timeout,
+            ]);
+        }
+    }
+}
+//# sourceMappingURL=engine.js.map