@dotdrelle/wiki-manager 0.7.3 → 0.8.2

package/src/runtime/server.test.js

@@ -31,6 +31,7 @@ test('runtime server accepts only one active run', async (t) => {
 
   try {
     const url = `http://127.0.0.1:${handle.port}/run`;
+    let acceptedRun = null;
     const [first, second] = await Promise.all([
       fetch(url, {
         method: 'POST',
@@ -45,9 +46,263 @@ test('runtime server accepts only one active run', async (t) => {
     ]);
 
     assert.deepEqual([first.status, second.status].sort(), [202, 409]);
+    const accepted = first.status === 202 ? first : second;
+    acceptedRun = await accepted.json();
+    assert.equal(acceptedRun.accepted, true);
+    assert.match(acceptedRun.runId, /^[0-9a-f-]{36}$/);
     assert.equal(runCount, 1);
   } finally {
     releaseRun?.();
     await handle.close();
   }
 });
+
+test('runtime server returns the accepted run id and passes it to the runner', async (t) => {
+  let receivedBody = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async (context, body) => {
+        receivedBody = body;
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/run`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'build', workspace: 'juno', evaluate: false, replans: 1 }),
+    });
+    assert.equal(response.status, 202);
+    const body = await response.json();
+    assert.equal(body.accepted, true);
+    assert.match(body.runId, /^[0-9a-f-]{36}$/);
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(receivedBody.runId, body.runId);
+    assert.equal(receivedBody.workspace, 'juno');
+    assert.equal(receivedBody.evaluate, false);
+    assert.equal(receivedBody.replans, 1);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server isolates active runs by workspace', async (t) => {
+  const releases = new Map();
+  const runWorkspaces = [];
+  const contexts = new Map();
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: (session) => ({ status: session?.running ? 'running' : 'idle' }),
+        listEvents: () => [],
+      },
+      getContext: async (workspace) => {
+        if (!contexts.has(workspace)) {
+          contexts.set(workspace, {
+            workspace,
+            session: { workspace },
+            running: false,
+            currentAbortController: null,
+          });
+        }
+        return contexts.get(workspace);
+      },
+      run: async (context) => {
+        runWorkspaces.push(context.workspace);
+        context.session.running = true;
+        await new Promise((resolve) => { releases.set(context.workspace, resolve); });
+        context.session.running = false;
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/run`;
+    const [juno, docs] = await Promise.all([
+      fetch(`${url}?workspace=juno`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'first' }),
+      }),
+      fetch(`${url}?workspace=docs`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'second' }),
+      }),
+    ]);
+    assert.deepEqual([juno.status, docs.status], [202, 202]);
+
+    const conflict = await fetch(`${url}?workspace=juno`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'third' }),
+    });
+    assert.equal(conflict.status, 409);
+    assert.deepEqual(runWorkspaces.sort(), ['docs', 'juno']);
+  } finally {
+    releases.get('juno')?.();
+    releases.get('docs')?.();
+    await handle.close();
+  }
+});
+
+test('runtime server filters state and events by workspace', async (t) => {
+  let stateWorkspace = null;
+  let eventWorkspace = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: (_session, options) => {
+          stateWorkspace = options.workspace;
+          return { status: 'idle', workspace: options.workspace };
+        },
+        listEvents: (options) => {
+          eventWorkspace = options.workspace;
+          return [{ id: 'e1', workspace: options.workspace }];
+        },
+      },
+      getContext: async (workspace) => ({
+        workspace,
+        session: { workspace },
+        running: false,
+        currentAbortController: null,
+      }),
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const state = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=juno`);
+    assert.equal(state.status, 200);
+    assert.equal((await state.json()).workspace, 'juno');
+    assert.equal(stateWorkspace, 'juno');
+
+    const events = await fetch(`http://127.0.0.1:${handle.port}/events?workspace=docs`);
+    assert.equal(events.status, 200);
+    assert.deepEqual(await events.json(), { events: [{ id: 'e1', workspace: 'docs' }] });
+    assert.equal(eventWorkspace, 'docs');
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server exposes manual resume endpoint', async (t) => {
+  let resumedWorkspace = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      run: async () => {},
+      resume: async ({ workspace }) => {
+        resumedWorkspace = workspace;
+        return { resumed: 1, interrupted: 0, workspaces: [{ workspace, resumed: true }] };
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/resume?workspace=juno`, {
+      method: 'POST',
+    });
+    assert.equal(response.status, 202);
+    assert.equal(resumedWorkspace, 'juno');
+    assert.deepEqual(await response.json(), {
+      resumed: 1,
+      interrupted: 0,
+      workspaces: [{ workspace: 'juno', resumed: true }],
+    });
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server exposes approval endpoint', async (t) => {
+  let approved = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      run: async () => {},
+      approve: async (request) => {
+        approved = request;
+        return { approved: true, runId: request.runId, itemId: request.itemId };
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/approve?workspace=juno&runId=run-1&itemId=item-1`, {
+      method: 'POST',
+    });
+    assert.equal(response.status, 202);
+    assert.deepEqual(approved, {
+      workspace: 'juno',
+      runId: 'run-1',
+      itemId: 'item-1',
+      approvalId: null,
+    });
+    assert.deepEqual(await response.json(), { approved: true, runId: 'run-1', itemId: 'item-1' });
+  } finally {
+    await handle.close();
+  }
+});

