hivehq 2.0.0

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

@@ -0,0 +1,43 @@
+// v23 — remote-access (mobile) audit trail. The tunnel/bridge layer is the
+// SINGLE collection point for every remote HTTP request + WS-input event
+// (see the plan's 审计规格): one place to record so no per-route handler has
+// to know about remote at all. Rows are append-only and written async off the
+// forwarding path (remote-audit-store.ts), so a slow disk never stalls a frame.
+//
+// Schema notes:
+//   - remote_device_id is the M1 session's device id; it's an audit/revocation
+//     tag, NEVER a permission branch (Authority Model: paired device == local).
+//   - action is a coarse category, not a full URL ('http' for bridged API
+//     requests, 'ws_input' for terminal/tasks stdin, plus lifecycle/control
+//     actions like 'session_open' / 'revoke' / 'reject'). endpoint holds the
+//     whitelisted path ('/api/...' '/ws/...') when there is one.
+//   - result is 'ok' | 'rejected' | 'error'. reject_reason is set ONLY on a
+//     rejection (off-whitelist path, revoked device, forged secret, …) so the
+//     security tests can assert the reason text, not just that a row exists.
+//   - WS input is summarised: byte_count + a short truncated preview. We NEVER
+//     persist full stdin (that's the user typing into a YOLO terminal). The
+//     preview is bounded by the store before it reaches here.
+//
+// Index covers the Settings audit-stream view: newest-first, optionally scoped
+// to one device.
+export const applySchemaVersion23 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS remote_audit (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      remote_device_id TEXT,
+      ts INTEGER NOT NULL,
+      workspace_id TEXT,
+      action TEXT NOT NULL,
+      endpoint TEXT,
+      result TEXT NOT NULL,
+      reject_reason TEXT,
+      byte_count INTEGER,
+      preview TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_remote_audit_recent
+      ON remote_audit (id DESC);
+    CREATE INDEX IF NOT EXISTS idx_remote_audit_device
+      ON remote_audit (remote_device_id, id DESC);
+  `);
+};

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

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

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

@@ -0,0 +1,34 @@
+// v24 — paired remote devices. A row exists ONLY after a human confirmed the pairing at the desktop
+// (Authority Model trust root): the pending handshake lives in memory in remote-pairing.ts and is
+// INSERTed here on confirm, NEVER before.
+//
+// key_d2p/key_p2d are the M3 DeviceSession.keys — M6.1 reinterprets these as the directional ROOT keys:
+// the bridge derives a fresh per-connection AEAD key from them on every connect (deriveConnectionKeys)
+// and never seals/opens under the stored bytes directly. The at-rest format is byte-identical — no
+// schema change, no version bump; v24 rows are forward-compatible (their stored material IS the root).
+// They are a stored secret in the sense that they decrypt all of that device's E2E traffic, but the
+// protection here is
+// exactly the same filesystem-local posture as remote_daemon_token (plaintext in app_state, see
+// remote-config-keys.ts): the runtime.sqlite file lives next to the daemon on 127.0.0.1. This is NOT
+// encryption-at-rest. If at-rest encryption is later wanted it should cover daemon_token + these keys
+// together as a single hardening item, not be implied here.
+//
+// revoked_at != NULL = dead device: the persistent provider returns null for it at once (live streams
+// drop on the next frame). Rows are kept (soft tombstone) so the device list / audit can still show a
+// revoked device.
+export const applySchemaVersion24 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS remote_devices (
+      id            TEXT PRIMARY KEY,
+      name          TEXT NOT NULL,
+      key_d2p       TEXT NOT NULL,   -- base64url(32) daemon->phone (daemon SEALS)
+      key_p2d       TEXT NOT NULL,   -- base64url(32) phone->daemon (daemon OPENS)
+      device_pubkey TEXT NOT NULL,   -- base64url(32); audit/debug, not secret
+      created_at    INTEGER NOT NULL,
+      last_active   INTEGER,
+      revoked_at    INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_remote_devices_active
+      ON remote_devices (revoked_at, created_at DESC);
+  `);
+};

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

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

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

