@supen-ai/cli 0.1.6

package/daemon/dist/core/store.js

@@ -0,0 +1,2956 @@
+/**
+ * Filesystem-based data store for Supen.
+ *
+ * Replaces SQLite (db.ts) with plain files:
+ *   - agents/{id}/agent.json        → AgentRecord
+ *   - sessions/{sid}/               → session.json + messages.jsonl
+ *   - router-state.json             → key-value pairs
+ *   - registered groups             → agent.json `sources` field (future)
+ *
+ * Design philosophy: the filesystem IS the database.
+ * See docs/data-management-design.md
+ */
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { CronExpressionParser } from 'cron-parser';
+import { AGENTS_DIR, SUPEN_HOME, TIMEZONE, getAgentModelConfig } from './config.js';
+import { computeNextAutomationRun } from './automation-timing.js';
+import { logger } from './logger.js';
+import { agentHomePaths, ensureSpaceLayout, spacePaths, spacesDir, } from './storage-paths.js';
+import { resolveTaskArtifactPaths } from './task-artifacts.js';
+const jsonlAppendDirCache = new Set();
+const getGlobalUsagePath = () => path.join(SUPEN_HOME, 'global-usage.json');
+export const AUTOMATION_TASK_AGENT_ID = 'automation-task';
+import { isValidGroupFolder } from './utils.js';
+import { assertSafePathSegment, resolveWithin } from './security.js';
+const DEFAULT_SPACE_ID = 'local';
+function defaultSpaceId() {
+    return (process.env.SUPEN_SPACE_ID || '').trim() || DEFAULT_SPACE_ID;
+}
+const AUTOMATION_STALE_EXECUTION_MS = 10 * 60 * 1000;
+const JSONL_TAIL_MAX_READ_BYTES = 16 * 1024 * 1024;
+const SESSION_UI_EVENT_RECOVERY_LIMIT = 2_000;
+const TASK_UI_EVENT_HISTORY_LIMIT = 5_000;
+// ═══════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════
+function readJson(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return undefined;
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+function appendJsonl(filePath, record) {
+    const dir = path.dirname(filePath);
+    if (!jsonlAppendDirCache.has(dir) || !fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        jsonlAppendDirCache.add(dir);
+    }
+    fs.appendFileSync(filePath, JSON.stringify(record) + '\n', 'utf-8');
+}
+function readJsonl(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return [];
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        if (!content)
+            return [];
+        return content.split('\n').map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+function listJsonFiles(dir) {
+    try {
+        if (!fs.existsSync(dir))
+            return [];
+        return fs
+            .readdirSync(dir)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => f.replace(/\.json$/, ''));
+    }
+    catch {
+        return [];
+    }
+}
+/** Read last N lines from a JSONL file (efficient tail). */
+function readJsonlTail(filePath, limit) {
+    try {
+        if (limit <= 0)
+            return [];
+        if (!fs.existsSync(filePath))
+            return [];
+        const stat = fs.statSync(filePath);
+        if (stat.size <= 0)
+            return [];
+        const fd = fs.openSync(filePath, 'r');
+        try {
+            const chunkSize = 64 * 1024;
+            let pos = stat.size;
+            let newlineCount = 0;
+            let bytesScanned = 0;
+            const chunks = [];
+            while (pos > 0 && newlineCount <= limit && bytesScanned < JSONL_TAIL_MAX_READ_BYTES) {
+                const bytesToRead = Math.min(chunkSize, pos, JSONL_TAIL_MAX_READ_BYTES - bytesScanned);
+                pos -= bytesToRead;
+                bytesScanned += bytesToRead;
+                const chunk = Buffer.allocUnsafe(bytesToRead);
+                const bytesRead = fs.readSync(fd, chunk, 0, bytesToRead, pos);
+                if (bytesRead <= 0)
+                    break;
+                const view = bytesRead === chunk.length ? chunk : chunk.subarray(0, bytesRead);
+                for (let i = 0; i < view.length; i += 1) {
+                    if (view[i] === 0x0a)
+                        newlineCount += 1;
+                }
+                chunks.unshift(view);
+            }
+            if (chunks.length === 0)
+                return [];
+            const content = Buffer.concat(chunks).toString('utf-8').trim();
+            if (!content)
+                return [];
+            const tail = content.split('\n').slice(-limit);
+            const out = [];
+            for (const line of tail) {
+                if (!line.trim())
+                    continue;
+                try {
+                    out.push(JSON.parse(line));
+                }
+                catch {
+                    // Skip malformed lines to preserve best-effort retrieval.
+                }
+            }
+            return out;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return [];
+    }
+}
+/** Read matching JSONL records from the tail until the caller has enough context. */
+function readJsonlTailMatchingUntil(filePath, matches, shouldStop) {
+    try {
+        if (!fs.existsSync(filePath))
+            return [];
+        const stat = fs.statSync(filePath);
+        if (stat.size <= 0)
+            return [];
+        const fd = fs.openSync(filePath, 'r');
+        try {
+            const chunkSize = 64 * 1024;
+            let pos = stat.size;
+            let carry = Buffer.alloc(0);
+            let bytesScanned = 0;
+            const matched = [];
+            while (pos > 0 && bytesScanned < JSONL_TAIL_MAX_READ_BYTES) {
+                const bytesToRead = Math.min(chunkSize, pos, JSONL_TAIL_MAX_READ_BYTES - bytesScanned);
+                pos -= bytesToRead;
+                bytesScanned += bytesToRead;
+                const chunk = Buffer.allocUnsafe(bytesToRead);
+                const bytesRead = fs.readSync(fd, chunk, 0, bytesToRead, pos);
+                if (bytesRead <= 0)
+                    break;
+                const view = bytesRead === chunk.length ? chunk : chunk.subarray(0, bytesRead);
+                const content = carry.length > 0 ? Buffer.concat([view, carry]) : view;
+                const lines = [];
+                let lineStart = 0;
+                for (let i = 0; i < content.length; i += 1) {
+                    if (content[i] !== 0x0a)
+                        continue;
+                    lines.push(content.subarray(lineStart, i));
+                    lineStart = i + 1;
+                }
+                lines.push(content.subarray(lineStart));
+                if (pos > 0) {
+                    carry = lines.shift() || Buffer.alloc(0);
+                }
+                else {
+                    carry = Buffer.alloc(0);
+                }
+                for (let i = lines.length - 1; i >= 0; i -= 1) {
+                    const line = lines[i]?.toString('utf-8').trim();
+                    if (!line)
+                        continue;
+                    try {
+                        const record = JSON.parse(line);
+                        if (!matches(record))
+                            continue;
+                        matched.push(record);
+                        if (shouldStop(record)) {
+                            return matched.reverse();
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines to preserve best-effort retrieval.
+                    }
+                }
+            }
+            return matched.reverse();
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return [];
+    }
+}
+function listDirs(parentDir) {
+    try {
+        if (!fs.existsSync(parentDir))
+            return [];
+        return fs
+            .readdirSync(parentDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+// Path helpers
+// ═══════════════════════════════════════════════════════════════
+function listSpaceIds() {
+    return listDirs(spacesDir());
+}
+function normalizeAgentNameValue(name, agentId) {
+    if (typeof name !== 'string')
+        return undefined;
+    const trimmed = name.trim();
+    if (!trimmed)
+        return undefined;
+    const lowered = trimmed.toLowerCase();
+    if (lowered === 'unknown' ||
+        lowered === 'undefined' ||
+        lowered === 'null' ||
+        lowered === 'n/a' ||
+        lowered === 'none') {
+        return undefined;
+    }
+    if (trimmed === agentId)
+        return agentId;
+    return trimmed;
+}
+function normalizeAgentRecord(record) {
+    const normalizedName = normalizeAgentNameValue(record.name, record.agent_id) || record.agent_id;
+    return {
+        ...record,
+        name: normalizedName,
+        space_id: record.space_id || defaultSpaceId(),
+        skills: record.skills || { mode: 'all', allowed: ['*'] },
+    };
+}
+function resolveAgentRecord(agentId) {
+    const home = agentHomePaths(agentId);
+    const record = readJson(home.config);
+    if (!record)
+        return undefined;
+    return {
+        record,
+        baseDir: home.base,
+        configPath: home.config,
+    };
+}
+function findAgentRecord(agentId) {
+    const resolved = resolveAgentRecord(agentId);
+    return resolved ? normalizeAgentRecord(resolved.record) : undefined;
+}
+export function getAgentStorage(agentId) {
+    const resolved = resolveAgentRecord(agentId);
+    if (!resolved)
+        return undefined;
+    return {
+        agent: normalizeAgentRecord(resolved.record),
+        baseDir: resolved.baseDir,
+        configPath: resolved.configPath,
+    };
+}
+function agentDir(agentId) {
+    const resolved = resolveAgentRecord(agentId);
+    if (resolved)
+        return resolved.baseDir;
+    return agentHomePaths(agentId).base;
+}
+function agentJsonPath(agentId) {
+    const resolved = resolveAgentRecord(agentId);
+    if (resolved)
+        return resolved.configPath;
+    return agentHomePaths(agentId).config;
+}
+function sessionsRootDir() {
+    return path.join(SUPEN_HOME, 'sessions');
+}
+function archivedSessionsRootDir() {
+    return path.join(SUPEN_HOME, 'archived_sessions');
+}
+function rootSessionDir(sessionId) {
+    const safeSessionId = assertSafePathSegment(sessionId, 'session_id');
+    return resolveWithin(sessionsRootDir(), safeSessionId);
+}
+function rootArchivedSessionDir(sessionId) {
+    const safeSessionId = assertSafePathSegment(sessionId, 'session_id');
+    return resolveWithin(archivedSessionsRootDir(), safeSessionId);
+}
+function sessionDir(agentId, sessionId) {
+    assertSafePathSegment(agentId, 'agent_id');
+    return rootSessionDir(sessionId);
+}
+function resolveSessionDir(agentId, sessionId) {
+    assertSafePathSegment(agentId, 'agent_id');
+    const livePath = rootSessionDir(sessionId);
+    if (fs.existsSync(livePath)) {
+        return livePath;
+    }
+    const archivedPath = rootArchivedSessionDir(sessionId);
+    if (fs.existsSync(archivedPath)) {
+        return archivedPath;
+    }
+    return sessionDir(agentId, sessionId);
+}
+function sessionJsonPath(agentId, sessionId) {
+    return path.join(resolveSessionDir(agentId, sessionId), 'session.json');
+}
+function messagesPath(agentId, sessionId) {
+    return path.join(resolveSessionDir(agentId, sessionId), 'messages.jsonl');
+}
+function taskMetadataDir(sessionId, taskId) {
+    if (!taskId || !taskId.trim())
+        return null;
+    return path.join(resolveTaskArtifactPaths(sessionId, taskId).taskRoot, '.supen');
+}
+function taskUiEventsPath(sessionId, taskId) {
+    const dir = taskMetadataDir(sessionId, taskId);
+    return dir ? path.join(dir, 'events.jsonl') : null;
+}
+function taskMetadataPath(sessionId, taskId) {
+    const dir = taskMetadataDir(sessionId, taskId);
+    return dir ? path.join(dir, 'task.json') : null;
+}
+function writeTaskMetadata(agentId, sessionId, taskId) {
+    const metadataPath = taskMetadataPath(sessionId, taskId);
+    if (!metadataPath || fs.existsSync(metadataPath))
+        return;
+    writeJson(metadataPath, {
+        agent_id: agentId,
+        session_id: sessionId,
+        task_id: taskId,
+    });
+}
+function listTaskUiEventsForSession(agentId, sessionId, limit = TASK_UI_EVENT_HISTORY_LIMIT) {
+    const tasksRoot = spacePaths('local').tasks;
+    const events = [];
+    const boundedLimit = Math.max(1, limit);
+    for (const taskFolder of listDirs(tasksRoot)) {
+        const metadataDir = path.join(tasksRoot, taskFolder, '.supen');
+        const metadata = readJson(path.join(metadataDir, 'task.json'));
+        if (metadata?.agent_id !== agentId || metadata.session_id !== sessionId)
+            continue;
+        events.push(...readJsonlTail(path.join(metadataDir, 'events.jsonl'), boundedLimit));
+    }
+    return events
+        .sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')))
+        .slice(-boundedLimit);
+}
+function automationsDir() {
+    return path.join(SUPEN_HOME, 'automations');
+}
+function automationDir(automationId) {
+    const safeAutomationId = assertSafePathSegment(automationId, 'automation_id');
+    return resolveWithin(automationsDir(), safeAutomationId);
+}
+function automationJsonPath(automationId) {
+    return path.join(automationDir(automationId), 'automation.json');
+}
+function automationStateJsonPath(automationId) {
+    return path.join(automationDir(automationId), 'state.json');
+}
+function automationRunsDir(automationId) {
+    return resolveWithin(automationDir(automationId), 'runs');
+}
+function automationRunJsonPath(automationId, runId) {
+    const safeRunId = assertSafePathSegment(runId, 'automation_run_id');
+    return resolveWithin(automationRunsDir(automationId), `${safeRunId}.json`);
+}
+function automationEventsDir(automationId) {
+    return resolveWithin(automationDir(automationId), 'events');
+}
+function automationEventJsonPath(automationId, eventId) {
+    const safeEventId = assertSafePathSegment(eventId, 'automation_event_id');
+    return resolveWithin(automationEventsDir(automationId), `${safeEventId}.json`);
+}
+function automationTaskId(automationId) {
+    return `task-automation-${automationId}`;
+}
+function automationChatJid(agentId, sessionId) {
+    return agentId === AUTOMATION_TASK_AGENT_ID
+        ? `task:${sessionId}`
+        : `web:${agentId}:${sessionId}`;
+}
+const getRouterStatePath = () => path.join(SUPEN_HOME, 'router-state.json');
+const getRegisteredGroupsPath = () => path.join(SUPEN_HOME, 'registered-groups.json');
+// ═══════════════════════════════════════════════════════════════
+// Init (no-op — dirs created on demand)
+// ═══════════════════════════════════════════════════════════════
+export function initStore() {
+    fs.mkdirSync(AGENTS_DIR, { recursive: true });
+    fs.mkdirSync(sessionsRootDir(), { recursive: true });
+    fs.mkdirSync(archivedSessionsRootDir(), { recursive: true });
+    fs.mkdirSync(spacesDir(), { recursive: true });
+    logger.info({ dir: AGENTS_DIR }, 'Store initialized (filesystem)');
+}
+// ═══════════════════════════════════════════════════════════════
+// Agents
+// ═══════════════════════════════════════════════════════════════
+export function ensureAgent(input) {
+    const existing = resolveAgentRecord(input.agent_id);
+    const now = new Date().toISOString();
+    const incomingName = normalizeAgentNameValue(input.name, input.agent_id);
+    if (existing) {
+        const existingName = normalizeAgentNameValue(existing.record.name, existing.record.agent_id) ||
+            existing.record.agent_id;
+        const updated = {
+            ...existing.record,
+            ...(existing.record.space_id || input.space_id
+                ? { space_id: existing.record.space_id || input.space_id || defaultSpaceId() }
+                : {}),
+            name: incomingName || existingName,
+            tags: input.tags || existing.record.tags,
+            channels: input.channels || existing.record.channels,
+            skills: input.skills || existing.record.skills,
+            updated_at: now,
+        };
+        writeJson(existing.configPath, updated);
+        return normalizeAgentRecord(updated);
+    }
+    const spaceId = input.space_id || defaultSpaceId();
+    ensureSpaceLayout(spaceId);
+    const record = {
+        agent_id: input.agent_id,
+        space_id: spaceId,
+        name: incomingName || input.agent_id,
+        tags: input.tags,
+        channels: input.channels,
+        skills: input.skills || { mode: 'all', allowed: ['*'] },
+        created_at: now,
+        updated_at: now,
+    };
+    writeJson(agentHomePaths(input.agent_id).config, record);
+    return record;
+}
+export function createAgent(input) {
+    if (findAgentRecord(input.agent_id)) {
+        throw new Error(`Agent "${input.agent_id}" already exists`);
+    }
+    const spaceId = input.space_id || defaultSpaceId();
+    ensureSpaceLayout(spaceId);
+    const now = new Date().toISOString();
+    const record = {
+        agent_id: input.agent_id,
+        space_id: spaceId,
+        name: input.name || input.agent_id,
+        tags: input.tags,
+        channels: input.channels,
+        skills: input.skills || { mode: 'all', allowed: ['*'] },
+        created_at: now,
+        updated_at: now,
+    };
+    writeJson(agentHomePaths(input.agent_id).config, record);
+    return record;
+}
+export function updateAgent(agentId, updates) {
+    const existing = resolveAgentRecord(agentId);
+    if (!existing)
+        return undefined;
+    const now = new Date().toISOString();
+    const updated = {
+        ...existing.record,
+        ...updates,
+        agent_id: existing.record.agent_id,
+        created_at: existing.record.created_at,
+        ...(existing.record.space_id || updates.space_id
+            ? {
+                space_id: typeof updates.space_id === 'string' && updates.space_id.trim()
+                    ? updates.space_id
+                    : existing.record.space_id || defaultSpaceId(),
+            }
+            : {}),
+        updated_at: now,
+    };
+    writeJson(existing.configPath, updated);
+    return normalizeAgentRecord(updated);
+}
+export function deleteAgent(agentId) {
+    const dir = agentDir(agentId);
+    if (!fs.existsSync(dir))
+        return false;
+    fs.rmSync(dir, { recursive: true, force: true });
+    return true;
+}
+export function getAgent(agentId) {
+    return findAgentRecord(agentId);
+}
+export function getAllAgents() {
+    const agents = [];
+    for (const agentId of listDirs(AGENTS_DIR)) {
+        const record = readJson(agentHomePaths(agentId).config);
+        if (record)
+            agents.push(normalizeAgentRecord(record));
+    }
+    return agents.sort((a, b) => (b.updated_at || '').localeCompare(a.updated_at || ''));
+}
+// ═══════════════════════════════════════════════════════════════
+// Sessions
+// ═══════════════════════════════════════════════════════════════
+export function ensureSession(input) {
+    const existingAgent = findAgentRecord(input.agent_id);
+    const resolvedSpaceId = input.space_id || existingAgent?.space_id || defaultSpaceId();
+    ensureAgent({
+        agent_id: input.agent_id,
+        name: input.agent_name,
+        space_id: resolvedSpaceId,
+    });
+    const jsonPath = sessionJsonPath(input.agent_id, input.session_id);
+    const existing = readJson(jsonPath);
+    const now = new Date().toISOString();
+    const normalizedCreatedAt = typeof input.created_at === 'string' && input.created_at.trim()
+        ? input.created_at
+        : now;
+    const normalizedUpdatedAt = typeof input.updated_at === 'string' && input.updated_at.trim()
+        ? input.updated_at
+        : undefined;
+    if (existing) {
+        const existingSpaceId = existing.space_id || resolvedSpaceId;
+        const nextSpaceId = input.space_id ||
+            (existingSpaceId === DEFAULT_SPACE_ID && resolvedSpaceId !== DEFAULT_SPACE_ID
+                ? resolvedSpaceId
+                : existingSpaceId);
+        const nextChannel = input.channel;
+        const nextChannelSession = input.channel_session ?? existing.channel_session;
+        const nextBackendDriverId = input.backend_driver_id || existing.backend_driver_id;
+        const nextSourceRef = input.source_ref || existing.source_ref;
+        const nextKnowledgeId = input.knowledge_id || existing.knowledge_id;
+        const nextKnowledgeName = input.knowledge_name || existing.knowledge_name;
+        const nextEnvironmentId = input.environment_id || existing.environment_id;
+        const nextEnvironmentSnapshot = input.environment_snapshot || existing.environment_snapshot;
+        const nextTaskWorkspaceFolder = input.task_workspace_folder ?? existing.task_workspace_folder;
+        const nextTitle = existing.title || input.title?.trim() || undefined;
+        const nextStatus = input.status || existing.status;
+        const changed = nextSpaceId !== existing.space_id ||
+            nextChannel !== existing.channel ||
+            nextChannelSession !== existing.channel_session ||
+            nextBackendDriverId !== existing.backend_driver_id ||
+            nextSourceRef !== existing.source_ref ||
+            nextKnowledgeId !== existing.knowledge_id ||
+            nextKnowledgeName !== existing.knowledge_name ||
+            nextEnvironmentId !== existing.environment_id ||
+            JSON.stringify(nextEnvironmentSnapshot ?? null) !== JSON.stringify(existing.environment_snapshot ?? null) ||
+            nextTaskWorkspaceFolder !== existing.task_workspace_folder ||
+            nextTitle !== existing.title ||
+            nextStatus !== existing.status;
+        const updated = {
+            ...existing,
+            space_id: nextSpaceId,
+            channel: nextChannel,
+            channel_session: nextChannelSession,
+            backend_driver_id: nextBackendDriverId,
+            source_ref: nextSourceRef,
+            knowledge_id: nextKnowledgeId,
+            knowledge_name: nextKnowledgeName,
+            environment_id: nextEnvironmentId,
+            environment_snapshot: nextEnvironmentSnapshot,
+            task_workspace_folder: nextTaskWorkspaceFolder,
+            title: nextTitle,
+            status: nextStatus,
+            updated_at: normalizedUpdatedAt || (changed ? now : existing.updated_at),
+        };
+        if (changed || normalizedUpdatedAt) {
+            writeJson(jsonPath, updated);
+        }
+        return updated;
+    }
+    const record = {
+        session_id: input.session_id,
+        agent_id: input.agent_id,
+        space_id: resolvedSpaceId,
+        channel: input.channel,
+        channel_session: input.channel_session,
+        backend_driver_id: input.backend_driver_id,
+        source_ref: input.source_ref,
+        knowledge_id: input.knowledge_id,
+        knowledge_name: input.knowledge_name,
+        environment_id: input.environment_id,
+        environment_snapshot: input.environment_snapshot,
+        task_workspace_folder: input.task_workspace_folder ?? null,
+        title: input.title?.trim() || undefined,
+        status: input.status || 'idle',
+        created_at: normalizedCreatedAt,
+        updated_at: normalizedUpdatedAt || normalizedCreatedAt,
+    };
+    writeJson(jsonPath, record);
+    return record;
+}
+export function getSession(sessionId) {
+    return (readJson(path.join(rootSessionDir(sessionId), 'session.json')) ||
+        readJson(path.join(rootArchivedSessionDir(sessionId), 'session.json')));
+}
+export function getSessionForAgent(agentId, sessionId) {
+    const session = readJson(sessionJsonPath(agentId, sessionId));
+    return session?.agent_id === agentId ? session : undefined;
+}
+function ensureAutomationTasksForAgent(agentId) {
+    for (const automation of listAutomations(agentId)) {
+        ensureAutomationTask(automation);
+    }
+}
+export function getSessionsForAgent(agentId) {
+    ensureAutomationTasksForAgent(agentId);
+    const sessions = [];
+    const sessionsBase = sessionsRootDir();
+    if (fs.existsSync(sessionsBase)) {
+        for (const sid of listDirs(sessionsBase)) {
+            const session = readJson(path.join(sessionsBase, sid, 'session.json'));
+            if (session?.agent_id === agentId)
+                sessions.push(session);
+        }
+    }
+    return sessions.sort((a, b) => (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || ''));
+}
+function touchSessionActivity(agentId, sessionId, timestamp = new Date().toISOString()) {
+    const jsonPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(jsonPath);
+    if (!session)
+        return;
+    const nextUpdatedAt = Number.isNaN(new Date(timestamp).getTime())
+        ? new Date().toISOString()
+        : timestamp;
+    if (session.updated_at && session.updated_at > nextUpdatedAt)
+        return;
+    session.space_id = session.space_id || DEFAULT_SPACE_ID;
+    session.updated_at = nextUpdatedAt;
+    writeJson(jsonPath, session);
+}
+export function getArchivedSessionsForAgent(agentId) {
+    const sessionsBase = archivedSessionsRootDir();
+    const sessions = [];
+    if (fs.existsSync(sessionsBase)) {
+        for (const sid of listDirs(sessionsBase)) {
+            const jsonPath = path.join(sessionsBase, sid, 'session.json');
+            const session = readJson(jsonPath);
+            if (session?.agent_id === agentId) {
+                sessions.push({ ...session, status: 'archived' });
+            }
+        }
+    }
+    return sessions.sort((a, b) => (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || ''));
+}
+export function getAllSessions() {
+    const sessions = [];
+    for (const sid of listDirs(sessionsRootDir())) {
+        const session = readJson(path.join(sessionsRootDir(), sid, 'session.json'));
+        if (session)
+            sessions.push(session);
+    }
+    return sessions.sort((a, b) => {
+        const cmp = a.agent_id.localeCompare(b.agent_id);
+        return cmp !== 0 ? cmp : a.session_id.localeCompare(b.session_id);
+    });
+}
+export function ensureAutomationTask(automation) {
+    const taskId = automation.task_id || automationTaskId(automation.id);
+    const agentId = automation.kind === 'event'
+        ? AUTOMATION_TASK_AGENT_ID
+        : automation.agent_id;
+    const session = ensureSession({
+        agent_id: agentId,
+        session_id: taskId,
+        channel: 'automation',
+        source_ref: `automation:${automation.id}`,
+        title: automation.name,
+        task_workspace_folder: automation.cwds?.[0] ?? null,
+    });
+    if (session.agent_id !== agentId) {
+        const updated = {
+            ...session,
+            agent_id: agentId,
+            channel: 'automation',
+            source_ref: `automation:${automation.id}`,
+            updated_at: new Date().toISOString(),
+        };
+        ensureAgent({ agent_id: agentId, name: agentId === AUTOMATION_TASK_AGENT_ID ? 'Automation Task' : undefined });
+        writeJson(sessionJsonPath(agentId, taskId), updated);
+        return updated;
+    }
+    return session;
+}
+export function automationExecutionIdentity(automationId) {
+    return `supen-automation:${automationId}`;
+}
+function automationRunContextPath(automationId, runId) {
+    const safeRunId = assertSafePathSegment(runId, 'automation_run_id');
+    return resolveWithin(automationRunsDir(automationId), `${safeRunId}.context.json`);
+}
+export function writeAutomationRunContext(input) {
+    const memoryPath = path.join(automationDir(input.automation.id), 'memory.md');
+    const executionIdentity = automationExecutionIdentity(input.automation.id);
+    const contextPath = automationRunContextPath(input.automation.id, input.runId);
+    writeJson(contextPath, {
+        version: 1,
+        kind: input.kind,
+        generated_at: input.nowIso,
+        automation: {
+            id: input.automation.id,
+            name: input.automation.name,
+            execution_identity: executionIdentity,
+            prompt: input.automation.prompt,
+            action: input.automation.action ?? null,
+            trigger: input.automation.trigger ?? null,
+            memory_path: memoryPath,
+            previous_triggered_at: input.previousTriggeredAt ?? null,
+            model: input.automation.model ?? null,
+            permission_mode: input.automation.permission_mode ?? null,
+            network_access: input.automation.network_access === true,
+            cwds: input.automation.cwds ?? [],
+        },
+        run: {
+            id: input.runId,
+        },
+        event: input.eventEnvelope ?? null,
+    });
+    return contextPath;
+}
+function readTemplatePath(root, pathExpression) {
+    const segments = pathExpression
+        .split('.')
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    let current = root;
+    for (const segment of segments) {
+        if (!current || typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function stringifyTemplateValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return JSON.stringify(value);
+}
+export function renderAutomationActionCommand(command, eventEnvelope) {
+    const root = {
+        event: eventEnvelope ?? null,
+        payload: eventEnvelope && typeof eventEnvelope.payload === 'object'
+            ? eventEnvelope.payload
+            : null,
+    };
+    return command.replace(/\{\{\s*([a-zA-Z0-9_.]+)\s*\}\}/g, (_match, pathExpression) => stringifyTemplateValue(readTemplatePath(root, String(pathExpression))));
+}
+export function buildAutomationRunChatMessage(input) {
+    const rawCommand = input.automation.action?.command?.trim();
+    const command = rawCommand?.startsWith('/')
+        ? renderAutomationActionCommand(rawCommand, input.eventEnvelope).trim()
+        : '';
+    const opening = command || 'Please execute the automation described in the context file.';
+    return [
+        opening,
+        '',
+        `Automation context file: ${input.contextPath}`,
+        `Automation id: ${input.automation.id}`,
+        `Run id: ${input.runId}`,
+        'Read the context JSON file before acting. Execute exactly once.',
+        'Use the event payload in that context when present. Do not ask for repeated instructions.',
+    ].join('\n');
+}
+export function buildAutomationTriggerMessage(input) {
+    const taskId = input.automation.task_id ||
+        automationTaskId(input.automation.id);
+    const memoryPath = path.join(automationDir(input.automation.id), 'memory.md');
+    const lastRun = input.previousTriggeredAt || 'never';
+    const executionIdentity = automationExecutionIdentity(input.automation.id);
+    const runId = input.runId || crypto.randomUUID();
+    const contextPath = writeAutomationRunContext({
+        automation: input.automation,
+        runId,
+        kind: 'scheduled',
+        nowIso: input.nowIso,
+        previousTriggeredAt: input.previousTriggeredAt,
+    });
+    const content = buildAutomationRunChatMessage({
+        automation: input.automation,
+        runId,
+        contextPath,
+    });
+    return {
+        id: crypto.randomUUID(),
+        chat_jid: automationChatJid(input.automation.agent_id, taskId),
+        sender: 'system',
+        sender_name: 'Automation',
+        content,
+        timestamp: input.nowIso,
+        is_from_me: false,
+        agent_id: input.automation.agent_id,
+        session_id: taskId,
+        task_id: taskId,
+        automation_id: input.automation.id,
+        automation_run_id: runId,
+        model: input.automation.model,
+        metadata: {
+            origin: 'automation',
+            automation_id: input.automation.id,
+            automation_name: input.automation.name,
+            automation_execution_identity: executionIdentity,
+            automation_memory_path: memoryPath,
+            automation_context_path: contextPath,
+            automation_last_run: lastRun,
+            automation_prompt: input.automation.prompt,
+            runtime_options: {
+                ...(input.automation.permission_mode
+                    ? { permissionMode: input.automation.permission_mode }
+                    : {}),
+                ...(input.automation.network_access ? { networkAccess: true } : {}),
+            },
+        },
+    };
+}
+export function updateSessionStatus(agentId, sessionId, status) {
+    const jsonPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(jsonPath);
+    if (session) {
+        session.space_id = session.space_id || DEFAULT_SPACE_ID;
+        session.status = status;
+        session.updated_at = new Date().toISOString();
+        writeJson(jsonPath, session);
+    }
+}
+export function updateSessionSdkId(agentId, sessionId, sdkSessionId) {
+    const jsonPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(jsonPath);
+    if (session) {
+        session.space_id = session.space_id || DEFAULT_SPACE_ID;
+        session.sdk_session_id = sdkSessionId;
+        session.updated_at = new Date().toISOString();
+        writeJson(jsonPath, session);
+    }
+}
+export function clearSessionSdkId(agentId, sessionId) {
+    const jsonPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(jsonPath);
+    if (session) {
+        session.space_id = session.space_id || DEFAULT_SPACE_ID;
+        delete session.sdk_session_id;
+        session.updated_at = new Date().toISOString();
+        writeJson(jsonPath, session);
+    }
+}
+export function updateSessionBackendDriverId(agentId, sessionId, backendDriverId) {
+    const jsonPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(jsonPath);
+    if (session) {
+        session.space_id = session.space_id || DEFAULT_SPACE_ID;
+        session.backend_driver_id = backendDriverId;
+        session.updated_at = new Date().toISOString();
+        writeJson(jsonPath, session);
+    }
+}
+export function updateSessionUsage(agentId, sessionId, tokensIn, tokensOut) {
+    const now = new Date().toISOString();
+    // 1. Update Session Usage
+    const sessPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(sessPath);
+    if (session) {
+        session.space_id = session.space_id || DEFAULT_SPACE_ID;
+        session.tokens_in = (session.tokens_in || 0) + tokensIn;
+        session.tokens_out = (session.tokens_out || 0) + tokensOut;
+        session.updated_at = now;
+        writeJson(sessPath, session);
+    }
+    // 2. Update Agent Usage (Aggregate)
+    const aPath = agentJsonPath(agentId);
+    const agent = readJson(aPath);
+    if (agent) {
+        agent.tokens_in = (agent.tokens_in || 0) + tokensIn;
+        agent.tokens_out = (agent.tokens_out || 0) + tokensOut;
+        agent.updated_at = now;
+        writeJson(aPath, agent);
+    }
+    appendGlobalUsage(agentId, sessionId, tokensIn, tokensOut);
+}
+export function appendGlobalUsage(agentId, sessionId, tokensIn, tokensOut) {
+    const now = new Date().toISOString();
+    // This ensures deletion of agents/sessions does not impact the historical total.
+    try {
+        const today = now.split('T')[0];
+        const models = getAgentModelConfig(agentId, true);
+        const modelId = models.length > 0 ? models[0].id : 'unknown';
+        const rawLedger = readJson(getGlobalUsagePath());
+        let ledger;
+        if (!rawLedger || typeof rawLedger.total !== 'object') {
+            ledger = {
+                total: {
+                    tokens_in: rawLedger?.tokens_in || 0,
+                    tokens_out: rawLedger?.tokens_out || 0,
+                    estimated_cost_usd: rawLedger?.estimated_cost_usd || 0,
+                    updated_at: rawLedger?.updated_at || now,
+                },
+                daily: {},
+            };
+        }
+        else {
+            ledger = rawLedger;
+        }
+        const increment = getUsageStats({
+            tokens_in: tokensIn,
+            tokens_out: tokensOut,
+            agent_id: agentId,
+        });
+        if (!ledger.daily)
+            ledger.daily = {};
+        if (!ledger.daily[today]) {
+            ledger.daily[today] = {
+                total: { tokens_in: 0, tokens_out: 0, estimated_cost_usd: 0 },
+                models: {},
+            };
+        }
+        const day = ledger.daily[today];
+        if (!day.models[modelId]) {
+            day.models[modelId] = {
+                total: { tokens_in: 0, tokens_out: 0, estimated_cost_usd: 0 },
+                sessions: {},
+            };
+        }
+        const model = day.models[modelId];
+        if (!model.sessions[sessionId]) {
+            model.sessions[sessionId] = {
+                agent_id: agentId,
+                tokens_in: 0,
+                tokens_out: 0,
+                estimated_cost_usd: 0,
+            };
+        }
+        const sessionEntry = model.sessions[sessionId];
+        const applyIncrement = (target) => {
+            target.tokens_in += tokensIn;
+            target.tokens_out += tokensOut;
+            target.tokens_total = (target.tokens_in || 0) + (target.tokens_out || 0);
+            target.estimated_cost_usd = Number((target.estimated_cost_usd + increment.estimated_cost_usd).toFixed(6));
+        };
+        applyIncrement(ledger.total);
+        ledger.total.updated_at = now;
+        applyIncrement(day.total);
+        applyIncrement(model.total);
+        applyIncrement(sessionEntry);
+        writeJson(getGlobalUsagePath(), ledger);
+    }
+    catch (e) {
+        logger.warn({
+            error: e,
+            message: e instanceof Error ? e.message : String(e),
+            stack: e instanceof Error ? e.stack : undefined,
+        }, 'Failed to update global usage file');
+    }
+}
+export function getUsageStats(record) {
+    const tokens_in = record.tokens_in || 0;
+    const tokens_out = record.tokens_out || 0;
+    let estimated_cost_usd = 0;
+    if (record.agent_id) {
+        const models = getAgentModelConfig(record.agent_id, true);
+        const model = models.length > 0 ? models[0] : null;
+        if (model?.pricing) {
+            estimated_cost_usd =
+                (tokens_in / 1_000_000) * (model.pricing.input_usd_per_1m || 0) +
+                    (tokens_out / 1_000_000) * (model.pricing.output_usd_per_1m || 0);
+        }
+    }
+    return {
+        tokens_in,
+        tokens_out,
+        tokens_total: tokens_in + tokens_out,
+        estimated_cost_usd: Number(estimated_cost_usd.toFixed(6)),
+    };
+}
+/** Get global usage across all agents and sessions. */
+export function getGlobalUsage() {
+    const ledger = readJson(getGlobalUsagePath());
+    if (ledger && ledger.total) {
+        return {
+            tokens_in: ledger.total.tokens_in,
+            tokens_out: ledger.total.tokens_out,
+            tokens_total: ledger.total.tokens_in + ledger.total.tokens_out,
+            estimated_cost_usd: ledger.total.estimated_cost_usd,
+        };
+    }
+    // Fallback: calculate from current agents (migration path)
+    let tokens_in = 0;
+    let tokens_out = 0;
+    let total_cost = 0;
+    for (const agent of getAllAgents()) {
+        const stats = getUsageStats(agent);
+        tokens_in += stats.tokens_in;
+        tokens_out += stats.tokens_out;
+        total_cost += stats.estimated_cost_usd;
+    }
+    return {
+        tokens_in,
+        tokens_out,
+        tokens_total: tokens_in + tokens_out,
+        estimated_cost_usd: Number(total_cost.toFixed(6)),
+    };
+}
+/** Get the full detailed daily usage ledger. */
+export function getDailyUsage() {
+    const ledger = readJson(getGlobalUsagePath());
+    return ledger?.daily || {};
+}
+/**
+ * Reset sessions stuck as "running" — called at startup to recover from crashes.
+ * A "running" session cannot survive a process restart, so these are stale.
+ */
+export function cleanupStaleSessions() {
+    let cleaned = 0;
+    for (const agentId of listDirs(AGENTS_DIR)) {
+        for (const session of getSessionsForAgent(agentId)) {
+            if (session.status === 'running') {
+                finalizeInterruptedSessionUiStream(agentId, session.session_id);
+                updateSessionStatus(agentId, session.session_id, 'idle');
+                cleaned++;
+                logger.info({ agentId, sessionId: session.session_id }, 'Reset stale running session to idle');
+            }
+        }
+    }
+    return cleaned;
+}
+function finalizeInterruptedSessionUiStream(agentId, sessionId) {
+    const events = getSessionUiEvents(agentId, sessionId, SESSION_UI_EVENT_RECOVERY_LIMIT);
+    if (events.length === 0)
+        return;
+    let openTaskId;
+    let messageOpen = false;
+    let stepOpen = false;
+    const openTextIds = new Set();
+    const openReasoningIds = new Set();
+    for (const event of events) {
+        const chunk = event.chunk;
+        if (!chunk || typeof chunk !== 'object')
+            continue;
+        const type = typeof chunk.type === 'string' ? chunk.type : '';
+        if (type === 'start') {
+            messageOpen = true;
+            stepOpen = false;
+            openTaskId = event.task_id;
+            openTextIds.clear();
+            openReasoningIds.clear();
+            continue;
+        }
+        if (!messageOpen)
+            continue;
+        if (type === 'start-step') {
+            stepOpen = true;
+            continue;
+        }
+        if (type === 'finish-step') {
+            stepOpen = false;
+            continue;
+        }
+        if (type === 'text-start') {
+            openTextIds.add(String(chunk.id || 'text-default'));
+            continue;
+        }
+        if (type === 'text-end') {
+            openTextIds.delete(String(chunk.id || 'text-default'));
+            continue;
+        }
+        if (type === 'reasoning-start') {
+            openReasoningIds.add(String(chunk.id || 'reasoning-default'));
+            continue;
+        }
+        if (type === 'reasoning-end') {
+            openReasoningIds.delete(String(chunk.id || 'reasoning-default'));
+            continue;
+        }
+        if (type === 'finish' || type === 'error') {
+            messageOpen = false;
+            stepOpen = false;
+            openTaskId = undefined;
+            openTextIds.clear();
+            openReasoningIds.clear();
+        }
+    }
+    if (!messageOpen)
+        return;
+    const timestamp = new Date().toISOString();
+    const taskId = openTaskId || `stale-${Date.now()}`;
+    const chunks = [
+        ...Array.from(openTextIds).map((id) => ({ type: 'text-end', id })),
+        ...Array.from(openReasoningIds).map((id) => ({ type: 'reasoning-end', id })),
+        ...(stepOpen ? [{ type: 'finish-step' }] : []),
+        {
+            type: 'error',
+            errorText: 'Response interrupted because the server restarted before this turn finished.',
+        },
+        { type: 'finish', finishReason: 'error' },
+    ];
+    chunks.forEach((chunk, index) => {
+        storeSessionUiEvent(agentId, sessionId, {
+            id: `${taskId}:stale-interrupted:${timestamp}:${index}`,
+            timestamp,
+            task_id: taskId,
+            chunk,
+        });
+    });
+}
+export function updateSessionMetadata(agentId, sessionId, updates) {
+    const jsonPath = sessionJsonPath(agentId, sessionId);
+    const session = readJson(jsonPath);
+    if (!session)
+        return false;
+    session.space_id = session.space_id || DEFAULT_SPACE_ID;
+    if (updates.title !== undefined)
+        session.title = updates.title;
+    if (updates.knowledge_id !== undefined)
+        session.knowledge_id = updates.knowledge_id;
+    if (updates.knowledge_name !== undefined)
+        session.knowledge_name = updates.knowledge_name;
+    session.updated_at = new Date().toISOString();
+    writeJson(jsonPath, session);
+    return true;
+}
+export function archiveSessionForAgent(agentId, sessionId) {
+    const dir = sessionDir(agentId, sessionId);
+    if (!fs.existsSync(dir))
+        return false;
+    const session = readJson(path.join(dir, 'session.json'));
+    if (session && session.agent_id !== agentId)
+        return false;
+    const archiveDir = archivedSessionsRootDir();
+    fs.mkdirSync(archiveDir, { recursive: true });
+    const targetDir = rootArchivedSessionDir(sessionId);
+    if (fs.existsSync(targetDir))
+        return false; // already archived
+    fs.renameSync(dir, targetDir);
+    deleteSchedulesForSession(agentId, sessionId);
+    return true;
+}
+function deleteSchedulesForSession(agentId, sessionId) {
+    if (sessionId.startsWith('sched-')) {
+        deleteSchedule(sessionId.slice(6));
+    }
+    else {
+        const schedules = getSchedulesForAgent(agentId);
+        for (const s of schedules) {
+            if (s.target_jid && s.target_jid.endsWith(':' + sessionId)) {
+                deleteSchedule(s.id);
+            }
+        }
+    }
+}
+export function restoreSessionForAgent(agentId, sessionId) {
+    const archivePath = rootArchivedSessionDir(sessionId);
+    if (!fs.existsSync(archivePath))
+        return false;
+    const restoreDir = sessionDir(agentId, sessionId);
+    fs.mkdirSync(path.dirname(restoreDir), { recursive: true });
+    if (fs.existsSync(restoreDir))
+        return false;
+    fs.renameSync(archivePath, restoreDir);
+    return true;
+}
+export function deleteSession(sessionId) {
+    const liveDir = rootSessionDir(sessionId);
+    if (fs.existsSync(liveDir)) {
+        fs.rmSync(liveDir, { recursive: true, force: true });
+        return;
+    }
+    const archivedDir = rootArchivedSessionDir(sessionId);
+    if (fs.existsSync(archivedDir)) {
+        fs.rmSync(archivedDir, { recursive: true, force: true });
+        return;
+    }
+}
+export function deleteSessionForAgent(agentId, sessionId, fromArchived = false) {
+    const dir = fromArchived
+        ? rootArchivedSessionDir(sessionId)
+        : sessionDir(agentId, sessionId);
+    if (!fs.existsSync(dir))
+        return false;
+    const session = readJson(path.join(dir, 'session.json'));
+    if (session && session.agent_id !== agentId)
+        return false;
+    fs.rmSync(dir, { recursive: true, force: true });
+    deleteSchedulesForSession(agentId, sessionId);
+    return true;
+}
+/** Convert internal JSONL format → NewMessage for API compatibility */
+function storedToNewMessage(m, chatJid) {
+    return {
+        id: m.id,
+        chat_jid: chatJid,
+        task_id: m.task_id,
+        sender: m.sender || 'unknown',
+        sender_name: m.sender_name || 'Unknown',
+        content: m.text,
+        timestamp: m.ts,
+        is_from_me: m.is_from_me ?? m.role === 'bot',
+        is_bot_message: m.role === 'bot',
+        attachments: m.attachments,
+        model: m.model,
+        metadata: m.metadata,
+        automation_id: m.automation_id,
+        automation_run_id: m.automation_run_id,
+        automation_notify_target_jid: m.automation_notify_target_jid,
+        automation_notify_policy: m.automation_notify_policy,
+        schedule_id: m.schedule_id,
+        schedule_run_id: m.schedule_run_id,
+        schedule_notify_target_jid: m.schedule_notify_target_jid,
+        schedule_notify_policy: m.schedule_notify_policy,
+    };
+}
+/** Resolve agent+session from chat_jid (format: "web:agent_id:session_id" or similar). */
+export function resolveFromChatJid(chatJid) {
+    const taskMatch = chatJid.match(/^task:(.+)$/);
+    if (taskMatch) {
+        return { agentId: AUTOMATION_TASK_AGENT_ID, sessionId: taskMatch[1] };
+    }
+    // web:agent_id:session_id
+    const webMatch = chatJid.match(/^web:(.+?):(.+)$/);
+    if (webMatch)
+        return { agentId: webMatch[1], sessionId: webMatch[2] };
+    // acp:agent_id:session_id
+    const acpMatch = chatJid.match(/^acp:(.+?):(.+)$/);
+    if (acpMatch)
+        return { agentId: acpMatch[1], sessionId: acpMatch[2] };
+    // gateway:agent_id:session_id
+    const gatewayMatch = chatJid.match(/^gateway:(.+?):(.+)$/);
+    if (gatewayMatch)
+        return { agentId: gatewayMatch[1], sessionId: gatewayMatch[2] };
+    // feishu:app_id:chat_id
+    const feishuMatch = chatJid.match(/^feishu:(.+?):(.+)$/);
+    if (feishuMatch)
+        return { agentId: feishuMatch[1], sessionId: feishuMatch[2] };
+    // For other channels, try to find the session across agents
+    for (const sid of listDirs(sessionsRootDir())) {
+        const session = readJson(path.join(sessionsRootDir(), sid, 'session.json'));
+        if (session?.source_ref === chatJid) {
+            return { agentId: session.agent_id, sessionId: session.session_id };
+        }
+    }
+    return null;
+}
+export function storeMessage(msg) {
+    // Determine agent_id and session_id
+    let agentId = msg.agent_id;
+    let sessionId = msg.session_id;
+    if (!agentId || !sessionId) {
+        const resolved = resolveFromChatJid(msg.chat_jid);
+        if (resolved) {
+            agentId = agentId || resolved.agentId;
+            sessionId = sessionId || resolved.sessionId;
+        }
+    }
+    if (!agentId || !sessionId) {
+        logger.warn({ chat_jid: msg.chat_jid }, 'Cannot store message: unable to resolve agent/session from chat_jid');
+        return;
+    }
+    const channelSession = typeof msg.metadata?.channel_thread === 'string'
+        ? msg.metadata.channel_thread
+        : typeof msg.metadata?.channel_session === 'string'
+            ? msg.metadata.channel_session
+            : undefined;
+    if (channelSession) {
+        const existingSession = getSessionForAgent(agentId, sessionId);
+        if (existingSession) {
+            ensureSession({
+                agent_id: agentId,
+                session_id: sessionId,
+                channel: existingSession.channel,
+                channel_session: channelSession,
+                source_ref: existingSession.source_ref || msg.chat_jid,
+            });
+        }
+    }
+    // Ensure session directory exists
+    const msgPath = messagesPath(agentId, sessionId);
+    const stored = {
+        id: msg.id,
+        ts: msg.timestamp,
+        role: msg.is_bot_message ? 'bot' : 'user',
+        task_id: msg.task_id,
+        sender: msg.sender,
+        sender_name: msg.sender_name,
+        text: msg.content,
+        is_from_me: msg.is_from_me,
+        attachments: msg.attachments,
+        model: msg.model,
+        metadata: msg.metadata,
+        automation_id: msg.automation_id,
+        automation_run_id: msg.automation_run_id,
+        automation_notify_target_jid: msg.automation_notify_target_jid,
+        automation_notify_policy: msg.automation_notify_policy,
+        schedule_id: msg.schedule_id,
+        schedule_run_id: msg.schedule_run_id,
+        schedule_notify_target_jid: msg.schedule_notify_target_jid,
+        schedule_notify_policy: msg.schedule_notify_policy,
+    };
+    appendJsonl(msgPath, stored);
+    touchSessionActivity(agentId, sessionId, msg.timestamp);
+}
+/** Alias for storeMessage — both had identical implementations in db.ts */
+export const storeMessageDirect = storeMessage;
+export function getRecentMessages(chatJid, limit = 10) {
+    const resolved = resolveFromChatJid(chatJid);
+    if (!resolved)
+        return [];
+    const messages = readJsonlTail(messagesPath(resolved.agentId, resolved.sessionId), limit);
+    return messages.map((m) => storedToNewMessage(m, chatJid));
+}
+export function getMessagesSince(chatJid, sinceTimestamp, _botPrefix) {
+    const resolved = resolveFromChatJid(chatJid);
+    if (!resolved)
+        return [];
+    const all = readJsonl(messagesPath(resolved.agentId, resolved.sessionId));
+    return all
+        .filter((m) => {
+        const isNew = m.ts > sinceTimestamp;
+        const isNotBot = m.role !== 'bot';
+        const hasText = m.text && m.text.trim() !== '';
+        const keep = isNew && isNotBot && hasText;
+        logger.debug({
+            msgId: m.id,
+            role: m.role,
+            text: m.text,
+            isNew,
+            isNotBot,
+            hasText,
+            keep,
+        }, 'getMessagesSince: filtering message');
+        return keep;
+    })
+        .map((m) => storedToNewMessage(m, chatJid));
+}
+export function getNewMessages(jids, lastTimestamp, botPrefix) {
+    if (jids.length === 0)
+        return { messages: [], newTimestamp: lastTimestamp };
+    let newTimestamp = lastTimestamp;
+    const messages = [];
+    for (const jid of jids) {
+        const msgs = getMessagesSince(jid, lastTimestamp, botPrefix);
+        for (const m of msgs) {
+            messages.push(m);
+            if (m.timestamp > newTimestamp)
+                newTimestamp = m.timestamp;
+        }
+    }
+    messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return { messages, newTimestamp };
+}
+// ═══════════════════════════════════════════════════════════════
+// Automations
+// ═══════════════════════════════════════════════════════════════
+export class AutomationInputError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'AutomationInputError';
+        this.code = code;
+    }
+}
+export class ScheduleInputError extends AutomationInputError {
+    constructor(code, message) {
+        super(code, message);
+        this.name = 'ScheduleInputError';
+    }
+}
+function normalizeAutomationTimestamp(value, fieldName) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new AutomationInputError(`missing_${fieldName}`, `${fieldName} is required`);
+    }
+    const parsed = new Date(trimmed);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new AutomationInputError(`invalid_${fieldName}`, `${fieldName} must be a valid ISO timestamp`);
+    }
+    return parsed.toISOString();
+}
+function normalizeOptionalAutomationTimestamp(value, fieldName) {
+    if (value == null)
+        return null;
+    return normalizeAutomationTimestamp(value, fieldName);
+}
+function validateAutomationCounter(name, value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new AutomationInputError(`invalid_${name}`, `${name} must be a non-negative integer`);
+    }
+}
+function buildAutomationResultPreview(text) {
+    const trimmed = text?.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.length <= 280 ? trimmed : `${trimmed.slice(0, 277)}...`;
+}
+const ONE_SHOT_RRULE = 'FREQ=MINUTELY;COUNT=1';
+function isRRuleExpression(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim().toUpperCase();
+    return trimmed.startsWith('FREQ=') || trimmed.startsWith('RRULE:');
+}
+function computeCronNextRun(cron, currentDate) {
+    try {
+        const interval = CronExpressionParser.parse(cron, {
+            tz: TIMEZONE,
+            currentDate,
+        });
+        return interval.next().toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+function computeScheduleExpressionNextRun(expression, timezone, currentDate) {
+    if (isRRuleExpression(expression)) {
+        return computeNextAutomationRun({
+            rrule: expression,
+            timezone,
+            currentDate,
+        });
+    }
+    return computeCronNextRun(expression, currentDate);
+}
+function computeScheduleExpressionNextRunOrThrow(input) {
+    const nextRun = computeScheduleExpressionNextRun(input.expression, input.timezone, input.currentDate);
+    if (!nextRun) {
+        throw new AutomationInputError(isRRuleExpression(input.expression) ? 'invalid_rrule' : 'invalid_cron', 'schedule expression must produce a valid next_run');
+    }
+    return nextRun;
+}
+function computeAutomationNextRunOrThrow(input) {
+    const nextRun = computeNextAutomationRun(input);
+    if (!nextRun) {
+        throw new AutomationInputError('invalid_rrule', 'rrule and timezone must produce a valid next_run');
+    }
+    return nextRun;
+}
+function computeStoredAutomationNextRun(automation, currentDate) {
+    if (automation.kind !== 'calendar')
+        return null;
+    const expression = automation.rrule;
+    if (!expression?.trim())
+        return null;
+    if (!automation.timezone?.trim())
+        return null;
+    return computeScheduleExpressionNextRun(expression, automation.timezone, currentDate);
+}
+function requireObjectRecord(value, field) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new AutomationInputError(`invalid_${field}`, `${field} must be an object`);
+    }
+    return value;
+}
+function requireStringValue(value, field) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new AutomationInputError(`missing_${field}`, `${field} is required`);
+    }
+    return value.trim();
+}
+function normalizeEventAutomationTrigger(trigger) {
+    const triggerRecord = requireObjectRecord(trigger, 'trigger');
+    const connection = requireObjectRecord(triggerRecord.connection, 'trigger_connection');
+    const subscription = requireObjectRecord(triggerRecord.subscription, 'trigger_subscription');
+    const type = requireStringValue(triggerRecord.type, 'trigger_type');
+    if (type !== 'supabase') {
+        throw new AutomationInputError('invalid_trigger_type', 'trigger.type must be supabase');
+    }
+    const source = typeof triggerRecord.source === 'string' && triggerRecord.source.trim()
+        ? triggerRecord.source.trim()
+        : 'postgres_changes';
+    if (source !== 'postgres_changes') {
+        throw new AutomationInputError('invalid_trigger_source', 'trigger.source must be postgres_changes');
+    }
+    const event = requireStringValue(subscription.event, 'trigger_subscription_event').toUpperCase();
+    if (!['*', 'INSERT', 'UPDATE', 'DELETE'].includes(event)) {
+        throw new AutomationInputError('invalid_trigger_subscription_event', 'trigger.subscription.event must be one of: *, INSERT, UPDATE, DELETE');
+    }
+    return {
+        type: 'supabase',
+        source,
+        connection: {
+            url_env: requireStringValue(connection.url_env, 'trigger_connection_url_env'),
+            key_env: requireStringValue(connection.key_env, 'trigger_connection_key_env'),
+        },
+        subscription: {
+            schema: requireStringValue(subscription.schema, 'trigger_subscription_schema'),
+            table: requireStringValue(subscription.table, 'trigger_subscription_table'),
+            event: event,
+            ...(typeof subscription.filter === 'string' && subscription.filter.trim()
+                ? { filter: subscription.filter.trim() }
+                : {}),
+        },
+    };
+}
+function normalizeEventAutomationAction(action, defaultPrompt) {
+    const actionRecord = action
+        ? requireObjectRecord(action, 'action')
+        : { type: 'skill', command: defaultPrompt };
+    const type = requireStringValue(actionRecord.type, 'action_type');
+    if (type !== 'skill') {
+        throw new AutomationInputError('invalid_action_type', 'action.type must be skill');
+    }
+    return {
+        type: 'skill',
+        command: requireStringValue(actionRecord.command ?? defaultPrompt, 'action_command'),
+    };
+}
+function normalizeAutomationRecord(automation) {
+    const id = assertSafePathSegment(automation.id, 'automation_id');
+    const taskId = typeof automation.task_id === 'string' && automation.task_id.trim()
+        ? assertSafePathSegment(automation.task_id.trim(), 'task_id')
+        : automationTaskId(id);
+    const kind = automation.kind === 'event' ? 'event' : 'calendar';
+    const agentId = kind === 'event'
+        ? AUTOMATION_TASK_AGENT_ID
+        : automation.agent_id.trim();
+    const normalized = {
+        ...automation,
+        version: 2,
+        id,
+        kind,
+        name: automation.name.trim(),
+        agent_id: agentId,
+        prompt: automation.prompt.trim(),
+        task_id: taskId,
+        status: automation.status === 'PAUSED' ? 'PAUSED' : 'ACTIVE',
+        ...(kind === 'calendar'
+            ? {
+                rrule: automation.rrule?.trim(),
+                timezone: automation.timezone?.trim(),
+                exdate: automation.exdate?.filter(Boolean),
+                trigger: undefined,
+                action: undefined,
+            }
+            : {
+                trigger: normalizeEventAutomationTrigger(automation.trigger),
+                action: normalizeEventAutomationAction(automation.action, automation.prompt),
+                rrule: undefined,
+                timezone: undefined,
+                exdate: undefined,
+            }),
+        network_access: automation.network_access === true,
+        last_triggered_at: automation.last_triggered_at ?? null,
+        last_message_id: automation.last_message_id ?? null,
+    };
+    return normalized;
+}
+function normalizeAutomationStateRecord(state) {
+    return {
+        ...state,
+        execution_status: state.execution_status ?? 'idle',
+        claimed_at: state.claimed_at ?? null,
+        started_at: state.started_at ?? null,
+        next_run: state.next_run ?? null,
+        last_run: state.last_run ?? null,
+        pending_event_count: state.pending_event_count ?? 0,
+        pending_event_at: state.pending_event_at ?? null,
+        pending_event_payload: state.pending_event_payload ?? null,
+        last_result_preview: state.last_result_preview ?? null,
+        last_error: state.last_error ?? null,
+        run_count: state.run_count ?? 0,
+        failure_count: state.failure_count ?? 0,
+    };
+}
+function normalizeAutomationRunRecord(run) {
+    return {
+        ...run,
+        claimed_at: run.claimed_at ?? null,
+        started_at: run.started_at ?? null,
+        finished_at: run.finished_at ?? null,
+        result_preview: run.result_preview ?? null,
+        full_result: run.full_result ?? null,
+        error: run.error ?? null,
+        no_op_detected: run.no_op_detected ?? false,
+        no_op_reason: run.no_op_reason ?? null,
+        notification_sent: run.notification_sent ?? false,
+    };
+}
+function normalizeAutomationEventRecord(event) {
+    const receivedAt = normalizeAutomationTimestamp(event.received_at, 'received_at');
+    return {
+        event_id: assertSafePathSegment(event.event_id, 'automation_event_id'),
+        automation_id: assertSafePathSegment(event.automation_id, 'automation_id'),
+        status: event.status === 'running' || event.status === 'succeeded' || event.status === 'failed'
+            ? event.status
+            : 'queued',
+        payload: event.payload && typeof event.payload === 'object' ? event.payload : {},
+        received_at: receivedAt,
+        claimed_at: normalizeOptionalAutomationTimestamp(event.claimed_at, 'claimed_at'),
+        finished_at: normalizeOptionalAutomationTimestamp(event.finished_at, 'finished_at'),
+        run_id: event.run_id ? assertSafePathSegment(event.run_id, 'automation_run_id') : null,
+        error: event.error ?? null,
+        created_at: event.created_at
+            ? normalizeAutomationTimestamp(event.created_at, 'created_at')
+            : receivedAt,
+        updated_at: event.updated_at
+            ? normalizeAutomationTimestamp(event.updated_at, 'updated_at')
+            : receivedAt,
+    };
+}
+function isStaleAutomationExecution(executionStatus, marker, nowMs) {
+    if (!marker)
+        return false;
+    if (executionStatus !== 'running' && executionStatus !== 'claimed')
+        return false;
+    const startedMs = new Date(marker).getTime();
+    if (Number.isNaN(startedMs))
+        return false;
+    return nowMs - startedMs >= AUTOMATION_STALE_EXECUTION_MS;
+}
+function getAutomationBundle(automationId) {
+    const automation = readJson(automationJsonPath(automationId));
+    if (!automation)
+        return undefined;
+    const state = readJson(automationStateJsonPath(automationId));
+    if (!state) {
+        throw new AutomationInputError('missing_state', `Automation state is missing for ${automationId}`);
+    }
+    return {
+        automation: normalizeAutomationRecord(automation),
+        state: normalizeAutomationStateRecord(state),
+    };
+}
+function locateAutomationRun(runId) {
+    for (const automationId of listDirs(automationsDir())) {
+        const run = readJson(automationRunJsonPath(automationId, runId));
+        if (run) {
+            return {
+                automationId,
+                run: normalizeAutomationRunRecord(run),
+            };
+        }
+    }
+    return undefined;
+}
+export function getAutomationRunById(runId) {
+    return locateAutomationRun(runId)?.run;
+}
+export function createAutomation(input) {
+    if (!input.agent_id?.trim()) {
+        throw new AutomationInputError('missing_agent_id', 'agent_id is required');
+    }
+    if (!input.name?.trim()) {
+        throw new AutomationInputError('missing_name', 'name is required');
+    }
+    if (!input.prompt?.trim()) {
+        throw new AutomationInputError('missing_prompt', 'prompt is required');
+    }
+    if (!input.rrule?.trim()) {
+        throw new AutomationInputError('missing_rrule', 'rrule is required');
+    }
+    if (!input.timezone?.trim()) {
+        throw new AutomationInputError('missing_timezone', 'timezone is required');
+    }
+    ensureAgent({ agent_id: input.agent_id });
+    const id = crypto.randomUUID();
+    const taskId = automationTaskId(id);
+    const now = Date.now();
+    const status = input.status ?? 'ACTIVE';
+    const nextRun = input.next_run !== undefined
+        ? normalizeOptionalAutomationTimestamp(input.next_run, 'next_run')
+        : status === 'ACTIVE'
+            ? computeAutomationNextRunOrThrow({
+                rrule: input.rrule,
+                timezone: input.timezone,
+            })
+            : null;
+    const automation = normalizeAutomationRecord({
+        version: 2,
+        id,
+        kind: 'calendar',
+        name: input.name.trim(),
+        agent_id: input.agent_id.trim(),
+        task_id: taskId,
+        prompt: input.prompt.trim(),
+        status,
+        rrule: input.rrule.trim(),
+        timezone: input.timezone.trim(),
+        exdate: input.exdate?.filter(Boolean),
+        session_mode: input.session_mode,
+        model: input.model,
+        reasoning_effort: input.reasoning_effort,
+        permission_mode: input.permission_mode,
+        network_access: input.network_access === true,
+        execution_environment: input.execution_environment,
+        cwds: input.cwds?.filter(Boolean),
+        last_triggered_at: null,
+        last_message_id: null,
+        created_at: now,
+        updated_at: now,
+    });
+    const state = normalizeAutomationStateRecord({
+        automation_id: id,
+        execution_status: 'idle',
+        claimed_at: null,
+        started_at: null,
+        next_run: nextRun,
+        last_run: null,
+        last_result_preview: null,
+        last_error: null,
+        run_count: 0,
+        failure_count: 0,
+        updated_at: now,
+    });
+    writeJson(automationJsonPath(id), automation);
+    writeJson(automationStateJsonPath(id), state);
+    ensureAutomationTask(automation);
+    return automation;
+}
+export function createEventAutomation(input) {
+    if (!input.name?.trim()) {
+        throw new AutomationInputError('missing_name', 'name is required');
+    }
+    if (!input.prompt?.trim()) {
+        throw new AutomationInputError('missing_prompt', 'prompt is required');
+    }
+    ensureAgent({ agent_id: AUTOMATION_TASK_AGENT_ID, name: 'Automation Task' });
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const automation = normalizeAutomationRecord({
+        version: 2,
+        id,
+        kind: 'event',
+        name: input.name.trim(),
+        agent_id: AUTOMATION_TASK_AGENT_ID,
+        task_id: automationTaskId(id),
+        prompt: input.prompt.trim(),
+        status: input.status ?? 'ACTIVE',
+        trigger: input.trigger,
+        action: input.action,
+        permission_mode: input.permission_mode,
+        network_access: input.network_access === true,
+        execution_environment: input.execution_environment,
+        cwds: input.cwds?.filter(Boolean),
+        last_triggered_at: null,
+        last_message_id: null,
+        created_at: now,
+        updated_at: now,
+    });
+    const state = normalizeAutomationStateRecord({
+        automation_id: id,
+        execution_status: 'idle',
+        claimed_at: null,
+        started_at: null,
+        next_run: null,
+        last_run: null,
+        last_result_preview: null,
+        last_error: null,
+        run_count: 0,
+        failure_count: 0,
+        updated_at: now,
+    });
+    writeJson(automationJsonPath(id), automation);
+    writeJson(automationStateJsonPath(id), state);
+    ensureAutomationTask(automation);
+    return automation;
+}
+export function getAutomationById(id) {
+    const automation = readJson(automationJsonPath(id));
+    return automation ? normalizeAutomationRecord(automation) : undefined;
+}
+export function getAutomationState(id) {
+    const state = readJson(automationStateJsonPath(id));
+    return state ? normalizeAutomationStateRecord(state) : undefined;
+}
+export function listAutomations(agentId) {
+    const records = [];
+    for (const automationId of listDirs(automationsDir())) {
+        const automation = getAutomationById(automationId);
+        if (!automation)
+            continue;
+        if (agentId && automation.agent_id !== agentId)
+            continue;
+        records.push(automation);
+    }
+    return records.sort((left, right) => right.updated_at - left.updated_at);
+}
+export function updateAutomation(id, updates) {
+    const bundle = getAutomationBundle(id);
+    if (!bundle)
+        return undefined;
+    if (updates.name !== undefined && !updates.name.trim()) {
+        throw new AutomationInputError('missing_name', 'name is required');
+    }
+    if (updates.prompt !== undefined && !updates.prompt.trim()) {
+        throw new AutomationInputError('missing_prompt', 'prompt is required');
+    }
+    const now = Date.now();
+    const automation = normalizeAutomationRecord({
+        ...bundle.automation,
+        ...(updates.kind !== undefined ? { kind: updates.kind } : {}),
+        ...(updates.name !== undefined ? { name: updates.name.trim() } : {}),
+        ...(updates.prompt !== undefined ? { prompt: updates.prompt.trim() } : {}),
+        ...(updates.rrule !== undefined ? { rrule: updates.rrule.trim() } : {}),
+        ...(updates.timezone !== undefined ? { timezone: updates.timezone.trim() } : {}),
+        ...(updates.exdate !== undefined ? { exdate: updates.exdate.filter(Boolean) } : {}),
+        ...(updates.status !== undefined ? { status: updates.status } : {}),
+        ...(updates.session_mode !== undefined ? { session_mode: updates.session_mode } : {}),
+        ...(updates.model !== undefined ? { model: updates.model } : {}),
+        ...(updates.reasoning_effort !== undefined
+            ? { reasoning_effort: updates.reasoning_effort }
+            : {}),
+        ...(updates.permission_mode !== undefined
+            ? { permission_mode: updates.permission_mode }
+            : {}),
+        ...(updates.network_access !== undefined
+            ? { network_access: updates.network_access === true }
+            : {}),
+        ...(updates.execution_environment !== undefined
+            ? { execution_environment: updates.execution_environment }
+            : {}),
+        ...(updates.cwds !== undefined ? { cwds: updates.cwds.filter(Boolean) } : {}),
+        ...(updates.trigger !== undefined ? { trigger: updates.trigger } : {}),
+        ...(updates.action !== undefined ? { action: updates.action } : {}),
+        updated_at: now,
+    });
+    const hasNextRunUpdate = Object.prototype.hasOwnProperty.call(updates, 'next_run');
+    const isCalendarAutomation = automation.kind === 'calendar';
+    const scheduleExpressionChanged = isCalendarAutomation && (updates.rrule !== undefined || updates.timezone !== undefined);
+    const wasPaused = bundle.automation.status === 'PAUSED';
+    const isActive = automation.status === 'ACTIVE';
+    let nextRun = bundle.state.next_run;
+    if (!isCalendarAutomation) {
+        nextRun = null;
+    }
+    else if (hasNextRunUpdate) {
+        nextRun = normalizeOptionalAutomationTimestamp(updates.next_run, 'next_run');
+    }
+    else if (!isActive) {
+        nextRun = null;
+    }
+    if (isCalendarAutomation &&
+        isActive &&
+        (scheduleExpressionChanged || wasPaused || nextRun === null) &&
+        (!hasNextRunUpdate || nextRun === null)) {
+        nextRun = computeAutomationNextRunOrThrow({
+            rrule: automation.rrule || '',
+            timezone: automation.timezone || '',
+        });
+    }
+    const state = normalizeAutomationStateRecord({
+        ...bundle.state,
+        next_run: nextRun,
+        updated_at: now,
+    });
+    writeJson(automationJsonPath(id), automation);
+    writeJson(automationStateJsonPath(id), state);
+    return automation;
+}
+export function updateAutomationState(id, updates) {
+    const bundle = getAutomationBundle(id);
+    if (!bundle)
+        return undefined;
+    if (updates.run_count !== undefined) {
+        validateAutomationCounter('run_count', updates.run_count);
+    }
+    if (updates.failure_count !== undefined) {
+        validateAutomationCounter('failure_count', updates.failure_count);
+    }
+    if (updates.pending_event_count !== undefined) {
+        validateAutomationCounter('pending_event_count', updates.pending_event_count);
+    }
+    const state = normalizeAutomationStateRecord({
+        ...bundle.state,
+        ...(updates.execution_status !== undefined
+            ? { execution_status: updates.execution_status }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'claimed_at')
+            ? {
+                claimed_at: normalizeOptionalAutomationTimestamp(updates.claimed_at, 'claimed_at'),
+            }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'started_at')
+            ? {
+                started_at: normalizeOptionalAutomationTimestamp(updates.started_at, 'started_at'),
+            }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'next_run')
+            ? {
+                next_run: normalizeOptionalAutomationTimestamp(updates.next_run, 'next_run'),
+            }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'last_run')
+            ? {
+                last_run: normalizeOptionalAutomationTimestamp(updates.last_run, 'last_run'),
+            }
+            : {}),
+        ...(updates.pending_event_count !== undefined
+            ? { pending_event_count: updates.pending_event_count }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'pending_event_at')
+            ? {
+                pending_event_at: normalizeOptionalAutomationTimestamp(updates.pending_event_at, 'pending_event_at'),
+            }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'pending_event_payload')
+            ? { pending_event_payload: updates.pending_event_payload ?? null }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'last_result_preview')
+            ? { last_result_preview: updates.last_result_preview ?? null }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'last_error')
+            ? { last_error: updates.last_error ?? null }
+            : {}),
+        ...(updates.run_count !== undefined ? { run_count: updates.run_count } : {}),
+        ...(updates.failure_count !== undefined
+            ? { failure_count: updates.failure_count }
+            : {}),
+        updated_at: Date.now(),
+    });
+    writeJson(automationStateJsonPath(id), state);
+    return state;
+}
+export function markAutomationTriggered(input) {
+    const bundle = getAutomationBundle(input.automationId);
+    if (!bundle)
+        return undefined;
+    const nextRun = bundle.automation.status === 'ACTIVE'
+        ? computeStoredAutomationNextRun(bundle.automation, input.triggeredAt)
+        : null;
+    const automation = updateAutomation(input.automationId, {
+        next_run: nextRun,
+    });
+    if (!automation)
+        return undefined;
+    const updated = normalizeAutomationRecord({
+        ...automation,
+        last_triggered_at: input.triggeredAt,
+        last_message_id: input.messageId,
+        updated_at: Date.now(),
+    });
+    writeJson(automationJsonPath(input.automationId), updated);
+    const state = input.keepExecutionStatus ? getAutomationState(input.automationId) : undefined;
+    updateAutomationState(input.automationId, {
+        execution_status: input.keepExecutionStatus
+            ? state?.execution_status ?? 'idle'
+            : 'idle',
+        claimed_at: input.keepExecutionStatus ? state?.claimed_at ?? null : null,
+        started_at: input.keepExecutionStatus ? state?.started_at ?? null : null,
+        next_run: nextRun,
+        last_run: input.triggeredAt,
+    });
+    if (automation.kind === 'calendar' && automation.status === 'ACTIVE' && nextRun === null) {
+        updateAutomation(input.automationId, { status: 'PAUSED' });
+    }
+    return updated;
+}
+export function deleteAutomation(id) {
+    const dir = automationDir(id);
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    const sessionId = `sched-${id}`;
+    for (const agentId of listDirs(AGENTS_DIR)) {
+        deleteSessionForAgent(agentId, sessionId);
+        deleteSessionForAgent(agentId, sessionId, true);
+    }
+}
+export function createAutomationRun(automationId, input = {}) {
+    const bundle = getAutomationBundle(automationId);
+    if (!bundle) {
+        throw new AutomationInputError('missing_automation', `Automation not found: ${automationId}`);
+    }
+    const runId = crypto.randomUUID();
+    const triggeredAt = input.triggered_at !== undefined
+        ? normalizeAutomationTimestamp(input.triggered_at, 'triggered_at')
+        : new Date().toISOString();
+    const claimedAt = input.claimed_at !== undefined
+        ? normalizeOptionalAutomationTimestamp(input.claimed_at, 'claimed_at')
+        : bundle.state.claimed_at;
+    const startedAt = input.started_at !== undefined
+        ? normalizeOptionalAutomationTimestamp(input.started_at, 'started_at')
+        : triggeredAt;
+    const run = normalizeAutomationRunRecord({
+        run_id: runId,
+        automation_id: bundle.automation.id,
+        agent_id: bundle.automation.agent_id,
+        status: 'running',
+        triggered_at: triggeredAt,
+        claimed_at: claimedAt,
+        started_at: startedAt,
+        finished_at: null,
+        session_id: input.session_id,
+        task_id: input.task_id,
+        prompt: bundle.automation.prompt,
+        model: bundle.automation.model,
+        reasoning_effort: bundle.automation.reasoning_effort,
+        cwd: input.cwd ?? bundle.automation.cwds?.[0],
+        result_preview: null,
+        full_result: null,
+        error: null,
+        no_op_detected: false,
+        no_op_reason: null,
+        notification_sent: false,
+        created_at: triggeredAt,
+        updated_at: triggeredAt,
+    });
+    writeJson(automationRunJsonPath(automationId, runId), run);
+    updateAutomationState(automationId, {
+        execution_status: 'running',
+        claimed_at: claimedAt,
+        started_at: startedAt,
+        next_run: computeStoredAutomationNextRun(bundle.automation, startedAt ?? undefined),
+        pending_event_count: 0,
+        pending_event_at: null,
+        pending_event_payload: null,
+    });
+    return run;
+}
+export function touchAutomationRun(automationRunId, now = new Date().toISOString()) {
+    const located = locateAutomationRun(automationRunId);
+    if (!located)
+        return false;
+    const updated = normalizeAutomationRunRecord({
+        ...located.run,
+        updated_at: normalizeAutomationTimestamp(now, 'updated_at'),
+    });
+    writeJson(automationRunJsonPath(located.automationId, automationRunId), updated);
+    return true;
+}
+export function enqueueAutomationEvent(input) {
+    const automation = getAutomationById(input.automationId);
+    if (!automation) {
+        throw new AutomationInputError('missing_automation', `Automation not found: ${input.automationId}`);
+    }
+    let receivedAt = normalizeAutomationTimestamp(input.receivedAt ?? new Date().toISOString(), 'received_at');
+    const latestExistingEvent = listAutomationEvents({
+        automation_id: automation.id,
+        limit: 10_000,
+    }).at(-1);
+    const latestExistingMs = Date.parse(latestExistingEvent?.received_at || '');
+    const receivedAtMs = Date.parse(receivedAt);
+    if (Number.isFinite(latestExistingMs) &&
+        Number.isFinite(receivedAtMs) &&
+        latestExistingMs >= receivedAtMs) {
+        receivedAt = new Date(latestExistingMs + 1).toISOString();
+    }
+    const event = normalizeAutomationEventRecord({
+        event_id: crypto.randomUUID(),
+        automation_id: automation.id,
+        status: 'queued',
+        payload: input.payload,
+        received_at: receivedAt,
+        claimed_at: null,
+        finished_at: null,
+        run_id: null,
+        error: null,
+        created_at: receivedAt,
+        updated_at: receivedAt,
+    });
+    writeJson(automationEventJsonPath(automation.id, event.event_id), event);
+    const queuedEvents = listAutomationEvents({
+        automation_id: automation.id,
+        status: 'queued',
+        limit: 10_000,
+    });
+    updateAutomationState(automation.id, {
+        pending_event_count: queuedEvents.length,
+        pending_event_at: queuedEvents.at(0)?.received_at ?? receivedAt,
+        pending_event_payload: queuedEvents.at(0)?.payload ?? input.payload,
+    });
+    return event;
+}
+export function listAutomationEvents(input) {
+    const automationId = assertSafePathSegment(input.automation_id, 'automation_id');
+    const dir = automationEventsDir(automationId);
+    if (!fs.existsSync(dir))
+        return [];
+    const events = [];
+    for (const file of fs.readdirSync(dir)) {
+        if (!file.endsWith('.json'))
+            continue;
+        const event = readJson(automationEventJsonPath(automationId, file.replace(/\.json$/, '')));
+        if (!event)
+            continue;
+        const normalized = normalizeAutomationEventRecord(event);
+        if (input.status && normalized.status !== input.status)
+            continue;
+        events.push(normalized);
+    }
+    const limit = typeof input.limit === 'number' && Number.isFinite(input.limit) && input.limit > 0
+        ? Math.floor(input.limit)
+        : 100;
+    return events
+        .sort((left, right) => {
+        const byReceived = left.received_at.localeCompare(right.received_at);
+        return byReceived !== 0 ? byReceived : left.event_id.localeCompare(right.event_id);
+    })
+        .slice(0, limit);
+}
+export function claimNextAutomationEvent(input) {
+    const queued = listAutomationEvents({
+        automation_id: input.automationId,
+        status: 'queued',
+        limit: 1,
+    })[0];
+    if (!queued)
+        return undefined;
+    const claimedAt = normalizeAutomationTimestamp(input.claimedAt ?? new Date().toISOString(), 'claimed_at');
+    const updated = normalizeAutomationEventRecord({
+        ...queued,
+        status: 'running',
+        claimed_at: claimedAt,
+        run_id: input.runId,
+        updated_at: claimedAt,
+    });
+    writeJson(automationEventJsonPath(input.automationId, queued.event_id), updated);
+    const remainingQueued = listAutomationEvents({
+        automation_id: input.automationId,
+        status: 'queued',
+        limit: 10_000,
+    });
+    updateAutomationState(input.automationId, {
+        pending_event_count: remainingQueued.length,
+        pending_event_at: remainingQueued.at(0)?.received_at ?? null,
+        pending_event_payload: remainingQueued.at(0)?.payload ?? null,
+    });
+    return updated;
+}
+export function finalizeAutomationEventForRun(runId, input) {
+    for (const automationId of listDirs(automationsDir())) {
+        for (const event of listAutomationEvents({ automation_id: automationId, limit: 10_000 })) {
+            if (event.run_id !== runId)
+                continue;
+            const finishedAt = normalizeAutomationTimestamp(input.finishedAt ?? new Date().toISOString(), 'finished_at');
+            const updated = normalizeAutomationEventRecord({
+                ...event,
+                status: input.status,
+                finished_at: finishedAt,
+                error: input.status === 'failed' ? input.error ?? 'Automation event failed' : null,
+                updated_at: finishedAt,
+            });
+            writeJson(automationEventJsonPath(automationId, event.event_id), updated);
+            return updated;
+        }
+    }
+    return undefined;
+}
+export function requeueAutomationEventForRun(runId, now = new Date().toISOString()) {
+    for (const automationId of listDirs(automationsDir())) {
+        for (const event of listAutomationEvents({ automation_id: automationId, limit: 10_000 })) {
+            if (event.run_id !== runId || event.status !== 'running')
+                continue;
+            const nowIso = normalizeAutomationTimestamp(now, 'updated_at');
+            const updated = normalizeAutomationEventRecord({
+                ...event,
+                status: 'queued',
+                claimed_at: null,
+                run_id: null,
+                error: null,
+                updated_at: nowIso,
+            });
+            writeJson(automationEventJsonPath(automationId, event.event_id), updated);
+            return updated;
+        }
+    }
+    return undefined;
+}
+export function finalizeAutomationRun(runId, input) {
+    const located = locateAutomationRun(runId);
+    if (!located)
+        return undefined;
+    const finishedAt = normalizeAutomationTimestamp(input.finished_at, 'finished_at');
+    const updated = normalizeAutomationRunRecord({
+        ...located.run,
+        status: input.status,
+        finished_at: finishedAt,
+        result_preview: input.result_preview !== undefined
+            ? buildAutomationResultPreview(input.result_preview)
+            : located.run.result_preview,
+        full_result: input.full_result !== undefined ? input.full_result ?? null : located.run.full_result,
+        error: input.status === 'failed'
+            ? input.error ?? located.run.error ?? 'Automation run failed'
+            : null,
+        no_op_detected: input.no_op_detected ?? located.run.no_op_detected,
+        no_op_reason: input.no_op_reason ?? located.run.no_op_reason,
+        notification_sent: input.notification_sent ?? located.run.notification_sent,
+        updated_at: finishedAt,
+    });
+    writeJson(automationRunJsonPath(located.automationId, runId), updated);
+    const automation = getAutomationById(located.automationId);
+    const state = getAutomationState(located.automationId);
+    if (automation && state) {
+        const nextRun = automation.status === 'ACTIVE'
+            ? computeStoredAutomationNextRun(automation, finishedAt)
+            : null;
+        updateAutomationState(located.automationId, {
+            execution_status: 'idle',
+            claimed_at: null,
+            started_at: null,
+            next_run: nextRun,
+            last_run: finishedAt,
+            last_result_preview: updated.result_preview,
+            last_error: updated.error,
+            run_count: state.run_count + 1,
+            failure_count: state.failure_count + (updated.status === 'failed' ? 1 : 0),
+        });
+        if (automation.kind === 'calendar' && automation.status === 'ACTIVE' && nextRun === null) {
+            updateAutomation(located.automationId, { status: 'PAUSED' });
+        }
+    }
+    return updated;
+}
+export function listAutomationRuns(input = {}) {
+    const limit = typeof input.limit === 'number' && Number.isFinite(input.limit) && input.limit > 0
+        ? Math.floor(input.limit)
+        : 100;
+    const automationIds = typeof input.automation_id === 'string' && input.automation_id.trim()
+        ? [input.automation_id.trim()]
+        : listDirs(automationsDir());
+    const runs = [];
+    for (const automationId of automationIds) {
+        const automation = getAutomationById(automationId);
+        if (!automation)
+            continue;
+        if (input.agent_id && automation.agent_id !== input.agent_id)
+            continue;
+        const runsDir = automationRunsDir(automationId);
+        if (!fs.existsSync(runsDir))
+            continue;
+        for (const file of fs.readdirSync(runsDir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            if (file.endsWith('.context.json'))
+                continue;
+            const run = readJson(automationRunJsonPath(automationId, file.replace(/\.json$/, '')));
+            if (!run)
+                continue;
+            const normalized = normalizeAutomationRunRecord(run);
+            if (input.status && normalized.status !== input.status)
+                continue;
+            runs.push(normalized);
+        }
+    }
+    return runs
+        .sort((left, right) => {
+        const leftStamp = left.started_at ?? left.triggered_at ?? left.created_at;
+        const rightStamp = right.started_at ?? right.triggered_at ?? right.created_at;
+        return rightStamp.localeCompare(leftStamp);
+    })
+        .slice(0, limit);
+}
+export function finalizeRunningAutomationRunForSession(agentId, sessionId, input = {}) {
+    const normalizedAgentId = agentId.trim();
+    const normalizedSessionId = sessionId.trim();
+    if (!normalizedAgentId || !normalizedSessionId)
+        return undefined;
+    const runningRun = listAutomationRuns({
+        agent_id: normalizedAgentId,
+        status: 'running',
+        limit: 100,
+    }).find((run) => run.session_id === normalizedSessionId);
+    if (!runningRun)
+        return undefined;
+    const actor = input.actor?.trim() || 'user';
+    return finalizeAutomationRun(runningRun.run_id, {
+        status: 'failed',
+        finished_at: input.finished_at ?? new Date().toISOString(),
+        error: input.error || `Automation run stopped by ${actor}`,
+        notification_sent: false,
+    });
+}
+function automationToScheduleRecord(automation, state) {
+    const lastStatus = state.last_error != null ? 'failed' : state.last_run ? 'succeeded' : null;
+    return {
+        id: automation.id,
+        agent_id: automation.agent_id,
+        prompt: automation.prompt,
+        cron: automation.rrule,
+        type: 'cron',
+        session: automation.session_mode ?? 'isolated',
+        status: automation.status === 'ACTIVE' ? 'active' : 'paused',
+        target_jid: undefined,
+        created_by: undefined,
+        created_from: undefined,
+        notify_policy: 'none',
+        notify_target_jid: undefined,
+        execution_status: state.execution_status === 'idle' ? 'idle' : 'claimed',
+        claimed_at: state.claimed_at,
+        delete_after_run: false,
+        next_run: state.next_run,
+        last_run: state.last_run,
+        last_status: lastStatus,
+        last_error: state.last_error,
+        last_result_preview: state.last_result_preview,
+        run_count: state.run_count,
+        failure_count: state.failure_count,
+        created_at: new Date(automation.created_at).toISOString(),
+    };
+}
+function automationRunToScheduleRun(run) {
+    return {
+        id: run.run_id,
+        schedule_id: run.automation_id,
+        agent_id: run.agent_id,
+        prompt: run.prompt,
+        status: run.status,
+        session_id: run.session_id,
+        task_id: run.task_id,
+        result_preview: run.result_preview,
+        error: run.error,
+        started_at: run.started_at ?? run.triggered_at,
+        finished_at: run.finished_at,
+        created_at: run.created_at,
+        updated_at: run.updated_at,
+    };
+}
+export function createScheduleRun(scheduleId, input) {
+    const run = createAutomationRun(scheduleId, {
+        triggered_at: input.started_at,
+        started_at: input.started_at,
+        session_id: input.session_id,
+        task_id: input.task_id,
+    });
+    return automationRunToScheduleRun(run);
+}
+export function getScheduleRunsForSchedule(scheduleId) {
+    return listAutomationRuns({ automation_id: scheduleId }).map(automationRunToScheduleRun).sort((a, b) => {
+        const aStamp = a.started_at || a.created_at;
+        const bStamp = b.started_at || b.created_at;
+        return bStamp.localeCompare(aStamp);
+    });
+}
+export function listScheduleRuns(input = {}) {
+    const runs = listAutomationRuns({
+        agent_id: input.agent_id,
+        automation_id: input.schedule_id,
+        status: input.status,
+        limit: input.limit,
+    }).map(automationRunToScheduleRun).sort((a, b) => {
+        const aStamp = a.started_at || a.created_at;
+        const bStamp = b.started_at || b.created_at;
+        return bStamp.localeCompare(aStamp);
+    });
+    const limit = typeof input.limit === 'number' && Number.isFinite(input.limit) && input.limit > 0
+        ? Math.floor(input.limit)
+        : 100;
+    return runs.slice(0, limit);
+}
+export function finalizeScheduleRunRecord(runId, input) {
+    const run = finalizeAutomationRun(runId, {
+        status: input.outcome,
+        finished_at: input.finished_at,
+        result_preview: input.outcome === 'succeeded' ? buildAutomationResultPreview(input.result_text) : null,
+        full_result: input.outcome === 'succeeded' ? input.result_text ?? null : null,
+        error: input.outcome === 'failed' ? input.error ?? 'Schedule run failed' : null,
+    });
+    return run ? automationRunToScheduleRun(run) : undefined;
+}
+export function createSchedule(input) {
+    if (!input.agent_id?.trim()) {
+        throw new ScheduleInputError('missing_agent_id', 'agent_id is required');
+    }
+    if (!input.prompt?.trim()) {
+        throw new ScheduleInputError('missing_prompt', 'prompt is required');
+    }
+    const isOneShot = input.type === 'one-shot';
+    const expression = isOneShot ? ONE_SHOT_RRULE : input.cron?.trim();
+    if (!expression) {
+        throw new ScheduleInputError(isOneShot ? 'missing_next_run' : 'missing_cron', isOneShot ? 'next_run is required for one-shot schedules' : 'cron is required');
+    }
+    const nextRun = isOneShot
+        ? normalizeAutomationTimestamp(input.next_run, 'next_run')
+        : Object.prototype.hasOwnProperty.call(input, 'next_run') && input.next_run
+            ? normalizeAutomationTimestamp(input.next_run, 'next_run')
+            : computeScheduleExpressionNextRunOrThrow({
+                expression,
+                timezone: TIMEZONE,
+            });
+    const automation = createAutomation({
+        agent_id: input.agent_id,
+        name: input.prompt.trim().slice(0, 80) || 'Automation',
+        prompt: input.prompt,
+        rrule: expression,
+        timezone: TIMEZONE,
+        status: 'ACTIVE',
+        next_run: nextRun,
+        session_mode: input.session ?? 'isolated',
+    });
+    const state = getAutomationState(automation.id);
+    if (!state) {
+        throw new ScheduleInputError('missing_state', 'automation state was not created');
+    }
+    return automationToScheduleRecord(automation, state);
+}
+export function getScheduleById(id) {
+    const bundle = getAutomationBundle(id);
+    if (bundle) {
+        return bundle.automation.kind === 'calendar'
+            ? automationToScheduleRecord(bundle.automation, bundle.state)
+            : undefined;
+    }
+    return undefined;
+}
+export function getAllSchedules() {
+    const automationSchedules = listAutomations()
+        .filter((automation) => automation.kind === 'calendar')
+        .map((automation) => {
+        const state = getAutomationState(automation.id);
+        return state ? automationToScheduleRecord(automation, state) : undefined;
+    }).filter((value) => value !== undefined);
+    return automationSchedules.sort((a, b) => (b.created_at || '').localeCompare(a.created_at || ''));
+}
+export function getSchedulesForAgent(agentId) {
+    const automationSchedules = listAutomations(agentId)
+        .filter((automation) => automation.kind === 'calendar')
+        .map((automation) => {
+        const state = getAutomationState(automation.id);
+        return state ? automationToScheduleRecord(automation, state) : undefined;
+    }).filter((value) => value !== undefined);
+    return automationSchedules.sort((a, b) => (b.created_at || '').localeCompare(a.created_at || ''));
+}
+export function getDueSchedules(forceAll = false) {
+    const now = new Date().toISOString();
+    return getAllSchedules().filter((schedule) => schedule.status === 'active' &&
+        schedule.execution_status !== 'claimed' &&
+        (forceAll || (schedule.next_run != null && schedule.next_run <= now)));
+}
+export function claimDueSchedules(nowIso = new Date().toISOString(), forceAll = false) {
+    const claimed = [];
+    recoverStaleAutomationExecutions(nowIso);
+    for (const automation of listAutomations()) {
+        if (automation.kind !== 'calendar')
+            continue;
+        const state = getAutomationState(automation.id);
+        if (!state)
+            continue;
+        if (automation.status !== 'ACTIVE')
+            continue;
+        if (state.execution_status !== 'idle')
+            continue;
+        if (!forceAll && (!state.next_run || state.next_run > nowIso))
+            continue;
+        const updatedState = updateAutomationState(automation.id, {
+            execution_status: 'claimed',
+            claimed_at: nowIso,
+        });
+        if (updatedState) {
+            claimed.push(automationToScheduleRecord(automation, updatedState));
+        }
+    }
+    return claimed;
+}
+export function recoverStaleAutomationExecutions(nowIso = new Date().toISOString()) {
+    const now = new Date(nowIso).getTime();
+    if (Number.isNaN(now))
+        return 0;
+    let recovered = 0;
+    for (const automation of listAutomations()) {
+        const state = getAutomationState(automation.id);
+        if (!state || (state.execution_status !== 'running' && state.execution_status !== 'claimed'))
+            continue;
+        const runningRun = listAutomationRuns({
+            automation_id: automation.id,
+            status: 'running',
+            limit: 1,
+        })[0];
+        const marker = state.execution_status === 'running'
+            ? (runningRun?.updated_at ?? state.started_at)
+            : state.claimed_at;
+        if (!isStaleAutomationExecution(state.execution_status, marker, now)) {
+            continue;
+        }
+        const staleRun = runningRun;
+        const nowIsoString = new Date(now).toISOString();
+        const timeoutError = `${automation.id}: automation execution state "${state.execution_status}" stale for at least ${AUTOMATION_STALE_EXECUTION_MS / 1000}s`;
+        const nextRun = computeStoredAutomationNextRun(automation, nowIsoString);
+        if (staleRun) {
+            const finalized = finalizeAutomationRun(staleRun.run_id, {
+                status: 'failed',
+                finished_at: nowIsoString,
+                error: timeoutError,
+            });
+            finalizeAutomationEventForRun(staleRun.run_id, {
+                status: 'failed',
+                finishedAt: nowIsoString,
+                error: timeoutError,
+            });
+            if (!finalized) {
+                logger.warn({ automation_id: automation.id, run_id: staleRun.run_id }, 'Failed to finalize stale automation run, falling back to state reset');
+                updateAutomationState(automation.id, {
+                    execution_status: 'idle',
+                    claimed_at: null,
+                    started_at: null,
+                    next_run: nextRun,
+                    last_error: timeoutError,
+                    failure_count: state.failure_count + 1,
+                    last_run: nowIsoString,
+                });
+            }
+        }
+        else {
+            updateAutomationState(automation.id, {
+                execution_status: 'idle',
+                claimed_at: null,
+                started_at: null,
+                next_run: nextRun,
+                last_error: timeoutError,
+                failure_count: state.failure_count + 1,
+            });
+        }
+        const recoveredState = getAutomationState(automation.id);
+        if (!recoveredState || recoveredState.execution_status !== 'idle') {
+            logger.warn({ automation_id: automation.id, execution_status: state.execution_status }, 'Failed to recover stale automation execution status');
+            continue;
+        }
+        recovered += 1;
+        logger.info({ automation_id: automation.id, execution_status: state.execution_status }, 'Recovered stale automation execution state');
+    }
+    return recovered;
+}
+/**
+ * Reset automation executions that were in-flight when the daemon process
+ * restarted. The stream owner lived in the old process, so these runs cannot
+ * complete normally even when they have not reached the normal stale timeout.
+ */
+export function cleanupStaleAutomationExecutions(nowIso = new Date().toISOString()) {
+    const now = new Date(nowIso).getTime();
+    if (Number.isNaN(now))
+        return 0;
+    let cleaned = 0;
+    for (const automation of listAutomations()) {
+        const state = getAutomationState(automation.id);
+        if (!state || (state.execution_status !== 'running' && state.execution_status !== 'claimed')) {
+            continue;
+        }
+        const orphanedRun = listAutomationRuns({
+            automation_id: automation.id,
+            status: 'running',
+            limit: 1,
+        })[0];
+        const nowIsoString = new Date(now).toISOString();
+        const error = `${automation.id}: automation execution state "${state.execution_status}" was interrupted by daemon restart`;
+        const nextRun = computeStoredAutomationNextRun(automation, nowIsoString);
+        if (orphanedRun) {
+            requeueAutomationEventForRun(orphanedRun.run_id, nowIsoString);
+            finalizeAutomationRun(orphanedRun.run_id, {
+                status: 'failed',
+                finished_at: nowIsoString,
+                error,
+            });
+        }
+        else {
+            updateAutomationState(automation.id, {
+                execution_status: 'idle',
+                claimed_at: null,
+                started_at: null,
+                next_run: nextRun,
+                last_error: error,
+                failure_count: state.failure_count + 1,
+            });
+        }
+        const cleanedState = getAutomationState(automation.id);
+        if (!cleanedState || cleanedState.execution_status !== 'idle') {
+            logger.warn({ automation_id: automation.id, execution_status: state.execution_status }, 'Failed to clean up interrupted automation execution');
+            continue;
+        }
+        cleaned += 1;
+        logger.info({ automation_id: automation.id, execution_status: state.execution_status }, 'Reset interrupted automation execution to idle');
+    }
+    return cleaned;
+}
+export function updateSchedule(id, updates) {
+    if (Object.prototype.hasOwnProperty.call(updates, 'prompt') &&
+        typeof updates.prompt === 'string' &&
+        !updates.prompt.trim()) {
+        throw new ScheduleInputError('missing_prompt', 'prompt is required');
+    }
+    if (Object.prototype.hasOwnProperty.call(updates, 'run_count') &&
+        typeof updates.run_count === 'number') {
+        validateAutomationCounter('run_count', updates.run_count);
+    }
+    if (Object.prototype.hasOwnProperty.call(updates, 'failure_count') &&
+        typeof updates.failure_count === 'number') {
+        validateAutomationCounter('failure_count', updates.failure_count);
+    }
+    const bundle = getAutomationBundle(id);
+    if (!bundle)
+        return undefined;
+    const existingProjection = automationToScheduleRecord(bundle.automation, bundle.state);
+    const nextType = updates.type ?? existingProjection.type ?? 'cron';
+    const nextStatus = updates.status ?? existingProjection.status;
+    const nextExpression = nextType === 'one-shot'
+        ? ONE_SHOT_RRULE
+        : updates.cron?.trim() || bundle.automation.rrule;
+    const hasExplicitNextRun = Object.prototype.hasOwnProperty.call(updates, 'next_run');
+    const hasTimingUpdates = updates.cron !== undefined ||
+        updates.type !== undefined ||
+        hasExplicitNextRun ||
+        (updates.status === 'active' && existingProjection.next_run === null);
+    if (updates.type === 'one-shot' &&
+        existingProjection.type !== 'one-shot' &&
+        !hasExplicitNextRun) {
+        throw new ScheduleInputError('missing_next_run', 'next_run is required when converting a schedule to one-shot');
+    }
+    let derivedNextRun = bundle.state.next_run;
+    if (hasTimingUpdates) {
+        if (hasExplicitNextRun) {
+            derivedNextRun = updates.next_run ?? null;
+        }
+        else if (nextType === 'one-shot') {
+            derivedNextRun = bundle.state.next_run;
+        }
+        else if (nextStatus === 'paused') {
+            derivedNextRun = bundle.state.next_run;
+        }
+        else {
+            derivedNextRun = computeScheduleExpressionNextRunOrThrow({
+                expression: nextExpression,
+                timezone: bundle.automation.timezone,
+            });
+        }
+    }
+    const automation = updateAutomation(id, {
+        ...(updates.prompt !== undefined ? { prompt: updates.prompt } : {}),
+        rrule: nextExpression,
+        ...(updates.status !== undefined
+            ? { status: updates.status === 'active' ? 'ACTIVE' : 'PAUSED' }
+            : {}),
+        next_run: derivedNextRun,
+        ...(updates.session !== undefined ? { session_mode: updates.session } : {}),
+    });
+    if (!automation)
+        return undefined;
+    const state = updateAutomationState(id, {
+        ...(updates.execution_status !== undefined
+            ? {
+                execution_status: updates.execution_status === 'claimed' ? 'claimed' : 'idle',
+            }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'claimed_at')
+            ? { claimed_at: updates.claimed_at ?? null }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'last_run')
+            ? { last_run: updates.last_run ?? null }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'last_error')
+            ? { last_error: updates.last_error ?? null }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(updates, 'last_result_preview')
+            ? { last_result_preview: updates.last_result_preview ?? null }
+            : {}),
+        ...(updates.run_count !== undefined ? { run_count: updates.run_count } : {}),
+        ...(updates.failure_count !== undefined
+            ? { failure_count: updates.failure_count }
+            : {}),
+    });
+    return state ? automationToScheduleRecord(automation, state) : undefined;
+}
+export function updateScheduleAfterRun(id, nextRun) {
+    updateAutomationState(id, {
+        execution_status: 'idle',
+        claimed_at: null,
+        started_at: null,
+        next_run: nextRun,
+        last_run: new Date().toISOString(),
+    });
+    if (nextRun === null) {
+        updateAutomation(id, { status: 'PAUSED' });
+    }
+}
+export function finalizeScheduleRun(id, input) {
+    if (input.run_id) {
+        finalizeAutomationRun(input.run_id, {
+            status: input.outcome,
+            finished_at: input.finished_at,
+            result_preview: input.outcome === 'succeeded' ? buildAutomationResultPreview(input.result_text) : null,
+            full_result: input.outcome === 'succeeded' ? input.result_text ?? null : null,
+            error: input.outcome === 'failed' ? input.error ?? 'Schedule run failed' : null,
+        });
+    }
+    const bundle = getAutomationBundle(id);
+    if (!bundle)
+        return undefined;
+    if (!input.run_id) {
+        const nextRun = bundle.automation.status === 'ACTIVE'
+            ? computeStoredAutomationNextRun(bundle.automation, input.finished_at)
+            : null;
+        const updatedState = updateAutomationState(id, {
+            execution_status: 'idle',
+            claimed_at: null,
+            started_at: null,
+            next_run: nextRun,
+            last_run: input.finished_at,
+            last_result_preview: input.outcome === 'succeeded'
+                ? buildAutomationResultPreview(input.result_text)
+                : null,
+            last_error: input.outcome === 'failed' ? input.error ?? 'Schedule run failed' : null,
+            run_count: bundle.state.run_count + 1,
+            failure_count: bundle.state.failure_count + (input.outcome === 'failed' ? 1 : 0),
+        });
+        if (bundle.automation.kind === 'calendar' &&
+            bundle.automation.status === 'ACTIVE' &&
+            nextRun === null) {
+            updateAutomation(id, { status: 'PAUSED' });
+        }
+        const refreshed = getAutomationBundle(id);
+        if (refreshed && updatedState) {
+            return automationToScheduleRecord(refreshed.automation, refreshed.state);
+        }
+    }
+    const refreshed = getAutomationBundle(id);
+    return refreshed
+        ? automationToScheduleRecord(refreshed.automation, refreshed.state)
+        : undefined;
+}
+export function deleteSchedule(id) {
+    if (getAutomationById(id)) {
+        deleteAutomation(id);
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+// Router state (simple JSON key-value file)
+// ═══════════════════════════════════════════════════════════════
+function loadRouterState() {
+    return readJson(getRouterStatePath()) || {};
+}
+function saveRouterState(state) {
+    writeJson(getRouterStatePath(), state);
+}
+export function getRouterState(key) {
+    return loadRouterState()[key];
+}
+export function setRouterState(key, value) {
+    const state = loadRouterState();
+    state[key] = value;
+    saveRouterState(state);
+}
+export function getAllRouterState() {
+    return loadRouterState();
+}
+// ═══════════════════════════════════════════════════════════════
+// Registered groups/projects (JSON file)
+// ═══════════════════════════════════════════════════════════════
+function loadRegisteredGroups() {
+    return (readJson(getRegisteredGroupsPath()) || {});
+}
+function saveRegisteredGroups(groups) {
+    writeJson(getRegisteredGroupsPath(), groups);
+}
+export function getRegisteredProject(jid) {
+    const groups = loadRegisteredGroups();
+    const group = groups[jid];
+    if (!group)
+        return undefined;
+    if (!isValidGroupFolder(group.folder)) {
+        logger.warn({ jid, folder: group.folder }, 'Skipping registered group with invalid folder');
+        return undefined;
+    }
+    return {
+        jid,
+        name: group.name,
+        folder: group.folder,
+        agent_id: group.agent_id || group.folder,
+        trigger: group.trigger,
+        added_at: group.added_at,
+        requiresTrigger: group.requiresTrigger,
+        isMain: group.isMain,
+    };
+}
+export function setRegisteredProject(jid, group) {
+    if (!isValidGroupFolder(group.folder)) {
+        throw new Error(`Invalid group folder "${group.folder}" for JID ${jid}`);
+    }
+    const agentId = group.agent_id || group.folder;
+    ensureAgent({ agent_id: agentId, name: group.name });
+    const groups = loadRegisteredGroups();
+    groups[jid] = {
+        ...group,
+        agent_id: agentId,
+    };
+    saveRegisteredGroups(groups);
+}
+export function getAllRegisteredProjects() {
+    const groups = loadRegisteredGroups();
+    const result = {};
+    for (const [jid, group] of Object.entries(groups)) {
+        if (!isValidGroupFolder(group.folder)) {
+            logger.warn({ jid, folder: group.folder }, 'Skipping registered group with invalid folder');
+            continue;
+        }
+        result[jid] = {
+            name: group.name,
+            folder: group.folder,
+            agent_id: group.agent_id || group.folder,
+            trigger: group.trigger,
+            added_at: group.added_at,
+            requiresTrigger: group.requiresTrigger,
+            isMain: group.isMain,
+        };
+    }
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════
+// Chat metadata (lightweight — stored in session.json)
+// ═══════════════════════════════════════════════════════════════
+export function storeChatMetadata(chatJid, timestamp, name, channel, _isGroup) {
+    // For the filesystem approach, chat metadata is implicitly part of
+    // the session. We ensure the session exists.
+    const resolved = resolveFromChatJid(chatJid);
+    if (!resolved)
+        return;
+    ensureSession({
+        agent_id: resolved.agentId,
+        session_id: resolved.sessionId,
+        channel: channel || 'unknown',
+        source_ref: chatJid,
+        agent_name: name,
+    });
+}
+export function updateChatName(chatJid, name) {
+    // Chat metadata is stored in session.json — update the agent name
+    const resolved = resolveFromChatJid(chatJid);
+    if (!resolved)
+        return;
+    const jsonPath = sessionJsonPath(resolved.agentId, resolved.sessionId);
+    const session = readJson(jsonPath);
+    if (session) {
+        session.name = name;
+        session.space_id = session.space_id || DEFAULT_SPACE_ID;
+        session.updated_at = new Date().toISOString();
+        writeJson(jsonPath, session);
+    }
+}
+export function getAllChats() {
+    // Reconstruct from sessions
+    const chats = [];
+    for (const agentId of listDirs(AGENTS_DIR)) {
+        const sessions = getSessionsForAgent(agentId);
+        for (const session of sessions) {
+            chats.push({
+                jid: session.source_ref || `web:${agentId}:${session.session_id}`,
+                name: agentId,
+                last_message_time: session.updated_at,
+                channel: session.channel,
+                is_group: 0,
+            });
+        }
+    }
+    return chats.sort((a, b) => b.last_message_time.localeCompare(a.last_message_time));
+}
+export function getLastGroupSync() {
+    return getRouterState('__group_sync__') || null;
+}
+export function setLastGroupSync() {
+    setRouterState('__group_sync__', new Date().toISOString());
+}
+// ═══════════════════════════════════════════════════════════════
+// Interaction events (JSONL per session)
+// ═══════════════════════════════════════════════════════════════
+export function storeInteractionEvent(event) {
+    const resolved = resolveFromChatJid(event.chat_jid);
+    if (!resolved)
+        return;
+    const eventsPath = path.join(sessionDir(resolved.agentId, resolved.sessionId), 'interaction-events.jsonl');
+    appendJsonl(eventsPath, event);
+}
+export function getRecentInteractionEvents(chatJid, limit = 20) {
+    const resolved = resolveFromChatJid(chatJid);
+    if (!resolved)
+        return [];
+    const eventsPath = path.join(resolveSessionDir(resolved.agentId, resolved.sessionId), 'interaction-events.jsonl');
+    return readJsonlTail(eventsPath, limit);
+}
+export function getSessionInteractionEvents(agentId, sessionId, limit = 20) {
+    const eventsPath = path.join(resolveSessionDir(agentId, sessionId), 'interaction-events.jsonl');
+    return limit > 0
+        ? readJsonlTail(eventsPath, limit)
+        : readJsonl(eventsPath);
+}
+export function storeSessionUiEvent(agentId, sessionId, event) {
+    const taskEventPath = taskUiEventsPath(sessionId, event.task_id);
+    if (taskEventPath) {
+        writeTaskMetadata(agentId, sessionId, event.task_id);
+        appendJsonl(taskEventPath, event);
+        touchSessionActivity(agentId, sessionId, event.timestamp);
+        return;
+    }
+    const eventsPath = path.join(sessionDir(agentId, sessionId), 'events.jsonl');
+    appendJsonl(eventsPath, event);
+    touchSessionActivity(agentId, sessionId, event.timestamp);
+}
+export function getSessionUiEvents(agentId, sessionId, limit = 200) {
+    const boundedLimit = limit > 0 ? limit : SESSION_UI_EVENT_RECOVERY_LIMIT;
+    const baseDir = resolveSessionDir(agentId, sessionId);
+    const eventsPath = path.join(baseDir, 'events.jsonl');
+    const taskEvents = listTaskUiEventsForSession(agentId, sessionId, boundedLimit);
+    if (!fs.existsSync(eventsPath) && taskEvents.length > 0) {
+        return taskEvents
+            .sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')))
+            .slice(-boundedLimit);
+    }
+    const sessionEvents = readJsonlTail(eventsPath, boundedLimit);
+    return [...sessionEvents, ...taskEvents]
+        .sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')))
+        .slice(-boundedLimit);
+}
+export function getSessionUiEventsForTaskIds(agentId, sessionId, taskIds) {
+    const wanted = new Set(Array.from(taskIds)
+        .map((taskId) => String(taskId || '').trim())
+        .filter(Boolean));
+    if (wanted.size === 0)
+        return [];
+    const taskScopedEvents = [];
+    const missingTaskIds = new Set();
+    for (const taskId of wanted) {
+        const taskEventsPathValue = taskUiEventsPath(sessionId, taskId);
+        if (taskEventsPathValue && fs.existsSync(taskEventsPathValue)) {
+            const taskEvents = readJsonlTail(taskEventsPathValue, TASK_UI_EVENT_HISTORY_LIMIT);
+            taskScopedEvents.push(...taskEvents);
+        }
+        else {
+            missingTaskIds.add(taskId);
+        }
+    }
+    if (missingTaskIds.size === 0) {
+        return taskScopedEvents.sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')));
+    }
+    const eventsPath = path.join(resolveSessionDir(agentId, sessionId), 'events.jsonl');
+    const tasksWithStart = new Set();
+    const sessionEvents = readJsonlTailMatchingUntil(eventsPath, (event) => typeof event.task_id === 'string' && missingTaskIds.has(event.task_id), (event) => {
+        if (event.chunk?.type !== 'start' || typeof event.task_id !== 'string') {
+            return false;
+        }
+        tasksWithStart.add(event.task_id);
+        return tasksWithStart.size >= missingTaskIds.size;
+    });
+    return [...taskScopedEvents, ...sessionEvents].sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')));
+}
+// Test-only exports for deterministic helper validation.
+export const __testOnly = {
+    readJsonlTail,
+};
+// ═══════════════════════════════════════════════════════════════
+// Mind state — REMOVED
+// These functions are kept as no-ops / stubs for compilation.
+// The mind state is now defined by Markdown files (SOUL.md, MEMORY.md).
+// ═══════════════════════════════════════════════════════════════
+// Intentionally not exported. Mind code should be refactored
+// to read/write Markdown files directly.
+//# sourceMappingURL=store.js.map