@kafca/agentdock 0.1.42 → 0.1.44

package/dist-electron/services/local-ai-core/src/acp/store/platform-store.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPlatformStore = void 0;
+class LocalPlatformStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createPairingRequest(input) {
+        this.db.prepare(`
+      INSERT INTO platform_pairings (code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.code, input.workspace_id, input.platform || 'lark', input.platform_user_id, input.chat_id, input.display_name, input.requested_at, input.expires_at, input.status);
+    }
+    listPendingPairings(workspaceId) {
+        const query = workspaceId
+            ? `
+        SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+        FROM platform_pairings
+        WHERE workspace_id = ? AND status = 'pending'
+        ORDER BY requested_at DESC
+      `
+            : `
+        SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+        FROM platform_pairings
+        WHERE status = 'pending'
+        ORDER BY requested_at DESC
+      `;
+        return this.db.prepare(query).all(...(workspaceId ? [workspaceId] : []));
+    }
+    getPairingRequest(code) {
+        return this.db.prepare(`
+      SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+      FROM platform_pairings
+      WHERE code = ?
+    `).get(code);
+    }
+    updatePairingStatus(code, status) {
+        this.db.prepare('UPDATE platform_pairings SET status = ? WHERE code = ?').run(status, code);
+    }
+    expirePendingPairings(nowIso = new Date().toISOString()) {
+        this.db.prepare(`
+      UPDATE platform_pairings
+      SET status = 'expired'
+      WHERE status = 'pending' AND expires_at < ?
+    `).run(nowIso);
+    }
+    getAuthorizedUser(workspaceId, platformUserId, platform = 'lark') {
+        return this.db.prepare(`
+      SELECT id, workspace_id, platform, platform_user_id, chat_id, display_name, thread_id, authorized_at
+      FROM platform_users
+      WHERE workspace_id = ? AND platform = ? AND platform_user_id = ?
+    `).get(workspaceId, platform, platformUserId);
+    }
+    listAuthorizedUsers(workspaceId, platform) {
+        const params = [];
+        const predicates = [];
+        if (workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(workspaceId);
+        }
+        if (platform) {
+            predicates.push('platform = ?');
+            params.push(platform);
+        }
+        const where = predicates.length > 0 ? `WHERE ${predicates.join(' AND ')}` : '';
+        const query = `
+        SELECT id, workspace_id, platform, platform_user_id, chat_id, display_name, thread_id, authorized_at
+        FROM platform_users
+        ${where}
+        ORDER BY authorized_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => ({
+            id: row.id,
+            workspaceId: row.workspace_id,
+            platform: row.platform,
+            participantId: row.platform_user_id,
+            channelId: row.chat_id,
+            platformUserId: row.platform_user_id,
+            chatId: row.chat_id,
+            displayName: row.display_name,
+            threadId: row.thread_id || undefined,
+            authorizedAt: row.authorized_at,
+        }));
+    }
+    createAuthorizedUser(input) {
+        this.db.prepare(`
+      INSERT INTO platform_users (id, workspace_id, platform, platform_user_id, chat_id, display_name, thread_id, authorized_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workspace_id, platform, platform_user_id) DO UPDATE SET
+        chat_id = excluded.chat_id,
+        display_name = excluded.display_name,
+        thread_id = COALESCE(excluded.thread_id, platform_users.thread_id),
+        authorized_at = excluded.authorized_at
+    `).run(input.id, input.workspace_id, input.platform || 'lark', input.platform_user_id, input.chat_id, input.display_name, input.thread_id, input.authorized_at);
+    }
+    updateAuthorizedUserThread(workspaceId, platformUserId, threadId, platform = 'lark') {
+        this.db.prepare(`
+      UPDATE platform_users
+      SET thread_id = ?
+      WHERE workspace_id = ? AND platform = ? AND platform_user_id = ?
+    `).run(threadId, workspaceId, platform, platformUserId);
+    }
+    clearAuthorizedUserThreadByThreadId(threadId) {
+        this.db.prepare('UPDATE platform_users SET thread_id = NULL WHERE thread_id = ?').run(threadId);
+    }
+    getPlatformThreadBinding(workspaceId, chatId, platformUserId, platform = 'lark') {
+        return this.db.prepare(`
+      SELECT workspace_id, platform, chat_id, platform_user_id, thread_id, last_platform_message_id, created_at, updated_at
+      FROM platform_thread_bindings
+      WHERE workspace_id = ? AND platform = ? AND chat_id = ? AND platform_user_id = ?
+    `).get(workspaceId, platform, chatId, platformUserId);
+    }
+    getPlatformThreadBindingByThreadId(threadId) {
+        return this.db.prepare(`
+      SELECT workspace_id, platform, chat_id, platform_user_id, thread_id, last_platform_message_id, created_at, updated_at
+      FROM platform_thread_bindings
+      WHERE thread_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `).get(threadId);
+    }
+    deletePlatformThreadBindingsByThreadId(threadId) {
+        this.db.prepare('DELETE FROM platform_thread_bindings WHERE thread_id = ?').run(threadId);
+    }
+    upsertPlatformThreadBinding(input) {
+        this.db.prepare(`
+      INSERT INTO platform_thread_bindings
+      (workspace_id, platform, chat_id, platform_user_id, thread_id, last_platform_message_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workspace_id, platform, chat_id, platform_user_id) DO UPDATE SET
+        thread_id = excluded.thread_id,
+        last_platform_message_id = COALESCE(excluded.last_platform_message_id, platform_thread_bindings.last_platform_message_id),
+        updated_at = excluded.updated_at
+    `).run(input.workspace_id, input.platform || 'lark', input.chat_id, input.platform_user_id, input.thread_id, input.last_platform_message_id, input.created_at, input.updated_at);
+    }
+    updatePlatformThreadMessageId(workspaceId, chatId, platformUserId, messageId, platform = 'lark') {
+        this.db.prepare(`
+      UPDATE platform_thread_bindings
+      SET last_platform_message_id = ?, updated_at = ?
+      WHERE workspace_id = ? AND platform = ? AND chat_id = ? AND platform_user_id = ?
+    `).run(messageId, new Date().toISOString(), workspaceId, platform, chatId, platformUserId);
+    }
+    clearPlatformThreadMessageId(workspaceId, chatId, platformUserId, platform = 'lark') {
+        this.db.prepare(`
+      UPDATE platform_thread_bindings
+      SET last_platform_message_id = NULL, updated_at = ?
+      WHERE workspace_id = ? AND platform = ? AND chat_id = ? AND platform_user_id = ?
+    `).run(new Date().toISOString(), workspaceId, platform, chatId, platformUserId);
+    }
+    listPairingRequests(workspaceId, platform) {
+        const params = [];
+        const predicates = [];
+        if (workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(workspaceId);
+        }
+        if (platform) {
+            predicates.push('platform = ?');
+            params.push(platform);
+        }
+        const where = predicates.length > 0 ? `WHERE ${predicates.join(' AND ')}` : '';
+        const query = `
+        SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+        FROM platform_pairings
+        ${where}
+        ORDER BY requested_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => ({
+            code: row.code,
+            workspaceId: row.workspace_id,
+            platform: row.platform,
+            participantId: row.platform_user_id,
+            channelId: row.chat_id,
+            platformUserId: row.platform_user_id,
+            chatId: row.chat_id,
+            displayName: row.display_name,
+            requestedAt: row.requested_at,
+            expiresAt: row.expires_at,
+            status: row.status,
+        }));
+    }
+}
+exports.LocalPlatformStore = LocalPlatformStore;

package/dist-electron/services/local-ai-core/src/acp/store/scheduler-store.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSchedulerStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+const job_id_js_1 = require("../../scheduler/job-id.js");
+const utils_js_1 = require("./utils.js");
+class LocalSchedulerStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    listJobs(workspaceId) {
+        const query = workspaceId
+            ? `
+        SELECT id, workspace_id, platform, route_type, route_config, trigger_type, cron_expr, run_at, prompt_template, description,
+               enabled, concurrency_policy, created_at, updated_at, last_run_at, last_status, last_error, execution_mode
+        FROM scheduled_jobs
+        WHERE workspace_id = ?
+        ORDER BY updated_at DESC
+      `
+            : `
+        SELECT id, workspace_id, platform, route_type, route_config, trigger_type, cron_expr, run_at, prompt_template, description,
+               enabled, concurrency_policy, created_at, updated_at, last_run_at, last_status, last_error, execution_mode
+        FROM scheduled_jobs
+        ORDER BY updated_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...(workspaceId ? [workspaceId] : []));
+        return rows.map((row) => this.toScheduledJob(row));
+    }
+    getJob(jobId) {
+        const row = this.db.prepare(`
+      SELECT id, workspace_id, platform, route_type, route_config, trigger_type, cron_expr, run_at, prompt_template, description,
+             enabled, concurrency_policy, created_at, updated_at, last_run_at, last_status, last_error, execution_mode
+      FROM scheduled_jobs
+      WHERE id = ?
+    `).get(jobId);
+        return row ? this.toScheduledJob(row) : undefined;
+    }
+    createJob(input) {
+        if (!input.platform || !input.route) {
+            throw new Error('Scheduled job creation requires a resolved platform and route.');
+        }
+        let id = (0, job_id_js_1.createScheduledJobId)();
+        for (let attempt = 0; attempt < 5 && this.getJob(id); attempt += 1) {
+            id = (0, job_id_js_1.createScheduledJobId)();
+        }
+        if (this.getJob(id)) {
+            throw new Error('Unable to allocate a unique scheduled job id.');
+        }
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO scheduled_jobs (
+        id, workspace_id, platform, route_type, route_config, execution_mode, trigger_type, cron_expr, run_at,
+        prompt_template, description, enabled, concurrency_policy, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'skip_if_running', ?, ?)
+    `).run(id, input.workspaceId, (0, index_js_1.normalizeChannelPlatform)(input.platform), input.route.type, JSON.stringify(input.route), (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode), (0, index_js_1.normalizeScheduledJobTriggerType)(input.triggerType), input.cronExpr || null, input.runAt || null, input.promptTemplate, input.description || '', input.enabled === false ? 0 : 1, now, now);
+        return this.getJob(id);
+    }
+    updateJob(jobId, input) {
+        const existing = this.getJob(jobId);
+        if (!existing) {
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        }
+        const next = {
+            ...existing,
+            ...(input.route ? { route: input.route } : {}),
+            ...(input.executionMode ? { executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode) } : {}),
+            ...(input.triggerType ? { triggerType: (0, index_js_1.normalizeScheduledJobTriggerType)(input.triggerType) } : {}),
+            ...(Object.prototype.hasOwnProperty.call(input, 'cronExpr') ? { cronExpr: input.cronExpr || undefined } : {}),
+            ...(Object.prototype.hasOwnProperty.call(input, 'runAt') ? { runAt: input.runAt || undefined } : {}),
+            ...(typeof input.promptTemplate === 'string' ? { promptTemplate: input.promptTemplate } : {}),
+            ...(typeof input.description === 'string' ? { description: input.description } : {}),
+            ...(typeof input.enabled === 'boolean' ? { enabled: input.enabled } : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        this.db.prepare(`
+      UPDATE scheduled_jobs
+      SET route_type = ?, route_config = ?, execution_mode = ?, trigger_type = ?, cron_expr = ?, run_at = ?, prompt_template = ?,
+          description = ?, enabled = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.route.type, JSON.stringify(next.route), next.executionMode, next.triggerType, next.cronExpr || null, next.runAt || null, next.promptTemplate, next.description, next.enabled ? 1 : 0, next.updatedAt, jobId);
+        return this.getJob(jobId);
+    }
+    deleteJob(jobId) {
+        const result = this.db.prepare('DELETE FROM scheduled_jobs WHERE id = ?').run(jobId);
+        if (result.changes === 0) {
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        }
+        return { deleted: true };
+    }
+    listRuns(jobId) {
+        const rows = this.db.prepare(`
+      SELECT id, job_id, status, triggered_at, started_at, finished_at, error, thread_id, run_id, platform_message_id, platform_message_ids_json, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM scheduled_job_runs
+      WHERE job_id = ?
+      ORDER BY triggered_at DESC
+    `).all(jobId);
+        return rows.map((row) => this.toScheduledJobRun(row));
+    }
+    createRun(jobId, status, input = {}) {
+        const id = `jobrun:${(0, node_crypto_1.randomUUID)()}`;
+        const triggeredAt = input.triggeredAt || new Date().toISOString();
+        const normalizedStatus = (0, index_js_1.normalizeScheduledJobRunStatus)(status);
+        this.db.prepare(`
+      INSERT INTO scheduled_job_runs (id, job_id, status, triggered_at, started_at, finished_at, error, thread_id, run_id, platform_message_id, platform_message_ids_json, delivery_mode, delivery_status, delivery_error, last_bridge_event_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, jobId, normalizedStatus, triggeredAt, input.startedAt || null, input.finishedAt || null, input.error || null, input.threadId || null, input.runId || null, input.platformMessageId || null, JSON.stringify(input.platformMessageIds || []), input.deliveryMode || null, input.deliveryStatus || null, input.deliveryError || null, input.lastBridgeEventAt || null);
+        this.updateJobStatus(jobId, {
+            lastRunAt: triggeredAt,
+            lastStatus: normalizedStatus,
+            lastError: input.error || '',
+        });
+        return this.getRun(id);
+    }
+    getRun(runId) {
+        const row = this.db.prepare(`
+      SELECT id, job_id, status, triggered_at, started_at, finished_at, error, thread_id, run_id, platform_message_id, platform_message_ids_json, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM scheduled_job_runs
+      WHERE id = ?
+    `).get(runId);
+        return row ? this.toScheduledJobRun(row) : undefined;
+    }
+    updateRun(runId, input) {
+        const existing = this.getRun(runId);
+        if (!existing) {
+            throw new Error(`Scheduled job run not found: ${runId}`);
+        }
+        const next = {
+            ...existing,
+            ...input,
+            ...(input.status ? { status: (0, index_js_1.normalizeScheduledJobRunStatus)(input.status) } : {}),
+        };
+        this.db.prepare(`
+      UPDATE scheduled_job_runs
+      SET status = ?, triggered_at = ?, started_at = ?, finished_at = ?, error = ?, thread_id = ?, run_id = ?, platform_message_id = ?, platform_message_ids_json = ?, delivery_mode = ?, delivery_status = ?, delivery_error = ?, last_bridge_event_at = ?
+      WHERE id = ?
+    `).run(next.status, next.triggeredAt, next.startedAt || null, next.finishedAt || null, next.error || null, next.threadId || null, next.runId || null, next.platformMessageId || null, JSON.stringify(next.platformMessageIds || []), next.deliveryMode || null, next.deliveryStatus || null, next.deliveryError || null, next.lastBridgeEventAt || null, runId);
+        if (input.status || Object.prototype.hasOwnProperty.call(input, 'error') || input.finishedAt || input.triggeredAt) {
+            this.updateJobStatus(existing.jobId, {
+                lastRunAt: next.triggeredAt,
+                lastStatus: next.status,
+                lastError: next.error || '',
+            });
+        }
+        return this.getRun(runId);
+    }
+    updateJobStatus(jobId, input) {
+        this.db.prepare(`
+      UPDATE scheduled_jobs
+      SET last_run_at = COALESCE(?, last_run_at),
+          last_status = COALESCE(?, last_status),
+          last_error = CASE WHEN ? IS NULL THEN last_error ELSE ? END,
+          enabled = CASE WHEN ? IS NULL THEN enabled ELSE ? END,
+          updated_at = ?
+      WHERE id = ?
+    `).run(input.lastRunAt || null, input.lastStatus || null, input.lastError == null ? null : input.lastError, input.lastError == null ? null : input.lastError, typeof input.enabled === 'boolean' ? (input.enabled ? 1 : 0) : null, typeof input.enabled === 'boolean' ? (input.enabled ? 1 : 0) : null, new Date().toISOString(), jobId);
+    }
+    toScheduledJob(row) {
+        const route = JSON.parse(row.route_config);
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            platform: (0, index_js_1.normalizeChannelPlatform)(row.platform),
+            route,
+            executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(row.execution_mode),
+            triggerType: (0, index_js_1.normalizeScheduledJobTriggerType)(row.trigger_type),
+            cronExpr: row.cron_expr || undefined,
+            runAt: row.run_at || undefined,
+            promptTemplate: row.prompt_template,
+            description: row.description,
+            enabled: Boolean(row.enabled),
+            concurrencyPolicy: row.concurrency_policy,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastRunAt: row.last_run_at || undefined,
+            lastStatus: row.last_status ? (0, index_js_1.normalizeScheduledJobRunStatus)(row.last_status) : undefined,
+            lastError: row.last_error || undefined,
+        };
+    }
+    toScheduledJobRun(row) {
+        return {
+            id: row.id,
+            jobId: row.job_id,
+            status: (0, index_js_1.normalizeScheduledJobRunStatus)(row.status),
+            triggeredAt: row.triggered_at,
+            startedAt: row.started_at || undefined,
+            finishedAt: row.finished_at || undefined,
+            error: row.error || undefined,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            platformMessageId: row.platform_message_id || undefined,
+            platformMessageIds: (0, utils_js_1.parseJson)(row.platform_message_ids_json || '[]', []),
+            deliveryMode: row.delivery_mode || undefined,
+            deliveryStatus: row.delivery_status || undefined,
+            deliveryError: row.delivery_error || undefined,
+            lastBridgeEventAt: row.last_bridge_event_at || undefined,
+        };
+    }
+}
+exports.LocalSchedulerStore = LocalSchedulerStore;

package/dist-electron/services/local-ai-core/src/acp/store/schema.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureLocalCoreAcpSchema = ensureLocalCoreAcpSchema;
+function ensureLocalCoreAcpSchema(db) {
+    db.exec(`
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE IF NOT EXISTS threads (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      bridge_session_key TEXT NOT NULL,
+      title TEXT NOT NULL,
+      agent_type TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      history_count INTEGER NOT NULL DEFAULT 0,
+      excerpt TEXT NOT NULL DEFAULT '',
+      acp_session_id TEXT,
+      acp_supports_load INTEGER NOT NULL DEFAULT 0,
+      agent_mode TEXT NOT NULL DEFAULT 'default'
+    );
+    CREATE INDEX IF NOT EXISTS idx_threads_workspace_updated ON threads (workspace_id, updated_at DESC);
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      tool_call_json TEXT,
+      bridge_kind TEXT,
+      bridge_status TEXT,
+      timestamp TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      seq INTEGER NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_messages_thread_seq ON messages (thread_id, seq ASC);
+    CREATE TABLE IF NOT EXISTS runs (
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_runs_thread_updated ON runs (thread_id, updated_at DESC);
+    CREATE TABLE IF NOT EXISTS platform_pairings (
+      code TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      platform_user_id TEXT NOT NULL,
+      chat_id TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      requested_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      status TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_platform_pairings_workspace_status ON platform_pairings (workspace_id, status, expires_at DESC);
+    CREATE TABLE IF NOT EXISTS platform_users (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      platform_user_id TEXT NOT NULL,
+      chat_id TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      thread_id TEXT,
+      authorized_at TEXT NOT NULL,
+      UNIQUE(workspace_id, platform, platform_user_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_platform_users_workspace_platform ON platform_users (workspace_id, platform);
+    CREATE TABLE IF NOT EXISTS platform_thread_bindings (
+      workspace_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      chat_id TEXT NOT NULL,
+      platform_user_id TEXT NOT NULL,
+      thread_id TEXT NOT NULL,
+      last_platform_message_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (workspace_id, platform, chat_id, platform_user_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_platform_thread_bindings_thread ON platform_thread_bindings (thread_id);
+    CREATE TABLE IF NOT EXISTS scheduled_jobs (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      route_type TEXT NOT NULL,
+      route_config TEXT NOT NULL,
+      execution_mode TEXT NOT NULL DEFAULT 'same-thread',
+      trigger_type TEXT NOT NULL,
+      cron_expr TEXT,
+      run_at TEXT,
+      prompt_template TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      concurrency_policy TEXT NOT NULL DEFAULT 'skip_if_running',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_run_at TEXT,
+      last_status TEXT,
+      last_error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_scheduled_jobs_workspace_updated ON scheduled_jobs (workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_scheduled_jobs_enabled ON scheduled_jobs (enabled, trigger_type, run_at);
+    CREATE TABLE IF NOT EXISTS scheduled_job_runs (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      triggered_at TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      error TEXT,
+      thread_id TEXT,
+      run_id TEXT,
+      platform_message_id TEXT,
+      platform_message_ids_json TEXT,
+      delivery_mode TEXT,
+      delivery_status TEXT,
+      delivery_error TEXT,
+      last_bridge_event_at TEXT,
+      FOREIGN KEY (job_id) REFERENCES scheduled_jobs(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_scheduled_job_runs_job_triggered ON scheduled_job_runs (job_id, triggered_at DESC);
+    CREATE TABLE IF NOT EXISTS automation_monitors (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      source_config_json TEXT NOT NULL DEFAULT '{}',
+      condition_json TEXT NOT NULL,
+      prompt_template TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      route_type TEXT NOT NULL,
+      route_config TEXT NOT NULL,
+      execution_mode TEXT NOT NULL DEFAULT 'side-thread',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      cooldown_ms INTEGER NOT NULL DEFAULT 900000,
+      concurrency_policy TEXT NOT NULL DEFAULT 'skip_if_running',
+      last_state_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_triggered_at TEXT,
+      last_status TEXT,
+      last_error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_automation_monitors_workspace_updated ON automation_monitors (workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_automation_monitors_enabled ON automation_monitors (enabled, source_type);
+    CREATE TABLE IF NOT EXISTS automation_monitor_runs (
+      id TEXT PRIMARY KEY,
+      monitor_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      triggered_at TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      error TEXT,
+      event_snapshot_json TEXT,
+      thread_id TEXT,
+      run_id TEXT,
+      delivery_mode TEXT,
+      delivery_status TEXT,
+      delivery_error TEXT,
+      last_bridge_event_at TEXT,
+      FOREIGN KEY (monitor_id) REFERENCES automation_monitors(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_automation_monitor_runs_monitor_triggered ON automation_monitor_runs (monitor_id, triggered_at DESC);
+    CREATE TABLE IF NOT EXISTS workspace_registry (
+      id TEXT PRIMARY KEY,
+      display_name TEXT NOT NULL,
+      path TEXT NOT NULL,
+      device_id TEXT NOT NULL,
+      default_runtime_id TEXT,
+      git_json TEXT NOT NULL DEFAULT '{}',
+      health_json TEXT NOT NULL DEFAULT '{}',
+      metadata_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_opened_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_workspace_registry_updated ON workspace_registry (updated_at DESC);
+    CREATE TABLE IF NOT EXISTS agent_tasks (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      device_id TEXT NOT NULL,
+      runtime_id TEXT NOT NULL,
+      thread_id TEXT,
+      run_id TEXT,
+      title TEXT NOT NULL,
+      prompt TEXT,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      queued_at TEXT,
+      started_at TEXT,
+      completed_at TEXT,
+      summary TEXT,
+      error TEXT,
+      timeline_json TEXT NOT NULL DEFAULT '[]',
+      logs_json TEXT NOT NULL DEFAULT '[]',
+      artifacts_json TEXT NOT NULL DEFAULT '[]',
+      approval_ids_json TEXT NOT NULL DEFAULT '[]',
+      metadata_json TEXT NOT NULL DEFAULT '{}'
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_tasks_workspace_updated ON agent_tasks (workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_agent_tasks_status_updated ON agent_tasks (status, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_agent_tasks_run ON agent_tasks (run_id);
+    CREATE TABLE IF NOT EXISTS workspace_security_settings (
+      workspace_id TEXT PRIMARY KEY,
+      permissions_json TEXT NOT NULL,
+      allow_paths_json TEXT NOT NULL DEFAULT '[]',
+      deny_paths_json TEXT NOT NULL DEFAULT '[]',
+      updated_at TEXT NOT NULL,
+      updated_by TEXT
+    );
+    CREATE TABLE IF NOT EXISTS approval_requests (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      task_id TEXT,
+      thread_id TEXT,
+      run_id TEXT,
+      device_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      status TEXT NOT NULL,
+      risk_level TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      requested_action TEXT NOT NULL,
+      command TEXT,
+      scopes_json TEXT NOT NULL DEFAULT '[]',
+      options_json TEXT NOT NULL DEFAULT '[]',
+      requested_by TEXT,
+      resolved_by TEXT,
+      resolution TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      resolved_at TEXT,
+      expires_at TEXT,
+      metadata_json TEXT NOT NULL DEFAULT '{}'
+    );
+    CREATE INDEX IF NOT EXISTS idx_approval_requests_workspace_updated ON approval_requests (workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_approval_requests_status_updated ON approval_requests (status, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_approval_requests_task ON approval_requests (task_id);
+    CREATE INDEX IF NOT EXISTS idx_approval_requests_run ON approval_requests (run_id);
+    CREATE TABLE IF NOT EXISTS audit_events (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      workspace_id TEXT,
+      task_id TEXT,
+      approval_id TEXT,
+      actor TEXT,
+      summary TEXT NOT NULL,
+      risk_level TEXT,
+      created_at TEXT NOT NULL,
+      metadata_json TEXT NOT NULL DEFAULT '{}'
+    );
+    CREATE INDEX IF NOT EXISTS idx_audit_events_workspace_created ON audit_events (workspace_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_audit_events_task_created ON audit_events (task_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_audit_events_type_created ON audit_events (type, created_at DESC);
+  `);
+    ensureColumn(db, 'messages', 'tool_call_json', 'TEXT');
+    ensureColumn(db, 'messages', 'bridge_kind', 'TEXT');
+    ensureColumn(db, 'messages', 'bridge_status', 'TEXT');
+    ensureColumn(db, 'scheduled_jobs', 'execution_mode', "TEXT NOT NULL DEFAULT 'same-thread'");
+    ensureColumn(db, 'scheduled_job_runs', 'platform_message_ids_json', 'TEXT');
+    ensureColumn(db, 'scheduled_job_runs', 'delivery_mode', 'TEXT');
+    ensureColumn(db, 'scheduled_job_runs', 'delivery_status', 'TEXT');
+    ensureColumn(db, 'scheduled_job_runs', 'delivery_error', 'TEXT');
+    ensureColumn(db, 'scheduled_job_runs', 'last_bridge_event_at', 'TEXT');
+    ensureColumn(db, 'threads', 'agent_mode', "TEXT NOT NULL DEFAULT 'default'");
+}
+function ensureColumn(db, table, column, definition) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (rows.some((row) => row.name === column)) {
+        return;
+    }
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}