@@ -0,0 +1,127 @@
+const tableExists = (db, table) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+const quoteFtsToken = (value) => `"${value.replaceAll('"', '""')}"`;
+const firstUnicodeTerm = (value) => {
+    if (!value)
+        return null;
+    const token = value.trim().split(/\s+/).find(Boolean);
+    if (!token)
+        return null;
+    return token;
+};
+const firstTrigramTerm = (value) => {
+    const token = firstUnicodeTerm(value);
+    if (!token)
+        return null;
+    return [...token].slice(0, Math.max(1, Math.min(3, [...token].length))).join('');
+};
+const ftsHasSampleHit = (db, table, term) => db
+    .prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE ${table} MATCH ?`)
+    .get(quoteFtsToken(term)).count > 0;
+const shouldRebuildMessageIndexes = (db) => {
+    const sample = db
+        .prepare(`SELECT text
+       FROM messages
+       ORDER BY sequence ASC
+       LIMIT 1`)
+        .get();
+    if (!sample)
+        return false;
+    const unicodeTerm = firstUnicodeTerm(sample.text);
+    const trigramTerm = firstTrigramTerm(sample.text);
+    if (!unicodeTerm && !trigramTerm)
+        return false;
+    const unicodeHealthy = unicodeTerm ? ftsHasSampleHit(db, 'messages_fts', unicodeTerm) : true;
+    const trigramHealthy = trigramTerm
+        ? ftsHasSampleHit(db, 'messages_fts_trigram', trigramTerm)
+        : true;
+    return !(unicodeHealthy && trigramHealthy);
+};
+const shouldRebuildDispatchIndexes = (db) => {
+    const sample = db
+        .prepare(`SELECT text, report_text
+       FROM dispatches
+       ORDER BY sequence ASC
+       LIMIT 1`)
+        .get();
+    if (!sample)
+        return false;
+    const unicodeTerm = firstUnicodeTerm(sample.text) ?? firstUnicodeTerm(sample.report_text);
+    const trigramTerm = firstTrigramTerm(sample.text) ?? firstTrigramTerm(sample.report_text);
+    if (!unicodeTerm && !trigramTerm)
+        return false;
+    const unicodeHealthy = unicodeTerm ? ftsHasSampleHit(db, 'dispatches_fts', unicodeTerm) : true;
+    const trigramHealthy = trigramTerm
+        ? ftsHasSampleHit(db, 'dispatches_fts_trigram', trigramTerm)
+        : true;
+    return !(unicodeHealthy && trigramHealthy);
+};
+export const applySchemaVersion25 = (db) => {
+    const messagesFtsExists = tableExists(db, 'messages_fts');
+    const messagesFtsTrigramExists = tableExists(db, 'messages_fts_trigram');
+    const dispatchesFtsExists = tableExists(db, 'dispatches_fts');
+    const dispatchesFtsTrigramExists = tableExists(db, 'dispatches_fts_trigram');
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts
+      USING fts5(text, content='messages', content_rowid='sequence', tokenize='unicode61');
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts_trigram
+      USING fts5(text, content='messages', content_rowid='sequence', tokenize='trigram');
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS dispatches_fts
+      USING fts5(text, report_text, content='dispatches', content_rowid='sequence', tokenize='unicode61');
+    CREATE VIRTUAL TABLE IF NOT EXISTS dispatches_fts_trigram
+      USING fts5(text, report_text, content='dispatches', content_rowid='sequence', tokenize='trigram');
+
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, text) VALUES (new.sequence, new.text);
+      INSERT INTO messages_fts_trigram(rowid, text) VALUES (new.sequence, new.text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, text) VALUES('delete', old.sequence, old.text);
+      INSERT INTO messages_fts_trigram(messages_fts_trigram, rowid, text)
+        VALUES('delete', old.sequence, old.text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS messages_fts_au AFTER UPDATE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, text) VALUES('delete', old.sequence, old.text);
+      INSERT INTO messages_fts(rowid, text) VALUES (new.sequence, new.text);
+      INSERT INTO messages_fts_trigram(messages_fts_trigram, rowid, text)
+        VALUES('delete', old.sequence, old.text);
+      INSERT INTO messages_fts_trigram(rowid, text) VALUES (new.sequence, new.text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS dispatches_fts_ai AFTER INSERT ON dispatches BEGIN
+      INSERT INTO dispatches_fts(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+      INSERT INTO dispatches_fts_trigram(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS dispatches_fts_ad AFTER DELETE ON dispatches BEGIN
+      INSERT INTO dispatches_fts(dispatches_fts, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+      INSERT INTO dispatches_fts_trigram(dispatches_fts_trigram, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+    END;
+    CREATE TRIGGER IF NOT EXISTS dispatches_fts_au AFTER UPDATE ON dispatches BEGIN
+      INSERT INTO dispatches_fts(dispatches_fts, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+      INSERT INTO dispatches_fts(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+      INSERT INTO dispatches_fts_trigram(dispatches_fts_trigram, rowid, text, report_text)
+        VALUES('delete', old.sequence, old.text, old.report_text);
+      INSERT INTO dispatches_fts_trigram(rowid, text, report_text)
+        VALUES (new.sequence, new.text, new.report_text);
+    END;
+  `);
+    if (!messagesFtsExists ||
+        !messagesFtsTrigramExists ||
+        !dispatchesFtsExists ||
+        !dispatchesFtsTrigramExists ||
+        shouldRebuildMessageIndexes(db) ||
+        shouldRebuildDispatchIndexes(db)) {
+        db.exec(`
+      INSERT INTO messages_fts(messages_fts) VALUES('rebuild');
+      INSERT INTO messages_fts_trigram(messages_fts_trigram) VALUES('rebuild');
+      INSERT INTO dispatches_fts(dispatches_fts) VALUES('rebuild');
+      INSERT INTO dispatches_fts_trigram(dispatches_fts_trigram) VALUES('rebuild');
+    `);
+    }
+};

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

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

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

