@oar-sh/oar 0.9.8 → 0.9.10

package/server/repositories/message-pin-statements.mjs

@@ -0,0 +1,39 @@
+'use strict';
+
+// Pinned messages: the pinned_at column detection and its SQL in one place.
+// The statements are null on a database the 0008 migration has not reached
+// yet; every caller treats that as "no pins".
+export function createMessagePinStatements(db) {
+  const messageColumns = new Set(
+    db.prepare(`PRAGMA table_info(messages)`).all().map((column) => String(column?.name || '').trim()),
+  );
+  const messagesSupportPins = messageColumns.has('pinned_at');
+  if (!messagesSupportPins) {
+    return {
+      messagesSupportPins,
+      setMessagePinnedAt: null,
+      listPinnedMessages: null,
+      countPinnedMessages: null,
+    };
+  }
+  return {
+    messagesSupportPins,
+    setMessagePinnedAt: db.prepare(`
+      UPDATE messages
+      SET pinned_at = ?
+      WHERE id = ? AND conversation_id = ?
+    `),
+    // Conversation order, not pin order: the list reads like a table of contents.
+    listPinnedMessages: db.prepare(`
+      SELECT id, role, text, mode, attachments, timestamp, pinned_at, hidden_from_shares
+      FROM messages
+      WHERE conversation_id = ? AND pinned_at IS NOT NULL
+      ORDER BY timestamp ASC
+    `),
+    countPinnedMessages: db.prepare(`
+      SELECT COUNT(*) AS cnt
+      FROM messages
+      WHERE conversation_id = ? AND pinned_at IS NOT NULL
+    `),
+  };
+}

package/server/repositories/message-repository.mjs

@@ -1,10 +1,12 @@
 'use strict';
 
 import { createShareVisibilityStatements } from './share-visibility-statements.mjs';
