hivehq 2.0.0

package/dist/src/server/session-capture.d.ts

@@ -0,0 +1,77 @@
+export type SessionIdCaptureConfig = {
+    source: 'claude_project_jsonl_dir';
+    pattern: string;
+} | {
+    source: 'codex_session_jsonl_dir';
+    pattern: string;
+} | {
+    source: 'gemini_session_json_dir';
+    pattern: string;
+} | {
+    source: 'opencode_session_db';
+    pattern: string;
+} | {
+    source: 'stdout_regex';
+    pattern: string;
+} | {
+    source: 'banner_parse';
+    pattern?: string;
+};
+export interface SessionCaptureSnapshot {
+    discriminator?: {
+        contentIncludes: string | readonly string[];
+    };
+    getOutput?: () => string | null;
+    knownSessionIds: Set<string>;
+    env?: Record<string, string>;
+    root?: string;
+}
+export declare const parseSessionIdCapture: (value: unknown) => SessionIdCaptureConfig | null;
+export declare const snapshotSessionIdsForCapture: (cwd: string, capture: SessionIdCaptureConfig | null | undefined, discriminator?: SessionCaptureSnapshot["discriminator"]) => {
+    discriminator?: {
+        contentIncludes: string | readonly string[];
+    };
+    env: {
+        HIVE_CLAUDE_PROJECTS_DIR: string;
+        CODEX_HOME?: never;
+        HIVE_GEMINI_HOME?: never;
+        HIVE_OPENCODE_DB_PATH?: never;
+    };
+    knownSessionIds: Set<string>;
+    root: string;
+} | {
+    env: {
+        CODEX_HOME: string;
+        HIVE_CLAUDE_PROJECTS_DIR?: never;
+        HIVE_GEMINI_HOME?: never;
+        HIVE_OPENCODE_DB_PATH?: never;
+    };
+    knownSessionIds: Set<string>;
+    root: string;
+} | {
+    env: {
+        HIVE_GEMINI_HOME: string;
+        HIVE_CLAUDE_PROJECTS_DIR?: never;
+        CODEX_HOME?: never;
+        HIVE_OPENCODE_DB_PATH?: never;
+    };
+    knownSessionIds: Set<string>;
+    root: string;
+} | {
+    env: {
+        HIVE_OPENCODE_DB_PATH: string;
+        HIVE_CLAUDE_PROJECTS_DIR?: never;
+        CODEX_HOME?: never;
+        HIVE_GEMINI_HOME?: never;
+    };
+    knownSessionIds: Set<string>;
+    root: string;
+} | {
+    knownSessionIds: Set<string>;
+    env?: never;
+    root?: never;
+} | undefined;
+export declare const getSessionCaptureEnvironment: (snapshot: SessionCaptureSnapshot | undefined) => Record<string, string>;
+export declare const captureSessionIdForCapture: (cwd: string, capture: SessionIdCaptureConfig, snapshot: SessionCaptureSnapshot, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number) => Promise<void>;
+export declare const doesCapturedSessionExist: (cwd: string, capture: SessionIdCaptureConfig, sessionId: string, discriminator?: SessionCaptureSnapshot["discriminator"]) => boolean;
+export declare const captureStdoutRegexSessionId: (pattern: string, getOutput: (() => string | null) | undefined, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number) => Promise<void>;

package/dist/src/server/session-capture.js