@@ -0,0 +1,56 @@
+export const applySchemaVersion26 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT,
+      scope TEXT NOT NULL DEFAULT 'workspace',
+      fts_rowid INTEGER UNIQUE,
+      kind TEXT NOT NULL,
+      body TEXT NOT NULL,
+      tags TEXT,
+      status TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'manual',
+      confidence REAL,
+      pinned INTEGER NOT NULL DEFAULT 0,
+      disabled INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      archived_at INTEGER,
+      last_injected_at INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_entries_ws_status
+      ON memory_entries(workspace_id, status);
+    CREATE INDEX IF NOT EXISTS idx_memory_entries_ws_updated
+      ON memory_entries(workspace_id, updated_at);
+
+    CREATE TABLE IF NOT EXISTS memory_sources (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL REFERENCES memory_entries(id) ON DELETE CASCADE,
+      source_type TEXT NOT NULL,
+      source_id TEXT,
+      source_sequence INTEGER,
+      excerpt TEXT,
+      text_hash TEXT,
+      actor_agent_id_snapshot TEXT,
+      actor_name_snapshot TEXT,
+      actor_role_snapshot TEXT,
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_sources_memory
+      ON memory_sources(memory_id);
+
+    CREATE TABLE IF NOT EXISTS memory_injections (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL REFERENCES memory_entries(id) ON DELETE CASCADE,
+      workspace_id TEXT,
+      target_agent_id_snapshot TEXT,
+      context_type TEXT NOT NULL,
+      dispatch_id TEXT,
+      injected_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_injections_ws
+      ON memory_injections(workspace_id, injected_at);
+    CREATE INDEX IF NOT EXISTS idx_memory_injections_memory
+      ON memory_injections(memory_id, injected_at);
+  `);
+};

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

@@ -0,0 +1,6 @@
+import type { Database } from 'better-sqlite3';
+interface ApplySchemaVersion27Options {
+    rebuild?: boolean;
+}
+export declare const applySchemaVersion27: (db: Database, options?: ApplySchemaVersion27Options) => void;
+export {};

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

@@ -0,0 +1,92 @@
+const tableExists = (db, table) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+const ensureFtsRowidColumn = (db) => {
+    const columns = new Set(db.prepare('PRAGMA table_info(memory_entries)').all().map((column) => column.name));
+    if (!columns.has('fts_rowid')) {
+        db.exec('ALTER TABLE memory_entries ADD COLUMN fts_rowid INTEGER');
+    }
+    db.exec(`
+    UPDATE memory_entries
+    SET fts_rowid = rowid
+    WHERE fts_rowid IS NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_entries_fts_rowid
+      ON memory_entries(fts_rowid)
+      WHERE fts_rowid IS NOT NULL;
+  `);
+};
+const quoteFtsToken = (value) => `"${value.replaceAll('"', '""')}"`;
+const firstUnicodeTerm = (value) => {
+    if (!value)
+        return null;
+    const token = value.trim().split(/\s+/).find(Boolean);
+    if (!token)
+        return null;
+    return token;
+};
+const firstTrigramTerm = (value) => {
+    const token = firstUnicodeTerm(value);
+    if (!token)
+        return null;
+    return [...token].slice(0, Math.max(1, Math.min(3, [...token].length))).join('');
+};
+const ftsHasSampleHit = (db, table, term) => db
+    .prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE ${table} MATCH ?`)
+    .get(quoteFtsToken(term)).count > 0;
+const shouldRebuildExistingIndex = (db) => {
+    const sample = db
+        .prepare(`SELECT body, tags
+       FROM memory_entries
+       WHERE scope = 'workspace'
+       ORDER BY created_at ASC, id ASC
+       LIMIT 1`)
+        .get();
+    if (!sample)
+        return false;
+    const unicodeTerm = firstUnicodeTerm(sample.body) ?? firstUnicodeTerm(sample.tags);
+    const trigramTerm = firstTrigramTerm(sample.body) ?? firstTrigramTerm(sample.tags);
+    if (!unicodeTerm && !trigramTerm)
+        return false;
+    const unicodeHealthy = unicodeTerm ? ftsHasSampleHit(db, 'memory_fts', unicodeTerm) : true;
+    const trigramHealthy = trigramTerm ? ftsHasSampleHit(db, 'memory_fts_trigram', trigramTerm) : true;
+    return !(unicodeHealthy && trigramHealthy);
+};
+export const applySchemaVersion27 = (db, options = {}) => {
+    ensureFtsRowidColumn(db);
+    const memoryFtsExists = tableExists(db, 'memory_fts');
+    const memoryFtsTrigramExists = tableExists(db, 'memory_fts_trigram');
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts
+      USING fts5(body, tags, content='memory_entries', content_rowid='fts_rowid', tokenize='unicode61');
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts_trigram
+      USING fts5(body, tags, content='memory_entries', content_rowid='fts_rowid', tokenize='trigram');
+
+    CREATE TRIGGER IF NOT EXISTS memory_fts_ai AFTER INSERT ON memory_entries BEGIN
+      INSERT INTO memory_fts(rowid, body, tags) VALUES (new.fts_rowid, new.body, new.tags);
+      INSERT INTO memory_fts_trigram(rowid, body, tags)
+        VALUES (new.fts_rowid, new.body, new.tags);
+    END;
+    CREATE TRIGGER IF NOT EXISTS memory_fts_ad AFTER DELETE ON memory_entries BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+      INSERT INTO memory_fts_trigram(memory_fts_trigram, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+    END;
+    CREATE TRIGGER IF NOT EXISTS memory_fts_au AFTER UPDATE ON memory_entries BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+      INSERT INTO memory_fts(rowid, body, tags) VALUES (new.fts_rowid, new.body, new.tags);
+      INSERT INTO memory_fts_trigram(memory_fts_trigram, rowid, body, tags)
+        VALUES('delete', old.fts_rowid, old.body, old.tags);
+      INSERT INTO memory_fts_trigram(rowid, body, tags)
+        VALUES (new.fts_rowid, new.body, new.tags);
+    END;
+  `);
+    if (options.rebuild === true ||
+        !memoryFtsExists ||
+        !memoryFtsTrigramExists ||
+        shouldRebuildExistingIndex(db)) {
+        db.exec(`
+      INSERT INTO memory_fts(memory_fts) VALUES('rebuild');
+      INSERT INTO memory_fts_trigram(memory_fts_trigram) VALUES('rebuild');
+    `);
+    }
+};

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

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

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