package/src/runtime/store.js

@@ -3,17 +3,23 @@ import { dirname, join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { applyAgentProjectionToSession, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
 import { defaultRuntimeStateDir } from '../core/env.js';
+import { projectQueue } from '../core/jobQueue.js';
 
 export { defaultRuntimeStateDir };
 
 const NON_PERSISTED_EVENT_TYPES = new Set(['runtime_log']);
 
-const RUN_STATUS_BY_TERMINAL_EVENT = {
+const RUN_STATUS_BY_EVENT = {
   run_done: 'done',
   run_error: 'error',
   run_cancelled: 'cancelled',
+  run_pending_approval: 'pending_approval',
+  run_approved: 'running',
 };
 
+const RECOVERABLE_RUN_STATUSES = ['running', 'waiting', 'pending_approval'];
+export const RECOVERABLE_QUEUE_STATUSES = ['waiting', 'queued', 'starting', 'running', 'blocked', 'pending_approval'];
+
 export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName = 'runtime.db' } = {}) {
   const resolvedStateDir = resolve(stateDir);
   mkdirSync(resolvedStateDir, { recursive: true });
@@ -23,11 +29,13 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   db.exec('PRAGMA foreign_keys = ON');
   db.exec(`
     CREATE TABLE IF NOT EXISTS events (
-      id TEXT PRIMARY KEY,
+      sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL UNIQUE,
       ts TEXT NOT NULL,
       type TEXT NOT NULL,
       run_id TEXT,
       turn_id TEXT,
+      workspace TEXT,
       origin TEXT,
       payload TEXT NOT NULL
     );
@@ -35,6 +43,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     CREATE INDEX IF NOT EXISTS idx_events_run_id ON events(run_id);
     CREATE TABLE IF NOT EXISTS runs (
       id TEXT PRIMARY KEY,
+      workspace TEXT,
       status TEXT NOT NULL,
       input TEXT,
       created_at TEXT NOT NULL,
@@ -58,31 +67,69 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       updated_at TEXT NOT NULL
     );
   `);
+  ensureColumn(db, 'events', 'sequence', 'INTEGER');
+  ensureColumn(db, 'events', 'workspace', 'TEXT');
+  ensureColumn(db, 'runs', 'workspace', 'TEXT');
+  backfillEventSequence(db);
+  db.exec('CREATE INDEX IF NOT EXISTS idx_events_workspace ON events(workspace)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_events_sequence ON events(sequence)');
 
   let lastEventId = null;
+  let lastEventSequence = null;
 
   const insertEvent = db.prepare(`
-    INSERT OR IGNORE INTO events (id, ts, type, run_id, turn_id, origin, payload)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
+    INSERT OR IGNORE INTO events (sequence, id, ts, type, run_id, turn_id, workspace, origin, payload)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
+  const nextEventSequenceStatement = db.prepare('SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence FROM events');
   const listEventsStatement = db.prepare(`
-    SELECT id, ts, type, run_id, turn_id, origin, payload
+    SELECT sequence, id, ts, type, run_id, turn_id, workspace, origin, payload
+    FROM events
+    ORDER BY sequence ASC
+  `);
+  const listEventsByWorkspaceStatement = db.prepare(`
+    SELECT sequence, id, ts, type, run_id, turn_id, workspace, origin, payload
     FROM events
-    ORDER BY ts ASC, id ASC
+    WHERE workspace = ?
+    ORDER BY sequence ASC
   `);
   const upsertRun = db.prepare(`
-    INSERT INTO runs (id, status, input, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?)
+    INSERT INTO runs (id, workspace, status, input, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
     ON CONFLICT(id) DO UPDATE SET
+      workspace = COALESCE(excluded.workspace, runs.workspace),
       status = excluded.status,
       input = COALESCE(excluded.input, runs.input),
       updated_at = excluded.updated_at
   `);
   const listRunsStatement = db.prepare(`
-    SELECT id, status, input, created_at, updated_at
+    SELECT id, workspace, status, input, created_at, updated_at
     FROM runs
     ORDER BY created_at DESC
   `);
+  const listRunsByWorkspaceStatement = db.prepare(`
+    SELECT id, workspace, status, input, created_at, updated_at
+    FROM runs
+    WHERE workspace = ?
+    ORDER BY created_at DESC
+  `);
+  const listRecoverableRunsStatement = db.prepare(`
+    SELECT id, workspace, status, input, created_at, updated_at
+    FROM runs
+    WHERE status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
+    ORDER BY created_at ASC
+  `);
+  const listRecoverableRunsByWorkspaceStatement = db.prepare(`
+    SELECT id, workspace, status, input, created_at, updated_at
+    FROM runs
+    WHERE workspace = ? AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
+    ORDER BY created_at ASC
+  `);
+  const interruptRunsStatement = db.prepare(`
+    UPDATE runs
+    SET status = 'interrupted', updated_at = ?
+    WHERE workspace = ? AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
+  `);
   const upsertQueueItem = db.prepare(`
     INSERT INTO queue_items (
       id, workspace, server, tool, args, lock_key, status, reason, job_id, activity_key,
@@ -109,6 +156,11 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     DELETE FROM queue_items
     WHERE id NOT IN (SELECT value FROM json_each(?))
   `);
+  const deleteMissingQueueItemsForWorkspace = db.prepare(`
+    DELETE FROM queue_items
+    WHERE workspace = ? AND id NOT IN (SELECT value FROM json_each(?))
+  `);
+  const clearQueueItemsForWorkspace = db.prepare('DELETE FROM queue_items WHERE workspace = ?');
   const clearQueueItems = db.prepare('DELETE FROM queue_items');
   const listQueueStatement = db.prepare(`
     SELECT id, workspace, server, tool, args, lock_key, status, reason, job_id, activity_key,
@@ -116,33 +168,58 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     FROM queue_items
     ORDER BY COALESCE(created_at, updated_at) ASC, id ASC
   `);
+  const listQueueByWorkspaceStatement = db.prepare(`
+    SELECT id, workspace, server, tool, args, lock_key, status, reason, job_id, activity_key,
+      error, created_at, started_at, finished_at, updated_at
+    FROM queue_items
+    WHERE workspace = ?
+    ORDER BY COALESCE(created_at, updated_at) ASC, id ASC
+  `);
+  const listRecoverableWorkspacesStatement = db.prepare(`
+    SELECT DISTINCT workspace FROM runs
+    WHERE workspace IS NOT NULL AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
+    UNION
+    SELECT DISTINCT workspace FROM queue_items
+    WHERE workspace IS NOT NULL AND status IN (${RECOVERABLE_QUEUE_STATUSES.map(() => '?').join(', ')})
+    ORDER BY workspace
+  `);
 
   function persistEvent(event) {
     if (NON_PERSISTED_EVENT_TYPES.has(event.type)) return event;
-    insertEvent.run(
+    const ws = event.workspace ?? event.payload?.workspace ?? null;
+    const sequence = nextEventSequenceStatement.get().next_sequence;
+    const result = insertEvent.run(
+      sequence,
       event.id,
       event.ts,
       event.type,
       event.runId ?? null,
       event.turnId ?? null,
+      ws,
       event.origin ?? null,
       JSON.stringify(event.payload ?? {}),
     );
-    lastEventId = event.id;
+    if (Number(result.changes ?? 0) > 0) {
+      event.sequence = sequence;
+      lastEventId = event.id;
+      lastEventSequence = sequence;
+    }
     if (event.type === 'run_started') {
       persistRun({
         id: event.runId ?? event.payload?.runId ?? event.id,
         status: 'running',
         input: event.payload?.input ?? null,
+        workspace: ws,
         createdAt: event.ts,
         updatedAt: event.ts,
       });
-    } else if (RUN_STATUS_BY_TERMINAL_EVENT[event.type]) {
+    } else if (RUN_STATUS_BY_EVENT[event.type]) {
       const runId = event.runId ?? event.payload?.runId ?? null;
       if (runId) {
         persistRun({
           id: runId,
-          status: RUN_STATUS_BY_TERMINAL_EVENT[event.type],
+          status: RUN_STATUS_BY_EVENT[event.type],
+          workspace: ws,
           updatedAt: event.ts,
         });
       }
@@ -150,19 +227,26 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     return event;
   }
 
-  function persistRun({ id, status, input = null, createdAt = null, updatedAt = null }) {
+  function persistRun({ id, status, input = null, workspace = null, createdAt = null, updatedAt = null }) {
     if (!id) return;
     const now = new Date().toISOString();
-    upsertRun.run(id, status, input, createdAt ?? now, updatedAt ?? now);
+    upsertRun.run(id, workspace, status, input, createdAt ?? now, updatedAt ?? now);
   }
 
-  function listEvents() {
-    return listEventsStatement.all().map(rowToEvent);
+  function listEvents({ workspace = null } = {}) {
+    const rows = workspace
+      ? listEventsByWorkspaceStatement.all(workspace)
+      : listEventsStatement.all();
+    return rows.map(rowToEvent);
   }
 
-  function listRuns() {
-    return listRunsStatement.all().map((row) => ({
+  function listRuns({ workspace = null } = {}) {
+    const rows = workspace
+      ? listRunsByWorkspaceStatement.all(workspace)
+      : listRunsStatement.all();
+    return rows.map((row) => ({
       id: row.id,
+      workspace: row.workspace ?? null,
       status: row.status,
       input: row.input,
       createdAt: row.created_at,
@@ -170,19 +254,48 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     }));
   }
 
-  function saveQueue(queue = []) {
+  function listRecoverableRuns({ workspace = null } = {}) {
+    const rows = workspace
+      ? listRecoverableRunsByWorkspaceStatement.all(workspace, ...RECOVERABLE_RUN_STATUSES)
+      : listRecoverableRunsStatement.all(...RECOVERABLE_RUN_STATUSES);
+    return rows.map((row) => ({
+      id: row.id,
+      workspace: row.workspace ?? null,
+      status: row.status,
+      input: row.input,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  function listRecoverableWorkspaces() {
+    return listRecoverableWorkspacesStatement
+      .all(...RECOVERABLE_RUN_STATUSES, ...RECOVERABLE_QUEUE_STATUSES)
+      .map((row) => row.workspace);
+  }
+
+  function interruptRuns({ workspace, reason = 'Runtime restart recovery failed.' } = {}) {
+    if (!workspace) return 0;
+    const now = new Date().toISOString();
+    const result = interruptRunsStatement.run(now, workspace, ...RECOVERABLE_RUN_STATUSES);
+    return Number(result.changes ?? 0);
+  }
+
+  function saveQueue(queue = [], { workspace = null } = {}) {
     const items = Array.isArray(queue) ? queue : [];
     const now = new Date().toISOString();
     db.exec('BEGIN');
     try {
       if (items.length === 0) {
-        clearQueueItems.run();
+        if (workspace) clearQueueItemsForWorkspace.run(workspace);
+        else clearQueueItems.run();
       } else {
-        deleteMissingQueueItems.run(JSON.stringify(items.map((item) => item.id)));
+        if (workspace) deleteMissingQueueItemsForWorkspace.run(workspace, JSON.stringify(items.map((item) => item.id)));
+        else deleteMissingQueueItems.run(JSON.stringify(items.map((item) => item.id)));
         for (const item of items) {
           upsertQueueItem.run(
             item.id,
-            item.workspace ?? null,
+            item.workspace ?? workspace ?? null,
             item.server ?? 'production',
             item.tool ?? 'production_start_job',
             JSON.stringify(item.args ?? {}),
@@ -206,8 +319,11 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     }
   }
 
-  function listQueue() {
-    return listQueueStatement.all().map((row) => ({
+  function listQueue({ workspace = null } = {}) {
+    const rows = workspace
+      ? listQueueByWorkspaceStatement.all(workspace)
+      : listQueueStatement.all();
+    return rows.map((row) => ({
       id: row.id,
       workspace: row.workspace ?? null,
       server: row.server,
@@ -226,34 +342,38 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     }));
   }
 
-  function replayEvents(session) {
-    const events = listEvents();
+  function replayEvents(session, { workspace = null } = {}) {
+    const events = listEvents({ workspace });
     for (const event of events) {
       dispatchAgentEvent(session, event);
     }
-    if (events.length > 0) lastEventId = events.at(-1).id;
+    if (events.length > 0) {
+      lastEventId = events.at(-1).id;
+      lastEventSequence = events.at(-1).sequence ?? null;
+    }
     return session.agentProjection ?? reduceAgentEvents([]);
   }
 
-  function getProjection() {
-    return reduceAgentEvents(listEvents());
+  function getProjection({ workspace = null } = {}) {
+    return reduceAgentEvents(listEvents({ workspace }));
   }
 
-  function getState(session = null) {
-    const projection = session?.agentProjection ?? reduceAgentEvents(listEvents());
-    const queue = session?.queueStore?.list() ?? listQueue();
+  function getState(session = null, { workspace = null } = {}) {
+    const events = session?.agentProjection ? null : listEvents({ workspace });
+    const projection = session?.agentProjection ?? reduceAgentEvents(events);
+    const rawQueue = session?.queueStore?.list() ?? listQueue({ workspace });
     return {
       ...projection,
-      runs: listRuns(),
-      queue: queue.map((item) => ({ ...item })),
-      eventsCursor: lastEventId,
+      runs: listRuns({ workspace }),
+      queue: projectQueue(projection.plan, rawQueue, { workspace }),
+      eventsCursor: session?.agentEvents?.at(-1)?.sequence ?? events?.at(-1)?.sequence ?? lastEventSequence,
     };
   }
 
-  function hydrateSession(session) {
-    const projection = replayEvents(session);
+  function hydrateSession(session, { workspace = null } = {}) {
+    const projection = replayEvents(session, { workspace });
     applyAgentProjectionToSession(session, projection);
-    session.jobQueue = listQueue();
+    session.jobQueue = listQueue({ workspace });
     return projection;
   }
 
@@ -269,6 +389,9 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     persistRun,
     listEvents,
     listRuns,
+    listRecoverableRuns,
+    listRecoverableWorkspaces,
+    interruptRuns,
     saveQueue,
     listQueue,
     replayEvents,
@@ -281,12 +404,28 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
 
 function rowToEvent(row) {
   return {
+    sequence: row.sequence ?? null,
     id: row.id,
     ts: row.ts,
     type: row.type,
     origin: row.origin ?? 'system',
     runId: row.run_id ?? null,
     turnId: row.turn_id ?? null,
+    workspace: row.workspace ?? null,
     payload: row.payload ? JSON.parse(row.payload) : {},
   };
 }
+
+function ensureColumn(db, table, column, definition) {
+  const existing = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (existing.some((row) => row.name === column)) return;
+  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+
+function backfillEventSequence(db) {
+  db.exec(`
+    UPDATE events
+    SET sequence = rowid
+    WHERE sequence IS NULL
+  `);
+}