@oar-sh/oar 0.9.9 → 0.9.11

package/server/repositories/session-repository.mjs

@@ -24,6 +24,16 @@ export function createSessionRepository(db) {
         ? 'rs.claude_cloud_cost_usd AS runtime_claude_cloud_cost_usd'
         : 'NULL AS runtime_claude_cloud_cost_usd',
     ].join(', ');
+    // Session groups (migration 0014). NULL on a schema that predates it.
+    const conversationsHaveGroup = db.prepare(`PRAGMA table_info(conversations)`).all()
+      .some((column) => String(column?.name || '').trim() === 'group_id');
+    // The hand order inside a group (migration 0015).
+    const conversationsHaveGroupPosition = db.prepare(`PRAGMA table_info(conversations)`).all()
+      .some((column) => String(column?.name || '').trim() === 'group_position');
+    const conversationGroupSelect = [
+      conversationsHaveGroup ? 'c.group_id' : 'NULL AS group_id',
+      conversationsHaveGroupPosition ? 'c.group_position' : 'NULL AS group_position',
+    ].join(', ');
     return {
         // conversations
         getConv:        db.prepare(`SELECT * FROM conversations WHERE id = ? AND status != 'deleted'`),
@@ -31,7 +41,7 @@ export function createSessionRepository(db) {
         getConvBySdkSessionId: db.prepare(`SELECT * FROM conversations WHERE sdk_session_id = ? AND status != 'deleted' ORDER BY updated_at DESC LIMIT 1`),
         listConvIdsMissingRuntimeSession: db.prepare(`SELECT c.id AS id FROM conversations c LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE rs.id IS NULL AND c.status != 'deleted'`),
         runtimeSessionsSupportProviders,
-        listConvs:      db.prepare(`SELECT c.id, c.title, c.title_source, c.archived, c.compacted_into, c.compacted_from, c.sdk_session_id, c.preferred_relay_mode, c.preferred_model, c.preferred_reasoning_effort, c.configured_workspace_root_path, c.runtime_workspace_root_path, c.draft_text, c.draft_updated_at, c.draft_updated_by_client_id, c.draft_attachments, ${conversationOriginSelect}, ${conversationCloudSelect}, c.created_at, c.updated_at, rs.id AS runtime_session_id, rs.strategy AS runtime_strategy, rs.status AS runtime_status, rs.last_used_at AS runtime_last_used_at, ${runtimeProviderSelect}, COUNT(m.id) as message_count FROM conversations c LEFT JOIN messages m ON m.conversation_id = c.id LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE c.status != 'deleted' AND (? = 1 OR c.archived = ?) GROUP BY c.id ORDER BY CASE WHEN c.sdk_session_id IS NULL OR c.sdk_session_id = '' THEN 1 ELSE 0 END ASC, c.updated_at DESC`),
+        listConvs:      db.prepare(`SELECT c.id, c.title, c.title_source, c.archived, c.compacted_into, c.compacted_from, c.sdk_session_id, c.preferred_relay_mode, c.preferred_model, c.preferred_reasoning_effort, c.configured_workspace_root_path, c.runtime_workspace_root_path, c.draft_text, c.draft_updated_at, c.draft_updated_by_client_id, c.draft_attachments, ${conversationOriginSelect}, ${conversationCloudSelect}, ${conversationGroupSelect}, c.created_at, c.updated_at, rs.id AS runtime_session_id, rs.strategy AS runtime_strategy, rs.status AS runtime_status, rs.last_used_at AS runtime_last_used_at, ${runtimeProviderSelect}, COUNT(m.id) as message_count FROM conversations c LEFT JOIN messages m ON m.conversation_id = c.id LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE c.status != 'deleted' AND (? = 1 OR c.archived = ?) GROUP BY c.id ORDER BY CASE WHEN c.sdk_session_id IS NULL OR c.sdk_session_id = '' THEN 1 ELSE 0 END ASC, c.updated_at DESC`),
         insertConv:     db.prepare(`INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`),
         updateConvTime: db.prepare(`UPDATE conversations SET updated_at = ? WHERE id = ?`),
         updateConvTitle: db.prepare(`UPDATE conversations SET title = ?, title_source = 'manual' WHERE id = ?`),
@@ -301,47 +311,12 @@ export function createSessionRepository(db) {
           FROM conversations
           WHERE status = 'deleted' AND sdk_session_id = ?
         `),
-        // public conversation shares
-        getConversationShareByConversationId: db.prepare(`
-          SELECT token, conversation_id, created_at, last_accessed_at, revoked_at
-          FROM conversation_shares
-          WHERE conversation_id = ?
-            AND (revoked_at IS NULL OR revoked_at = '')
-          ORDER BY created_at DESC
-          LIMIT 1
-        `),
-        getConversationShareByToken: db.prepare(`
-          SELECT token, conversation_id, created_at, last_accessed_at, revoked_at
-          FROM conversation_shares
-          WHERE token = ?
-          LIMIT 1
-        `),
-        insertConversationShare: db.prepare(`
-          INSERT INTO conversation_shares (
-            token,
-            conversation_id,
-            created_at,
-            last_accessed_at,
-            revoked_at
-          ) VALUES (?, ?, ?, ?, NULL)
-        `),
+        // public conversation shares (the rest lives in share-repository.mjs)
         touchConversationShare: db.prepare(`
           UPDATE conversation_shares
           SET last_accessed_at = ?
           WHERE token = ?
             AND (revoked_at IS NULL OR revoked_at = '')
         `),
-        revokeConversationShareByToken: db.prepare(`
-          UPDATE conversation_shares
-          SET revoked_at = ?
-          WHERE token = ?
-            AND (revoked_at IS NULL OR revoked_at = '')
-        `),
-        revokeConversationSharesByConversationId: db.prepare(`
-          UPDATE conversation_shares
-          SET revoked_at = ?
-          WHERE conversation_id = ?
-            AND (revoked_at IS NULL OR revoked_at = '')
-        `),
     };
 }

package/server/repositories/share-repository.mjs

@@ -0,0 +1,322 @@
+'use strict';
+
+import { randomBytes } from 'node:crypto';
+
+// Public conversation shares and their access log (migration 0016).
+//
+// A conversation has at most one active share: its newest unrevoked row in
+// `conversation_shares`. A share is a lineage of tokens: renewing it adds a
+// row with a new token and the same `lineage_id` and revokes the old token in
+// the same transaction, so the access log, keyed to the lineage, carries over.
+// Stopping a share revokes it and deletes its log.
+//
+// Every reader tolerates a schema without the migration: a share then has its
+// token as its lineage, nothing is logged, and the log reads as empty.
+
+export const SHARE_STORE_VIEWER_IP_SETTING_KEY = 'shares_store_viewer_ip';
+const SHARE_VIEWER_KEY_SECRET_SETTING_KEY = 'shares_viewer_key_secret';
+
+export const SHARE_OPENS_PAGE_DEFAULT = 200;
+export const SHARE_OPENS_PAGE_MAX = 1000;
+
+function tableExists(db, name) {
+  return !!db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name);
+}
+
+function isRevoked(row) {
+  return !!String(row?.revoked_at || '').trim();
+}
+
+function mapShareRow(row) {
+  if (!row?.token) return null;
+  return {
+    token: String(row.token),
+    conversationId: String(row.conversation_id || ''),
+    lineageId: String(row.lineage_id || '').trim() || String(row.token),
+    createdAt: row.created_at || null,
+    revokedAt: row.revoked_at || null,
+  };
+}
+
+function mapOpenRow(row) {
+  return {
+    openedAt: row.opened_at,
+    ip: row.ip || null,
+    country: row.country || null,
+    userAgent: row.user_agent || null,
+    // Enough to tell viewers apart in a list; the key itself stays here.
+    viewer: String(row.viewer_key || '').slice(0, 8) || null,
+  };
+}
+
+export function createShareRepository(db) {
+  const shareColumns = new Set(db.prepare(`PRAGMA table_info(conversation_shares)`).all().map((column) => column.name));
+  const hasLineage = shareColumns.has('lineage_id');
+  const hasLog = tableExists(db, 'conversation_share_opens');
+  const lineageSelect = hasLineage ? 'lineage_id' : 'NULL AS lineage_id';
+  const shareSelect = `token, conversation_id, created_at, revoked_at, ${lineageSelect}`;
+
+  const stmts = {
+    activeByConversation: db.prepare(`
+      SELECT ${shareSelect}
+      FROM conversation_shares
+      WHERE conversation_id = ?
+        AND (revoked_at IS NULL OR revoked_at = '')
+      ORDER BY created_at DESC
+      LIMIT 1
+    `),
+    byToken: db.prepare(`SELECT ${shareSelect} FROM conversation_shares WHERE token = ? LIMIT 1`),
+    insert: hasLineage
+      ? db.prepare(`
+        INSERT INTO conversation_shares (token, conversation_id, created_at, last_accessed_at, revoked_at, lineage_id)
+        VALUES (?, ?, ?, NULL, NULL, ?)
+      `)
+      : db.prepare(`
+        INSERT INTO conversation_shares (token, conversation_id, created_at, last_accessed_at, revoked_at)
+        VALUES (?, ?, ?, NULL, NULL)
+      `),
+    revokeOthers: db.prepare(`
+      UPDATE conversation_shares
+      SET revoked_at = ?
+      WHERE conversation_id = ?
+        AND token <> ?
+        AND (revoked_at IS NULL OR revoked_at = '')
+    `),
+    revokeAll: db.prepare(`
+      UPDATE conversation_shares
+      SET revoked_at = ?
+      WHERE conversation_id = ?
+        AND (revoked_at IS NULL OR revoked_at = '')
+    `),
+    listActive: db.prepare(`
+      SELECT s.token, s.conversation_id, s.created_at, s.revoked_at, ${hasLineage ? 's.lineage_id' : 'NULL AS lineage_id'},
+        c.title AS conversation_title, c.archived AS conversation_archived
+      FROM conversation_shares s
+      JOIN conversations c ON c.id = s.conversation_id
+      WHERE (s.revoked_at IS NULL OR s.revoked_at = '')
+        AND c.status != 'deleted'
+      ORDER BY s.created_at DESC
+    `),
+    conversationStatus: db.prepare(`SELECT id, status FROM conversations WHERE id = ?`),
+    getSetting: db.prepare(`SELECT value FROM app_settings WHERE key = ? LIMIT 1`),
+    upsertSetting: db.prepare(`
+      INSERT INTO app_settings (key, value, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `),
+  };
+  // Addresses already stored: the access log's `ip` and the `viewerIp` of the
+  // status log's shared reads. A row whose payload is not JSON is left alone.
+  const hasEvents = tableExists(db, 'status_events');
+  const EVENT_IP = `CASE WHEN json_valid(payload_json) THEN json_extract(payload_json, '$.viewerIp') END`;
+  const ipSources = [
+    ...(hasLog ? [`SELECT ip AS address FROM conversation_share_opens WHERE ip IS NOT NULL AND ip <> ''`] : []),
+    ...(hasEvents ? [`SELECT ${EVENT_IP} AS address FROM status_events WHERE type = 'shared-access-opened' AND COALESCE(${EVENT_IP}, '') <> ''`] : []),
+  ];
+  const ipStmts = {
+    count: ipSources.length ? db.prepare(`SELECT COUNT(*) AS n FROM (${ipSources.join(' UNION ')})`) : null,
+    clearOpens: hasLog ? db.prepare(`UPDATE conversation_share_opens SET ip = NULL WHERE ip IS NOT NULL`) : null,
+    clearEvents: hasEvents ? db.prepare(`
+      UPDATE status_events
+      SET payload_json = json_remove(payload_json, '$.viewerIp')
+      WHERE type = 'shared-access-opened' AND ${EVENT_IP} IS NOT NULL
+    `) : null,
+  };
+
+  const logStmts = hasLog ? {
+    insert: db.prepare(`
+      INSERT INTO conversation_share_opens (lineage_id, conversation_id, opened_at, ip, user_agent, country, viewer_key)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `),
+    stats: db.prepare(`
+      SELECT COUNT(*) AS opens, COUNT(DISTINCT viewer_key) AS viewers, MAX(opened_at) AS last_opened_at
+      FROM conversation_share_opens
+      WHERE lineage_id = ?
+    `),
+    page: db.prepare(`
+      SELECT opened_at, ip, user_agent, country, viewer_key
+      FROM conversation_share_opens
+      WHERE lineage_id = ?
+      ORDER BY opened_at DESC, id DESC
+      LIMIT ?
+    `),
+    lastOpenOf: db.prepare(`
+      SELECT MAX(opened_at) AS opened_at
+      FROM conversation_share_opens
+      WHERE lineage_id = ? AND viewer_key = ?
+    `),
+    deleteForConversation: db.prepare(`DELETE FROM conversation_share_opens WHERE conversation_id = ?`),
+  } : null;
+
+  function findActiveShare(conversationId) {
+    return mapShareRow(stmts.activeByConversation.get(String(conversationId || '').trim()));
+  }
+
+  function findShareByToken(token) {
+    return mapShareRow(stmts.byToken.get(String(token || '').trim()));
+  }
+
+  /**
+   * The share a public request may read: the token's row, neither revoked nor
+   * renewed, of a conversation that still exists. Null otherwise, and every
+   * share route answers that with a 404.
+   */
+  function findLiveShare(token) {
+    const row = stmts.byToken.get(String(token || '').trim());
+    if (!row || isRevoked(row)) return null;
+    const share = mapShareRow(row);
+    const conversation = stmts.conversationStatus.get(share.conversationId);
+    if (!conversation || String(conversation.status || '').trim().toLowerCase() === 'deleted') return null;
+    return share;
+  }
+
+  function insertShare(conversationId, token, now, lineageId) {
+    if (hasLineage) stmts.insert.run(token, conversationId, now, lineageId || token);
+    else stmts.insert.run(token, conversationId, now);
+  }
+
+  /** The active share, or a new one; `created` tells which. */
+  const getOrCreateShare = db.transaction((conversationId, makeToken, now) => {
+    const existing = findActiveShare(conversationId);
+    if (existing) return { share: existing, created: false };
+    const token = makeToken();
+    insertShare(conversationId, token, now, token);
+    return { share: findShareByToken(token), created: true };
+  });
+
+  /**
+   * A new token for the conversation's active share, same lineage; every other
+   * token of the conversation is revoked with it. Null without an active share.
+   */
+  const renewShare = db.transaction((conversationId, makeToken, now) => {
+    const existing = findActiveShare(conversationId);
+    if (!existing) return null;
+    const token = makeToken();
+    insertShare(conversationId, token, now, existing.lineageId);
+    stmts.revokeOthers.run(now, conversationId, token);
+    return { share: findShareByToken(token), previousToken: existing.token };
+  });
+
+  /** Revokes every token of the conversation and deletes its access log. */
+  const stopSharing = db.transaction((conversationId, now) => {
+    const revoked = stmts.revokeAll.run(now, conversationId).changes;
+    const opensDeleted = logStmts ? logStmts.deleteForConversation.run(conversationId).changes : 0;
+    return { revokedCount: Number(revoked || 0), opensDeleted: Number(opensDeleted || 0) };
+  });
+
+  function forgetConversation(conversationId) {
+    return logStmts ? Number(logStmts.deleteForConversation.run(conversationId).changes || 0) : 0;
+  }
+
+  function shareStats(lineageId) {
+    const row = logStmts ? logStmts.stats.get(lineageId) : null;
+    return {
+      openCount: Number(row?.opens || 0),
+      viewerCount: Number(row?.viewers || 0),
+      lastOpenedAt: row?.last_opened_at || null,
+    };
+  }
+
+  /** One entry per conversation with an active share, newest share first. */
+  function listActiveShares() {
+    const seen = new Set();
+    const shares = [];
+    for (const row of stmts.listActive.all()) {
+      const conversationId = String(row.conversation_id || '');
+      if (seen.has(conversationId)) continue;
+      seen.add(conversationId);
+      const share = mapShareRow(row);
+      // The lineage started with its first token; that row holds the date.
+      const first = share.lineageId === share.token ? row : stmts.byToken.get(share.lineageId);
+      shares.push({
+        ...share,
+        title: String(row.conversation_title || '').trim(),
+        archived: Number(row.conversation_archived || 0) === 1,
+        sharedSince: first?.created_at || share.createdAt,
+        ...shareStats(share.lineageId),
+      });
+    }
+    return shares;
+  }
+
+  function recordOpen({ lineageId, conversationId, openedAt, ip = null, userAgent = null, country = null, viewerKey }) {
+    if (!logStmts) return false;
+    logStmts.insert.run(lineageId, conversationId, openedAt, ip || null, userAgent || null, country || null, viewerKey);
+    return true;
+  }
+
+  function lastOpenAt(lineageId, viewerKey) {
+    return logStmts ? logStmts.lastOpenOf.get(lineageId, viewerKey)?.opened_at || null : null;
+  }
+
+  function listOpens(lineageId, { limit = SHARE_OPENS_PAGE_DEFAULT } = {}) {
+    const pageSize = Math.max(1, Math.min(SHARE_OPENS_PAGE_MAX, Math.trunc(Number(limit) || SHARE_OPENS_PAGE_DEFAULT)));
+    if (!logStmts) return { opens: [], total: 0, limit: pageSize };
+    return {
+      opens: logStmts.page.all(lineageId, pageSize).map(mapOpenRow),
+      total: shareStats(lineageId).openCount,
+      limit: pageSize,
+    };
+  }
+
+  // Default on: a relay records the address of a public reader unless told not to.
+  function readStoreViewerIp() {
+    return String(stmts.getSetting.get(SHARE_STORE_VIEWER_IP_SETTING_KEY)?.value || '').trim() !== 'false';
+  }
+
+  function writeStoreViewerIp(enabled) {
+    stmts.upsertSetting.run(SHARE_STORE_VIEWER_IP_SETTING_KEY, enabled ? 'true' : 'false', new Date().toISOString());
+    return readStoreViewerIp();
+  }
+
+  /** How many distinct viewer addresses the relay still holds. */
+  function countStoredViewerIps() {
+    return Number(ipStmts.count?.get()?.n || 0);
+  }
+
+  /**
+   * Drops every stored viewer address: the access log keeps its rows and
+   * viewer keys (so viewer counts stay), the status log its events.
+   */
+  const forgetStoredViewerIps = db.transaction(() => ({
+    opens: Number(ipStmts.clearOpens?.run().changes || 0),
+    events: Number(ipStmts.clearEvents?.run().changes || 0),
+  }));
+
+  // The key of the viewer hash, made once per relay. Kept next to the log, so
+  // it keeps addresses out of the log but does not hide them from someone
+  // holding the whole database.
+  let viewerKeySecret = '';
+  function readViewerKeySecret() {
+    if (viewerKeySecret) return viewerKeySecret;
+    const stored = String(stmts.getSetting.get(SHARE_VIEWER_KEY_SECRET_SETTING_KEY)?.value || '').trim();
+    if (stored) {
+      viewerKeySecret = stored;
+      return stored;
+    }
+    const created = randomBytes(32).toString('hex');
+    stmts.upsertSetting.run(SHARE_VIEWER_KEY_SECRET_SETTING_KEY, created, new Date().toISOString());
+    viewerKeySecret = created;
+    return created;
+  }
+
+  return {
+    logAvailable: hasLog,
+    findActiveShare,
+    findShareByToken,
+    findLiveShare,
+    getOrCreateShare,
+    renewShare,
+    stopSharing,
+    forgetConversation,
+    shareStats,
+    listActiveShares,
+    recordOpen,
+    lastOpenAt,
+    listOpens,
+    readStoreViewerIp,
+    writeStoreViewerIp,
+    countStoredViewerIps,
+    forgetStoredViewerIps,
+    readViewerKeySecret,
+  };
+}

package/server/repositories/share-visibility-statements.mjs

@@ -20,5 +20,15 @@ export function createShareVisibilityStatements(db) {
           WHERE id = ? AND conversation_id = ?
         `)
       : null,
+    // Conversation order, like the pin list. Null on a database without the
+    // columns: every caller treats that as "nothing hidden".
+    listHiddenMessages: messagesSupportShareVisibility
+      ? db.prepare(`
+          SELECT id, role, text, mode, attachments, timestamp, share_hidden_at
+          FROM messages
+          WHERE conversation_id = ? AND hidden_from_shares = 1
+          ORDER BY timestamp ASC
+        `)
+      : null,
   };
 }

package/server/repositories/subagent-timeline-statements.mjs

@@ -0,0 +1,170 @@
+'use strict';
+
+// Sub-agent viewer: the timeline table, the run header columns and their SQL
+// in one place. On a database the 0009 migration has not reached yet the
+// timeline statements are null and the header columns read as absent; every
+// caller treats that as "no timeline" and falls back to the activity, thought
+// and stream rows a run has always had.
+
+const HEADER_COLUMNS = [
+  'model',
+  'model_inherited',
+  'subagent_type',
+  'task_id',
+  'total_tokens',
+  'background',
+  'truncated',
+  'timeline_owner',
+];
+
+const BASE_RUN_COLUMNS = [
+  'id',
+  'queue_message_id',
+  'conversation_id',
+  'parent_subagent_id',
+  'display_name',
+  'status',
+  'started_at',
+  'updated_at',
+  'completed_at',
+];
+
+export function createSubagentTimelineStatements(db) {
+  const tableNames = new Set(
+    db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table'`).all().map((row) => String(row.name)),
+  );
+  if (!tableNames.has('subagent_runs')) {
+    return { subagentRunsSupportHeader: false, subagentTimelineSupported: false, subagentRunSelectColumns: BASE_RUN_COLUMNS.join(', ') };
+  }
+  const runColumns = new Set(db.prepare(`PRAGMA table_info(subagent_runs)`).all().map((column) => String(column.name)));
+  const subagentRunsSupportHeader = HEADER_COLUMNS.every((name) => runColumns.has(name));
+  const subagentTimelineSupported = subagentRunsSupportHeader && tableNames.has('subagent_timeline');
+  const subagentRunSelectColumns = [...BASE_RUN_COLUMNS, ...(subagentRunsSupportHeader ? HEADER_COLUMNS : [])].join(', ');
+
+  const statements = {
+    subagentRunsSupportHeader,
+    subagentTimelineSupported,
+    // The column list every run read uses, so the header travels with the
+    // run wherever runs are listed (conversation payload, in-flight snapshot).
+    subagentRunSelectColumns,
+    updateSubagentRunHeader: null,
+    setSubagentRunTruncated: null,
+    listChildSubagentRuns: null,
+    getSubagentRunByTaskId: null,
+    listRunningBackgroundSubagentRunsForSession: null,
+    getTimelineEntryByKey: null,
+    getMaxTimelineSeq: null,
+    countTimelineEntries: null,
+    insertTimelineEntry: null,
+    updateTimelineEntryByKey: null,
+    listTimelineEntries: null,
+    deleteConvSubagentTimeline: null,
+    listLegacyActivityBySubagentRun: null,
+    listLegacyThoughtsBySubagentRun: null,
+    listLegacyStreamBySubagentRun: null,
+  };
+
+  // What a run recorded before the timeline existed: its tagged activity
+  // lines, thoughts and reply text. The viewer reads these for an old run.
+  const hasRunColumn = (table) => tableNames.has(table)
+    && db.prepare(`PRAGMA table_info(${table})`).all().some((column) => column.name === 'subagent_run_id');
+  if (hasRunColumn('relay_activity')) {
+    statements.listLegacyActivityBySubagentRun = db.prepare(`
+      SELECT id, text, metadata_json, created_at FROM relay_activity
+      WHERE subagent_run_id = ? ORDER BY id ASC LIMIT ?
+    `);
+  }
+  if (hasRunColumn('relay_thought')) {
+    statements.listLegacyThoughtsBySubagentRun = db.prepare(`
+      SELECT reasoning_id, seq, text, done, created_at FROM relay_thought
+      WHERE subagent_run_id = ? ORDER BY seq ASC, id ASC LIMIT ?
+    `);
+  }
+  if (hasRunColumn('relay_stream_events')) {
+    statements.listLegacyStreamBySubagentRun = db.prepare(`
+      SELECT text, done, created_at FROM relay_stream_events
+      WHERE subagent_run_id = ? ORDER BY seq ASC, id ASC LIMIT ?
+    `);
+  }
+  if (!subagentRunsSupportHeader) return statements;
+
+  // A patch, not a replace: every field the writer did not name (NULL) keeps
+  // what the row has. `background` and `truncated` only ever turn on, and the
+  // timeline owner is claimed once.
+  statements.updateSubagentRunHeader = db.prepare(`
+    UPDATE subagent_runs
+    SET model = COALESCE(@model, model),
+        model_inherited = COALESCE(@modelInherited, model_inherited),
+        subagent_type = COALESCE(@subagentType, subagent_type),
+        task_id = COALESCE(@taskId, task_id),
+        total_tokens = COALESCE(@totalTokens, total_tokens),
+        background = MAX(background, COALESCE(@background, 0)),
+        truncated = MAX(truncated, COALESCE(@truncated, 0)),
+        timeline_owner = COALESCE(timeline_owner, @timelineOwner),
+        updated_at = @updatedAt
+    WHERE id = @id
+  `);
+  statements.setSubagentRunTruncated = db.prepare(`UPDATE subagent_runs SET truncated = 1, updated_at = ? WHERE id = ?`);
+  statements.listChildSubagentRuns = db.prepare(`
+    SELECT ${subagentRunSelectColumns}
+    FROM subagent_runs
+    WHERE parent_subagent_id = ?
+    ORDER BY started_at ASC, id ASC
+  `);
+  // A worker's live background agents: what dies with it.
+  if (tableNames.has('conversations')) {
+    statements.listRunningBackgroundSubagentRunsForSession = db.prepare(`
+      SELECT ${subagentRunSelectColumns}
+      FROM subagent_runs
+      WHERE status = 'running' AND background = 1
+        AND conversation_id IN (SELECT id FROM conversations WHERE sdk_session_id = ? OR id = ?)
+    `);
+  }
+  statements.getSubagentRunByTaskId = db.prepare(`
+    SELECT ${subagentRunSelectColumns}
+    FROM subagent_runs
+    WHERE conversation_id = ? AND task_id = ?
+    ORDER BY started_at DESC
+    LIMIT 1
+  `);
+
+  if (!subagentTimelineSupported) return statements;
+
+  statements.getTimelineEntryByKey = db.prepare(`SELECT id, seq, done FROM subagent_timeline WHERE run_id = ? AND entry_key = ?`);
+  statements.getMaxTimelineSeq = db.prepare(`SELECT COALESCE(MAX(seq), 0) AS max_seq FROM subagent_timeline WHERE run_id = ?`);
+  statements.countTimelineEntries = db.prepare(`SELECT COUNT(*) AS cnt FROM subagent_timeline WHERE run_id = ?`);
+  statements.insertTimelineEntry = db.prepare(`
+    INSERT INTO subagent_timeline (
+      run_id, conversation_id, queue_message_id, entry_key, seq, kind, text, tool_name, tool_use_id,
+      metadata_json, done, created_at, updated_at
+    ) VALUES (
+      @runId, @conversationId, @queueMessageId, @entryKey, @seq, @kind, @text, @toolName, @toolUseId,
+      @metadataJson, @done, @createdAt, @updatedAt
+    )
+  `);
+  // In place: the entry keeps its seq (its place in the order). A closed
+  // entry stays closed, though its text may still be corrected (the complete
+  // copy of a block that streamed).
+  statements.updateTimelineEntryByKey = db.prepare(`
+    UPDATE subagent_timeline
+    SET text = @text,
+        tool_name = COALESCE(@toolName, tool_name),
+        tool_use_id = COALESCE(@toolUseId, tool_use_id),
+        metadata_json = COALESCE(@metadataJson, metadata_json),
+        done = MAX(done, @done),
+        updated_at = @updatedAt
+    WHERE run_id = @runId AND entry_key = @entryKey
+  `);
+  // Everything after `afterSeq`, plus whatever is still open before it: an
+  // open entry changes in place, so a reader that already has its seq still
+  // needs its newer text.
+  statements.listTimelineEntries = db.prepare(`
+    SELECT seq, kind, text, tool_name, tool_use_id, metadata_json, done, created_at, updated_at
+    FROM subagent_timeline
+    WHERE run_id = @runId AND (seq > @afterSeq OR done = 0)
+    ORDER BY seq ASC
+    LIMIT @limit
+  `);
+  statements.deleteConvSubagentTimeline = db.prepare(`DELETE FROM subagent_timeline WHERE conversation_id = ?`);
+  return statements;
+}

package/server/routes/about-routes.mjs

@@ -0,0 +1,15 @@
+'use strict';
+
+// GET /api/about: the About OAR modal's data (about-service.mjs). The owner's
+// only; a shared viewer never sees it.
+
+export function registerAboutRoutes(app, { auth, aboutService = null } = {}) {
+  app.get('/api/about', auth, async (_req, res) => {
+    if (!aboutService) return res.status(503).json({ error: 'About is unavailable on this relay' });
+    try {
+      return res.json(await aboutService.describe());
+    } catch (error) {
+      return res.status(500).json({ error: `Reading the relay's facts failed: ${String(error?.message || error)}` });
+    }
+  });
+}

package/server/routes/ask-user-routes.mjs

@@ -116,6 +116,8 @@ export function registerAskUserRoutes(app, deps) {
     DEFAULT_RELAY_MODE,
     sessionWorkerRegistry,
     pushDispatchService,
+    // Relay event subscriptions: a question is an event for its watchers.
+    relayEventService = null,
     // Remote relays: another relay's agent answering a question is refused
     // while the inbound switch is off. Absent in older wiring (no-op).
     remoteRelayInbound = null,
@@ -246,6 +248,7 @@ export function registerAskUserRoutes(app, deps) {
     console.log(`[${ts()}] QUESTION  ${questionId.slice(0,8)} conv=${question.conversationId.slice(0,8)} mode=${relayMode} fields=${fieldCount} prompt="${promptText.slice(0,60)}"`);
     io.emit('relay_question', { question });
     void pushDispatchService?.notifyQuestion?.(question);
+    try { relayEventService?.noteQuestion?.(question); } catch {}
     res.json({ question });
   });
 

package/server/routes/cache-routes.mjs

@@ -14,6 +14,8 @@ export function registerCacheRoutes(app, deps) {
     bootstrapRuntimeSessionBindings,
     collectOrphanedUploadsFromConversation,
     deleteOrphanedUploads,
+    closeConversationPreviews,
+    conversationGroups = null,
   } = deps;
 
   const cacheRebuildService = createCacheRebuildService({
@@ -26,6 +28,8 @@ export function registerCacheRoutes(app, deps) {
     bootstrapRuntimeSessionBindings,
     collectOrphanedUploadsFromConversation,
     deleteOrphanedUploads,
+    closeConversationPreviews,
+    conversationGroups,
   });
 
   app.post('/api/cache/rebuild', auth, (req, res) => {