@@ -0,0 +1,123 @@
+import { captureClaudeSessionId, getClaudeProjectsRoot, hasClaudeSessionFile, snapshotClaudeSessionIds, } from './session-capture-claude.js';
+import { captureCodexSessionId, getCodexHome, hasCodexSession, snapshotCodexSessionIds, } from './session-capture-codex.js';
+import { captureGeminiSessionId, getGeminiHome, hasGeminiSession, snapshotGeminiSessionIds, } from './session-capture-gemini.js';
+import { captureOpenCodeSessionId, getOpenCodeDbPath, hasOpenCodeSession, snapshotOpenCodeSessionIds, } from './session-capture-opencode.js';
+const hasSource = (value) => Boolean(value && typeof value === 'object' && 'source' in value);
+export const parseSessionIdCapture = (value) => {
+    if (!hasSource(value))
+        return null;
+    const pattern = 'pattern' in value && (typeof value.pattern === 'string' || value.pattern === undefined)
+        ? value.pattern
+        : undefined;
+    if (value.source === 'claude_project_jsonl_dir' ||
+        value.source === 'codex_session_jsonl_dir' ||
+        value.source === 'gemini_session_json_dir' ||
+        value.source === 'opencode_session_db' ||
+        value.source === 'stdout_regex') {
+        return typeof pattern === 'string' ? { pattern, source: value.source } : null;
+    }
+    if (value.source === 'banner_parse') {
+        return pattern === undefined ? { source: value.source } : { pattern, source: value.source };
+    }
+    return null;
+};
+export const snapshotSessionIdsForCapture = (cwd, capture, discriminator) => {
+    if (!capture)
+        return undefined;
+    if (capture.source === 'claude_project_jsonl_dir') {
+        const projectsRoot = getClaudeProjectsRoot(capture.pattern);
+        return {
+            env: { HIVE_CLAUDE_PROJECTS_DIR: projectsRoot },
+            knownSessionIds: snapshotClaudeSessionIds(cwd, projectsRoot),
+            root: projectsRoot,
+            ...(discriminator ? { discriminator } : {}),
+        };
+    }
+    if (capture.source === 'codex_session_jsonl_dir') {
+        const codexHome = getCodexHome(capture.pattern);
+        return {
+            env: { CODEX_HOME: codexHome },
+            knownSessionIds: snapshotCodexSessionIds(cwd, codexHome),
+            root: codexHome,
+        };
+    }
+    if (capture.source === 'gemini_session_json_dir') {
+        const geminiHome = getGeminiHome(capture.pattern);
+        return {
+            env: { HIVE_GEMINI_HOME: geminiHome },
+            knownSessionIds: snapshotGeminiSessionIds(cwd, geminiHome),
+            root: geminiHome,
+        };
+    }
+    if (capture.source === 'opencode_session_db') {
+        const dbPath = getOpenCodeDbPath(capture.pattern);
+        return {
+            env: { HIVE_OPENCODE_DB_PATH: dbPath },
+            knownSessionIds: snapshotOpenCodeSessionIds(cwd, dbPath),
+            root: dbPath,
+        };
+    }
+    if (capture.source === 'stdout_regex') {
+        return {
+            knownSessionIds: new Set(),
+        };
+    }
+    return undefined;
+};
+export const getSessionCaptureEnvironment = (snapshot) => snapshot?.env ?? {};
+export const captureSessionIdForCapture = async (cwd, capture, snapshot, onCapture, timeoutMs = 5000, intervalMs = 100) => {
+    if (capture.source === 'claude_project_jsonl_dir') {
+        await captureClaudeSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root, snapshot.discriminator);
+    }
+    if (capture.source === 'codex_session_jsonl_dir') {
+        await captureCodexSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root);
+    }
+    if (capture.source === 'gemini_session_json_dir') {
+        await captureGeminiSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root);
+    }
+    if (capture.source === 'opencode_session_db') {
+        await captureOpenCodeSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root);
+    }
+    if (capture.source === 'stdout_regex') {
+        await captureStdoutRegexSessionId(capture.pattern, snapshot.getOutput, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs);
+    }
+};
+export const doesCapturedSessionExist = (cwd, capture, sessionId, discriminator) => {
+    if (capture.source === 'claude_project_jsonl_dir') {
+        return hasClaudeSessionFile(cwd, sessionId, capture.pattern, discriminator);
+    }
+    if (capture.source === 'codex_session_jsonl_dir') {
+        return hasCodexSession(cwd, sessionId, capture.pattern);
+    }
+    if (capture.source === 'gemini_session_json_dir') {
+        return hasGeminiSession(cwd, sessionId, capture.pattern);
+    }
+    if (capture.source === 'opencode_session_db') {
+        return hasOpenCodeSession(cwd, sessionId, capture.pattern);
+    }
+    return false;
+};
+const compileCaptureRegex = (pattern) => {
+    try {
+        return new RegExp(pattern, 'u');
+    }
+    catch {
+        return null;
+    }
+};
+export const captureStdoutRegexSessionId = async (pattern, getOutput, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100) => {
+    const regex = compileCaptureRegex(pattern);
+    if (!regex || !getOutput)
+        return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        const output = getOutput();
+        const match = output ? regex.exec(output) : null;
+        const sessionId = match?.[1];
+        if (sessionId && !knownSessionIds.has(sessionId)) {
+            onCapture(sessionId);
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+};

package/dist/src/server/settings-store.d.ts

@@ -0,0 +1,22 @@
+import type { Database } from 'better-sqlite3';
+import { type AppStateRecord, type AppStateValue } from './app-state-store.js';
+import { type CommandPresetInput, type CommandPresetRecord } from './command-preset-store.js';
+import { type RoleTemplateInput, type RoleTemplateRecord } from './role-template-store.js';
+export interface SettingsStore {
+    createCommandPreset: (input: CommandPresetInput) => CommandPresetRecord;
+    createRoleTemplate: (input: RoleTemplateInput) => RoleTemplateRecord;
+    deleteCommandPreset: (id: string) => void;
+    deleteRoleTemplate: (id: string) => void;
+    /** TIER 2 #4 — workflow runner uses this to resolve a non-built-in
+     *  agentType against the user's curated role library. */
+    findRoleTemplateByName: (name: string) => RoleTemplateRecord | undefined;
+    getAppState: (key: string) => AppStateRecord | undefined;
+    getCommandPreset: (id: string) => CommandPresetRecord | undefined;
+    listCommandPresets: () => CommandPresetRecord[];
+    listRoleTemplates: () => RoleTemplateRecord[];
+    setAppState: (key: string, value: AppStateValue) => void;
+    updateCommandPreset: (id: string, input: CommandPresetInput) => CommandPresetRecord;
+    updateRoleTemplate: (id: string, input: RoleTemplateInput) => RoleTemplateRecord;
+}
+export type { AppStateRecord, AppStateValue, CommandPresetInput, CommandPresetRecord, RoleTemplateInput, RoleTemplateRecord, };
+export declare const createSettingsStore: (db: Database) => SettingsStore;

package/dist/src/server/settings-store.js

@@ -0,0 +1,22 @@
+import { createAppStateStore } from './app-state-store.js';
+import { createCommandPresetStore, } from './command-preset-store.js';
+import { createRoleTemplateStore, } from './role-template-store.js';
+export const createSettingsStore = (db) => {
+    const appStateStore = createAppStateStore(db);
+    const commandPresetStore = createCommandPresetStore(db);
+    const roleTemplateStore = createRoleTemplateStore(db);
+    return {
+        createCommandPreset: commandPresetStore.create,
+        createRoleTemplate: roleTemplateStore.create,
+        deleteCommandPreset: commandPresetStore.remove,
+        deleteRoleTemplate: roleTemplateStore.remove,
+        findRoleTemplateByName: roleTemplateStore.findByName,
+        getAppState: appStateStore.get,
+        getCommandPreset: commandPresetStore.get,
+        listCommandPresets: commandPresetStore.list,
+        listRoleTemplates: roleTemplateStore.list,
+        setAppState: appStateStore.set,
+        updateCommandPreset: commandPresetStore.update,
+        updateRoleTemplate: roleTemplateStore.update,
+    };
+};

package/dist/src/server/sqlite-schema-v10.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion10: (db: Database) => void;

package/dist/src/server/sqlite-schema-v10.js

@@ -0,0 +1,13 @@
+import { BUILTIN_COMMAND_PRESETS } from './command-preset-defaults.js';
+export const applySchemaVersion10 = (db) => {
+    const updatePreset = db.prepare(`UPDATE command_presets
+     SET resume_args_template = ?,
+         session_id_capture = ?,
+         yolo_args_template = ?,
+         updated_at = ?
+     WHERE id = ? AND is_builtin = 1`);
+    const now = Date.now();
+    for (const preset of BUILTIN_COMMAND_PRESETS) {
+        updatePreset.run(preset.resumeArgsTemplate, preset.sessionIdCapture ? JSON.stringify(preset.sessionIdCapture) : null, preset.yoloArgsTemplate ? JSON.stringify(preset.yoloArgsTemplate) : null, now, preset.id);
+    }
+};

package/dist/src/server/sqlite-schema-v11.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion11: (db: Database) => void;

package/dist/src/server/sqlite-schema-v11.js

@@ -0,0 +1,10 @@
+import { BUILTIN_COMMAND_PRESETS } from './command-preset-defaults.js';
+export const applySchemaVersion11 = (db) => {
+    const updatePreset = db.prepare(`UPDATE command_presets
+     SET yolo_args_template = ?, updated_at = ?
+     WHERE id = ? AND is_builtin = 1`);
+    const now = Date.now();
+    for (const preset of BUILTIN_COMMAND_PRESETS) {
+        updatePreset.run(preset.yoloArgsTemplate ? JSON.stringify(preset.yoloArgsTemplate) : null, now, preset.id);
+    }
+};

package/dist/src/server/sqlite-schema-v12.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion12: (db: Database) => void;

package/dist/src/server/sqlite-schema-v12.js

@@ -0,0 +1,21 @@
+import { CODER_ROLE_DESCRIPTION, ORCHESTRATOR_ROLE_DESCRIPTION, REVIEWER_ROLE_DESCRIPTION, TESTER_ROLE_DESCRIPTION, } from './role-templates.js';
+const BUILTIN_ROLE_DESCRIPTIONS = [
+    ['orchestrator', ORCHESTRATOR_ROLE_DESCRIPTION],
+    ['coder', CODER_ROLE_DESCRIPTION],
+    ['reviewer', REVIEWER_ROLE_DESCRIPTION],
+    ['tester', TESTER_ROLE_DESCRIPTION],
+];
+export const applySchemaVersion12 = (db) => {
+    const table = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'role_templates'")
+        .get();
+    if (!table)
+        return;
+    const updateTemplate = db.prepare(`UPDATE role_templates
+     SET description = ?, updated_at = ?
+     WHERE id = ? AND is_builtin = 1`);
+    const now = Date.now();
+    for (const [id, description] of BUILTIN_ROLE_DESCRIPTIONS) {
+        updateTemplate.run(description, now, id);
+    }
+};

package/dist/src/server/sqlite-schema-v13.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion13: (db: Database) => void;

package/dist/src/server/sqlite-schema-v13.js

@@ -0,0 +1,4 @@
+import { applySchemaVersion12 } from './sqlite-schema-v12.js';
+export const applySchemaVersion13 = (db) => {
+    applySchemaVersion12(db);
+};

package/dist/src/server/sqlite-schema-v14.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion14: (db: Database) => void;

package/dist/src/server/sqlite-schema-v14.js

@@ -0,0 +1,84 @@
+import { randomUUID } from 'node:crypto';
+export const applySchemaVersion14 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS dispatches (
+      sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL UNIQUE,
+      workspace_id TEXT NOT NULL,
+      from_agent_id TEXT,
+      to_agent_id TEXT NOT NULL,
+      text TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      delivered_at INTEGER,
+      submitted_at INTEGER,
+      reported_at INTEGER,
+      report_text TEXT,
+      artifacts TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_dispatches_workspace_created_at
+      ON dispatches (workspace_id, sequence);
+
+    CREATE INDEX IF NOT EXISTS idx_dispatches_open_by_worker
+      ON dispatches (workspace_id, to_agent_id, status, sequence);
+  `);
+    backfillDispatchesFromMessages(db);
+};
+const backfillDispatchesFromMessages = (db) => {
+    const existing = db.prepare('SELECT COUNT(*) AS count FROM dispatches').get();
+    if (existing.count > 0)
+        return;
+    const messages = db
+        .prepare(`SELECT
+         workspace_id,
+         worker_id,
+         type,
+         from_agent_id,
+         to_agent_id,
+         text,
+         artifacts,
+         created_at
+       FROM messages
+       WHERE type IN ('send', 'report')
+       ORDER BY sequence ASC`)
+        .all();
+    if (messages.length === 0)
+        return;
+    const insertDispatch = db.prepare(`INSERT INTO dispatches (
+       id,
+       workspace_id,
+       from_agent_id,
+       to_agent_id,
+       text,
+       status,
+       created_at,
+       artifacts
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+    const markReported = db.prepare(`UPDATE dispatches
+     SET status = 'reported',
+         reported_at = ?,
+         report_text = ?,
+         artifacts = ?
+     WHERE id = ?`);
+    const openByWorker = new Map();
+    const backfill = db.transaction(() => {
+        for (const message of messages) {
+            const queueKey = `${message.workspace_id}:${message.worker_id}`;
+            if (message.type === 'send') {
+                const dispatchId = randomUUID();
+                insertDispatch.run(dispatchId, message.workspace_id, message.from_agent_id, message.to_agent_id ?? message.worker_id, message.text ?? '', 'queued', message.created_at, '[]');
+                const queue = openByWorker.get(queueKey) ?? [];
+                queue.push(dispatchId);
+                openByWorker.set(queueKey, queue);
+                continue;
+            }
+            const queue = openByWorker.get(queueKey);
+            const dispatchId = queue?.shift();
+            if (!dispatchId)
+                continue;
+            markReported.run(message.created_at, message.text ?? '', message.artifacts ?? '[]', dispatchId);
+        }
+    });
+    backfill();
+};

package/dist/src/server/sqlite-schema-v15.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion15: (db: Database) => void;

package/dist/src/server/sqlite-schema-v15.js

@@ -0,0 +1,73 @@
+const getDispatchColumns = (db) => new Set(db.prepare('PRAGMA table_info(dispatches)').all().map((column) => column.name));
+const createDispatchIndexes = (db) => {
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_dispatches_workspace_created_at
+      ON dispatches (workspace_id, sequence);
+
+    CREATE INDEX IF NOT EXISTS idx_dispatches_open_by_worker
+      ON dispatches (workspace_id, to_agent_id, status, sequence);
+  `);
+};
+export const applySchemaVersion15 = (db) => {
+    const dispatchColumns = getDispatchColumns(db);
+    if (dispatchColumns.size === 0)
+        return;
+    db.exec(`
+    DROP INDEX IF EXISTS idx_dispatches_workspace_created_at;
+    DROP INDEX IF EXISTS idx_dispatches_open_by_worker;
+  `);
+    if (!dispatchColumns.has('sequence')) {
+        db.exec(`
+      ALTER TABLE dispatches RENAME TO dispatches_legacy_v15;
+
+      CREATE TABLE dispatches (
+        sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE,
+        workspace_id TEXT NOT NULL,
+        from_agent_id TEXT,
+        to_agent_id TEXT NOT NULL,
+        text TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        delivered_at INTEGER,
+        submitted_at INTEGER,
+        reported_at INTEGER,
+        report_text TEXT,
+        artifacts TEXT
+      );
+
+      INSERT INTO dispatches (
+        id,
+        workspace_id,
+        from_agent_id,
+        to_agent_id,
+        text,
+        status,
+        created_at,
+        delivered_at,
+        submitted_at,
+        reported_at,
+        report_text,
+        artifacts
+      )
+      SELECT
+        id,
+        workspace_id,
+        from_agent_id,
+        to_agent_id,
+        text,
+        status,
+        created_at,
+        delivered_at,
+        submitted_at,
+        reported_at,
+        report_text,
+        artifacts
+      FROM dispatches_legacy_v15
+      ORDER BY created_at ASC, rowid ASC;
+
+      DROP TABLE dispatches_legacy_v15;
+    `);
+    }
+    createDispatchIndexes(db);
+};

package/dist/src/server/sqlite-schema-v16.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion16: (db: Database) => void;

package/dist/src/server/sqlite-schema-v16.js

@@ -0,0 +1,6 @@
+export const applySchemaVersion16 = (db) => {
+    const launchConfigColumns = new Set(db.prepare('PRAGMA table_info(agent_launch_configs)').all().map((column) => column.name));
+    if (!launchConfigColumns.has('preset_augmentation_disabled')) {
+        db.exec('ALTER TABLE agent_launch_configs ADD COLUMN preset_augmentation_disabled INTEGER NOT NULL DEFAULT 0');
+    }
+};

package/dist/src/server/sqlite-schema-v17.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion17: (db: Database) => void;

package/dist/src/server/sqlite-schema-v17.js

@@ -0,0 +1,15 @@
+import { BUILTIN_COMMAND_PRESETS } from './command-preset-defaults.js';
+export const applySchemaVersion17 = (db) => {
+    const commandPresetsTable = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'command_presets'")
+        .get();
+    if (!commandPresetsTable)
+        return;
+    const updatePreset = db.prepare(`UPDATE command_presets
+     SET yolo_args_template = ?, updated_at = ?
+     WHERE id = ? AND is_builtin = 1`);
+    const now = Date.now();
+    for (const preset of BUILTIN_COMMAND_PRESETS) {
+        updatePreset.run(preset.yoloArgsTemplate?.length ? JSON.stringify(preset.yoloArgsTemplate) : null, now, preset.id);
+    }
+};

package/dist/src/server/sqlite-schema-v18.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion18: (db: Database) => void;

package/dist/src/server/sqlite-schema-v18.js

@@ -0,0 +1,6 @@
+export const applySchemaVersion18 = (db) => {
+    const columns = new Set(db.prepare('PRAGMA table_info(agent_launch_configs)').all().map((column) => column.name));
+    if (!columns.has('interactive_command')) {
+        db.exec('ALTER TABLE agent_launch_configs ADD COLUMN interactive_command TEXT');
+    }
+};

package/dist/src/server/sqlite-schema-v19.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion19: (db: Database) => void;

package/dist/src/server/sqlite-schema-v19.js

@@ -0,0 +1,17 @@
+export const applySchemaVersion19 = (db) => {
+    const workerColumns = new Set(db.prepare('PRAGMA table_info(workers)').all().map((c) => c.name));
+    if (!workerColumns.has('ephemeral')) {
+        db.exec('ALTER TABLE workers ADD COLUMN ephemeral INTEGER NOT NULL DEFAULT 0');
+    }
+    if (!workerColumns.has('spawned_by')) {
+        db.exec('ALTER TABLE workers ADD COLUMN spawned_by TEXT');
+    }
+    const dispatchColumns = new Set(db.prepare('PRAGMA table_info(dispatches)').all().map((c) => c.name));
+    if (!dispatchColumns.has('workflow_run_id')) {
+        db.exec('ALTER TABLE dispatches ADD COLUMN workflow_run_id TEXT');
+    }
+    if (!dispatchColumns.has('step_index')) {
+        db.exec('ALTER TABLE dispatches ADD COLUMN step_index INTEGER');
+    }
+    db.exec('CREATE INDEX IF NOT EXISTS idx_dispatches_workflow ON dispatches (workflow_run_id, step_index)');
+};

package/dist/src/server/sqlite-schema-v20.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion20: (db: Database) => void;

package/dist/src/server/sqlite-schema-v20.js

@@ -0,0 +1,20 @@
+export const applySchemaVersion20 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      script_hash TEXT,
+      name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      phase TEXT,
+      args TEXT,
+      started_at INTEGER NOT NULL,
+      finished_at INTEGER,
+      error TEXT,
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_workspace
+      ON workflow_runs (workspace_id, created_at);
+  `);
+};

package/dist/src/server/sqlite-schema-v21.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion21: (db: Database) => void;

package/dist/src/server/sqlite-schema-v21.js

@@ -0,0 +1,20 @@
+export const applySchemaVersion21 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_schedules (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      cron TEXT NOT NULL,
+      args TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at INTEGER,
+      next_run_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_due
+      ON workflow_schedules (enabled, next_run_at);
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_workspace
+      ON workflow_schedules (workspace_id, created_at);
+  `);
+};

package/dist/src/server/sqlite-schema-v22.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion22: (db: Database) => void;

package/dist/src/server/sqlite-schema-v22.js

@@ -0,0 +1,27 @@
+const HERMES_SESSION_ID_CAPTURE = {
+    pattern: String.raw `Session:\s*([A-Za-z0-9_-]+)`,
+    source: 'stdout_regex',
+};
+const HERMES_YOLO_ARGS = ['--yolo'];
+export const applySchemaVersion22 = (db) => {
+    const hasCommandPresets = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'command_presets'")
+        .get();
+    if (!hasCommandPresets)
+        return;
+    const now = Date.now();
+    db.prepare(`INSERT INTO command_presets (
+       id, display_name, command, args, env, resume_args_template, session_id_capture,
+       yolo_args_template, is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       display_name = excluded.display_name,
+       command = excluded.command,
+       args = excluded.args,
+       env = excluded.env,
+       resume_args_template = excluded.resume_args_template,
+       session_id_capture = excluded.session_id_capture,
+       yolo_args_template = excluded.yolo_args_template,
+       updated_at = excluded.updated_at
+    WHERE command_presets.is_builtin = 1`).run('hermes', 'Hermes', 'hermes', '[]', '{}', '--resume {session_id}', JSON.stringify(HERMES_SESSION_ID_CAPTURE), JSON.stringify(HERMES_YOLO_ARGS), now, now);
+};

package/dist/src/server/sqlite-schema-v23.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion23: (db: Database) => void;