@@ -0,0 +1,19 @@
+export const applySchemaVersion28 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS dream_runs (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      trigger TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      finished_at INTEGER,
+      input_seq_from INTEGER,
+      input_seq_to INTEGER,
+      report TEXT,
+      revert_blob TEXT,
+      error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_dream_runs_ws
+      ON dream_runs(workspace_id, started_at);
+  `);
+};

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

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

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

@@ -0,0 +1,61 @@
+const legacyMessageTypeColumn = 'kind';
+export const applySchemaVersion5 = (db) => {
+    const workerColumns = new Set(db.prepare('PRAGMA table_info(workers)').all().map((column) => column.name));
+    if (workerColumns.size > 0 && !workerColumns.has('last_session_id')) {
+        db.exec('ALTER TABLE workers ADD COLUMN last_session_id TEXT');
+    }
+    const agentRunColumns = new Set(db.prepare('PRAGMA table_info(agent_runs)').all().map((column) => column.name));
+    if (agentRunColumns.size > 0 && !agentRunColumns.has('pid')) {
+        db.exec('ALTER TABLE agent_runs ADD COLUMN pid INTEGER');
+    }
+    if (agentRunColumns.size > 0 && !agentRunColumns.has('ended_at')) {
+        db.exec('ALTER TABLE agent_runs ADD COLUMN ended_at INTEGER');
+    }
+    const messageColumns = new Set(db.prepare('PRAGMA table_info(messages)').all().map((column) => column.name));
+    if (!messageColumns.has(legacyMessageTypeColumn)) {
+        return;
+    }
+    db.exec(`
+    ALTER TABLE messages RENAME TO messages_legacy;
+
+    CREATE TABLE messages (
+      sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      worker_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      from_agent_id TEXT,
+      to_agent_id TEXT,
+      text TEXT,
+      status TEXT,
+      artifacts TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    INSERT INTO messages (
+      sequence,
+      workspace_id,
+      worker_id,
+      type,
+      from_agent_id,
+      to_agent_id,
+      text,
+      status,
+      artifacts,
+      created_at
+    )
+    SELECT
+      sequence,
+      workspace_id,
+      worker_id,
+      type,
+      from_agent_id,
+      to_agent_id,
+      text,
+      status,
+      artifacts,
+      created_at
+    FROM messages_legacy;
+
+    DROP TABLE messages_legacy;
+  `);
+};

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

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

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

@@ -0,0 +1,70 @@
+import { BUILTIN_COMMAND_PRESETS } from './command-preset-defaults.js';
+import { CODER_ROLE_DESCRIPTION, ORCHESTRATOR_ROLE_DESCRIPTION, REVIEWER_ROLE_DESCRIPTION, TESTER_ROLE_DESCRIPTION, } from './role-templates.js';
+export const applySchemaVersion7 = (db) => {
+    const now = Date.now();
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS command_presets (
+      id TEXT PRIMARY KEY,
+      display_name TEXT NOT NULL,
+      command TEXT NOT NULL,
+      args TEXT NOT NULL,
+      env TEXT NOT NULL,
+      resume_args_template TEXT,
+      session_id_capture TEXT,
+      yolo_args_template TEXT,
+      is_builtin INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS role_templates (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      role_type TEXT NOT NULL,
+      description TEXT NOT NULL,
+      default_command TEXT NOT NULL,
+      default_args TEXT NOT NULL,
+      default_env TEXT NOT NULL,
+      is_builtin INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS app_state (
+      key TEXT PRIMARY KEY,
+      value TEXT,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+    const insertPreset = 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 NOTHING`);
+    for (const preset of BUILTIN_COMMAND_PRESETS) {
+        insertPreset.run(preset.id, preset.displayName, preset.command, '[]', '{}', preset.resumeArgsTemplate, preset.sessionIdCapture ? JSON.stringify(preset.sessionIdCapture) : null, preset.yoloArgsTemplate ? JSON.stringify(preset.yoloArgsTemplate) : null, now, now);
+    }
+    db.prepare(`INSERT INTO role_templates (
+       id, name, role_type, description, default_command, default_args, default_env,
+       is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run('orchestrator', 'Orchestrator', 'orchestrator', ORCHESTRATOR_ROLE_DESCRIPTION, 'claude', '[]', '{}', now, now);
+    db.prepare(`INSERT INTO role_templates (
+       id, name, role_type, description, default_command, default_args, default_env,
+       is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run('coder', 'Coder', 'coder', CODER_ROLE_DESCRIPTION, 'claude', '[]', '{}', now, now);
+    db.prepare(`INSERT INTO role_templates (
+       id, name, role_type, description, default_command, default_args, default_env,
+       is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run('reviewer', 'Reviewer', 'reviewer', REVIEWER_ROLE_DESCRIPTION, 'claude', '[]', '{}', now, now);
+    db.prepare(`INSERT INTO role_templates (
+       id, name, role_type, description, default_command, default_args, default_env,
+       is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run('tester', 'Tester', 'tester', TESTER_ROLE_DESCRIPTION, 'claude', '[]', '{}', now, now);
+    db.prepare(`INSERT INTO app_state (key, value, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(key) DO NOTHING`).run('active_workspace_id', null, now);
+};

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { CLAUDE_DEFAULT_YOLO_ARGS } from './claude-command-defaults.js';
+export const applySchemaVersion9 = (db) => {
+    db.prepare(`UPDATE command_presets
+     SET yolo_args_template = ?, updated_at = ?
+     WHERE id = ? AND is_builtin = 1`).run(JSON.stringify(CLAUDE_DEFAULT_YOLO_ARGS), Date.now(), 'claude');
+};

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

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