+import { createMessagePinStatements } from './message-pin-statements.mjs';
 import { sessionWorkerProviderSqlList } from '../../shared/provider-routing.mjs';
 
 export function createMessageRepository(db) {
     const shareVisibility = createShareVisibilityStatements(db);
+    const messagePins = createMessagePinStatements(db);
     const queueHasImageOperationId = db.prepare(`PRAGMA table_info(queue)`).all()
         .some((column) => column.name === 'image_operation_id');
     // A turn paused at the Claude usage limit (usage-limit-pause-service): a
@@ -27,6 +29,9 @@ export function createMessageRepository(db) {
         getSharedMessages: shareVisibility.getSharedMessages,
         getMessageByConversation: db.prepare(`SELECT * FROM messages WHERE id = ? AND conversation_id = ? LIMIT 1`),
         setMessageShareVisibility: shareVisibility.setMessageShareVisibility,
+        setMessagePinnedAt: messagePins.setMessagePinnedAt,
+        listPinnedMessages: messagePins.listPinnedMessages,
+        countPinnedMessages: messagePins.countPinnedMessages,
         getLatestConversationModel: db.prepare(`SELECT model FROM messages WHERE conversation_id = ? AND model IS NOT NULL AND model != '' ORDER BY timestamp DESC LIMIT 1`),
         getRecentMessagesDesc: db.prepare(`SELECT id, role, text, timestamp FROM messages WHERE conversation_id = ? ORDER BY timestamp DESC LIMIT ?`),
         insertMsg:      db.prepare(`INSERT INTO messages (id, conversation_id, role, text, model, mode, attachments, timestamp, model_requested, model_actual, model_origin) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`),
@@ -341,6 +346,12 @@ export function createMessageRepository(db) {
         //
         // A turn blocked on an unanswered AskUserQuestion is never stale — it is
         // waiting on the human, and relay_questions carries its own expiry.
+        //
+        // The ceiling counts from the last human interaction with the turn, not
+        // from its start: answering a question restarts the clock. Otherwise an
+        // interview that waited hours for its answers would be cut off by the
+        // ceiling the moment the last answer arrived (live 2026-10-10: a
+        // five-question interview lost its reply that way).
         listRecoverableProcessing: db.prepare(`
           SELECT id, conversation_id, kind, relay_mode, model, retry_count, consumed_at
           FROM queue
@@ -348,7 +359,13 @@ export function createMessageRepository(db) {
             AND COALESCE(kind, '') != 'continuation'
             AND (
               COALESCE(owner_last_claimed_at, processing_at, timestamp) < @inactiveBefore
-              OR (@ceilingBefore IS NOT NULL AND COALESCE(processing_at, timestamp) < @ceilingBefore)
+              OR (
+                @ceilingBefore IS NOT NULL
+                AND MAX(
+                  COALESCE(processing_at, timestamp),
+                  COALESCE((SELECT MAX(answered_at) FROM relay_questions WHERE queue_id = queue.id), '')
+                ) < @ceilingBefore
+              )
             )
             AND id NOT IN (SELECT queue_id FROM relay_questions WHERE status = 'pending')
         `),
@@ -426,15 +443,29 @@ export function createMessageRepository(db) {
         // A continuation with no live worker can only be torn down — replaying
         // it as deliverable work would send the CLI's own bookkeeping text back
         // to the CLI as a user prompt.
+        //
+        // Same staleness rules as listRecoverableProcessing: a continuation
+        // waiting on an unanswered question is never stale, and an answer
+        // restarts the ceiling clock. A background-agent interview hangs its
+        // question cards on the continuation row, so without this a long
+        // interview was torn down by the ceiling while the human was still
+        // answering (live 2026-10-10).
         listStaleProcessingContinuations: db.prepare(`
-          SELECT id, conversation_id
+          SELECT id, conversation_id, timestamp, processing_at, owner_last_claimed_at
           FROM queue
           WHERE status = 'processing'
             AND kind = 'continuation'
             AND (
               COALESCE(owner_last_claimed_at, processing_at, timestamp) < @inactiveBefore
-              OR (@ceilingBefore IS NOT NULL AND COALESCE(processing_at, timestamp) < @ceilingBefore)
+              OR (
+                @ceilingBefore IS NOT NULL
+                AND MAX(
+                  COALESCE(processing_at, timestamp),
+                  COALESCE((SELECT MAX(answered_at) FROM relay_questions WHERE queue_id = queue.id), '')
+                ) < @ceilingBefore
+              )
             )
+            AND id NOT IN (SELECT queue_id FROM relay_questions WHERE status = 'pending')
         `),
         listQueueForPauseDrop: db.prepare(`SELECT id, conversation_id FROM queue WHERE status IN ('pending', 'processing', 'parked')`),
         // Authoritative "is a turn in flight" signal for the conversation list.

package/server/repositories/question-repository.mjs

@@ -1,7 +1,13 @@
 'use strict';
 
+import { createSubagentTimelineStatements } from './subagent-timeline-statements.mjs';
+
 export function createQuestionRepository(db) {
+    const subagentTimeline = createSubagentTimelineStatements(db);
+    const runColumns = subagentTimeline.subagentRunSelectColumns;
+    const runColumnsAs = (alias) => runColumns.split(', ').map((column) => `${alias}.${column}`).join(', ');
     return {
+        ...subagentTimeline,
         // relay questions
         insertQuestion: db.prepare(`INSERT INTO relay_questions (id, queue_id, conversation_id, message_id, relay_mode, prompt, choices, request, request_schema, status, answer, structured_answer, sdk_session_id, owner_worker_id, continuation_id, continuation_question_id, created_at, answered_at, expires_at, attempt_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?, ?, ?, ?, NULL, ?, ?)`),
         getQuestion:    db.prepare(`SELECT * FROM relay_questions WHERE id = ?`),
@@ -99,7 +105,7 @@ export function createQuestionRepository(db) {
           WHERE id = ?
         `),
         listSubagentRunsByQueueMessage: db.prepare(`
-          SELECT id, queue_message_id, conversation_id, parent_subagent_id, display_name, status, started_at, updated_at, completed_at
+          SELECT ${runColumns}
           FROM subagent_runs
           WHERE queue_message_id = ?
           ORDER BY started_at ASC, id ASC
@@ -108,7 +114,7 @@ export function createQuestionRepository(db) {
         // abort) also ends its subagent runs — nothing else ever will, and an
         // un-reconciled row renders as a bubble stuck "running" forever.
         listRunningSubagentRunsByQueueMessage: db.prepare(`
-          SELECT id, conversation_id, parent_subagent_id, display_name
+          SELECT ${runColumns}
           FROM subagent_runs
           WHERE queue_message_id = ? AND status = 'running'
         `),
@@ -121,7 +127,7 @@ export function createQuestionRepository(db) {
           WHERE queue_message_id = ? AND status = 'running'
         `),
         listSubagentRunsByResponse: db.prepare(`
-          SELECT sr.id, sr.queue_message_id, sr.conversation_id, sr.parent_subagent_id, sr.display_name, sr.status, sr.started_at, sr.updated_at, sr.completed_at
+          SELECT ${runColumnsAs('sr')}
           FROM subagent_runs sr
           WHERE sr.queue_message_id IN (
             SELECT id FROM queue WHERE response_message_id = ?

package/server/repositories/remote-relay-repository.mjs

@@ -29,7 +29,10 @@ export function createRemoteRelayRepository(db) {
   const hasUnlock = db.prepare(`SELECT 1 FROM conversation_remote_relay_unlocks WHERE conversation_id = ? AND remote_relay_id = ?`);
   const listUnlocks = db.prepare(`SELECT remote_relay_id, message_id, created_at FROM conversation_remote_relay_unlocks WHERE conversation_id = ? ORDER BY created_at ASC`);
   const insertUnlock = db.prepare(`INSERT OR IGNORE INTO conversation_remote_relay_unlocks (conversation_id, remote_relay_id, message_id, created_at) VALUES (?, ?, ?, ?)`);
-  const deleteUnlocksForRelay = db.prepare(`DELETE FROM conversation_remote_relay_unlocks WHERE remote_relay_id = ?`);
+  // The relay's unlocks and the approvals stored under its id (`<id>:watch`).
+  const deleteUnlocksForRelay = db.prepare(`
+    DELETE FROM conversation_remote_relay_unlocks WHERE remote_relay_id = ? OR substr(remote_relay_id, 1, length(?) + 1) = ? || ':'
+  `);
   const deleteUnlocksForConversation = db.prepare(`DELETE FROM conversation_remote_relay_unlocks WHERE conversation_id = ?`);
   const setMessageOrigin = db.prepare(`UPDATE messages SET origin_json = ? WHERE id = ?`);
   const getMessageOrigin = db.prepare(`SELECT origin_json FROM messages WHERE id = ?`);
@@ -101,7 +104,8 @@ export function createRemoteRelayRepository(db) {
         .map((row) => String(row.id));
     },
     forgetRelay(remoteRelayId) {
-      return deleteUnlocksForRelay.run(String(remoteRelayId || '')).changes;
+      const id = String(remoteRelayId || '');
+      return deleteUnlocksForRelay.run(id, id, id).changes;
     },
     forgetConversation(conversationId) {
       return deleteUnlocksForConversation.run(String(conversationId || '')).changes;

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/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 });
   });