@oar-sh/oar 0.9.5 → 0.9.6

package/server/public/app/socket-handlers.js

@@ -49,6 +49,7 @@ import { applyGrokAuthState } from './grok-auth-ui.js';
 import { applyCliInstallState } from './cli-install-ui.js';
 import { renderUpdateSection } from './update-ui.js';
 import { applyHostSuspendState, applyRelayShutdownState } from './host-suspend-ui.js';
+import { applyClaudeUsageLimit, applyUsageLimitPause } from './usage-limit-ui.js';
 import {
   showThinking,
   removeThinking,
@@ -399,6 +400,14 @@ export async function connectSocket(overrideDeps) {
   socket.on('relay_shutdown_state', (payload) => {
     applyRelayShutdownState(payload || null);
   });
+  // The Claude usage limit: a conversation's paused turn, and the account's
+  // latest report (also sent on connect).
+  socket.on('usage_limit_pause', (payload) => {
+    applyUsageLimitPause(payload || null);
+  });
+  socket.on('claude_usage_limit', (payload) => {
+    applyClaudeUsageLimit(payload || null);
+  });
   socket.on('grok_settings_updated', (payload) => {
     deps?.applyGrokSettingsState?.(payload || {});
     if (Number(payload?.reconciliation?.updatedUnstartedConversations || 0) > 0) {

package/server/public/app/store.js

@@ -3,6 +3,8 @@ import { recordCliLifecycleEvent, recordRelayLifecycleEvent } from './status-sto
 import { resolveRelayDotState } from './relay-dot-state.mjs';
 import { readRepoBrowserPreferences } from './repo-browser-preferences.mjs';
 import { isChatInteractionHeld } from './selection-guard.mjs';
+import { nextSubagentStatus } from './subagent-fold.mjs';
+import { useStrictStrikethrough } from './markdown-strikethrough.mjs';
 
 function resolveAppBase() {
   const configuredBase = typeof window.__COPILOT_APP_CONFIG?.basePath === 'string'
@@ -173,6 +175,7 @@ const CONVERSATION_SCROLL_STORAGE_PREFIX = 'copilot_message_scroll_';
 
 if (globalThis.marked && typeof globalThis.marked.setOptions === 'function') {
   globalThis.marked.setOptions({ breaks: true });
+  useStrictStrikethrough(globalThis.marked);
 } else {
   console.warn('[store] marked unavailable; markdown rendering will use plain-text fallback.');
 }
@@ -1475,7 +1478,7 @@ export function upsertSubagentRun(payload) {
     conversationId: String(payload?.conversationId || existing?.conversationId || '').trim() || null,
     parentSubagentId: normalizeSubagentRunId(payload?.parentSubagentId) || existing?.parentSubagentId || null,
     displayName: String(payload?.displayName || existing?.displayName || '').trim() || null,
-    status: normalizeSubagentStatus(payload?.status) || existing?.status || 'running',
+    status: nextSubagentStatus({ reported: payload?.status, known: existing?.status, normalize: normalizeSubagentStatus }),
     startedAt: existing?.startedAt || payload?.timestamp || now,
     updatedAt: payload?.timestamp || now,
     activities: existing?.activities || [],

package/server/public/app/subagent-fold.mjs

@@ -0,0 +1,61 @@
+// Whether a live subagent bubble is shown folded (header only), and what the
+// header says while it is.
+//
+// A running turn can hold many subagents, and each keeps its whole transcript
+// in its bubble: on a phone that is screens of text to scroll past to reach
+// the turn's own output. So a bubble is folded from the start and stays folded
+// until the user opens it; what they chose by hand holds, in either direction,
+// for as long as the bubble lives. The folded header makes up for it with one
+// line: how many steps the run has taken and the latest one.
+
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'dropped', 'done']);
+
+export function isTerminalSubagentStatus(status) {
+  return TERMINAL_STATUSES.has(String(status || '').trim().toLowerCase());
+}
+
+/**
+ * `choice` is the user's own: 'open', 'folded', or nothing.
+ */
+export function resolveSubagentFold({ choice = null } = {}) {
+  return choice !== 'open';
+}
+
+/** The choice a tap on the header records, given what the bubble shows now. */
+export function toggledSubagentFoldChoice(folded) {
+  return folded ? 'open' : 'folded';
+}
+
+const SUMMARY_MAX_CHARS = 160;
+
+function oneLine(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * The line a folded header shows: the number of steps (activity lines) and
+ * the latest one, or the end of what the run has written when it has taken
+ * no step yet. Empty when there is nothing to say.
+ */
+export function subagentFoldSummary({ activities = [], streamText = '' } = {}) {
+  const steps = (Array.isArray(activities) ? activities : []).map(oneLine).filter(Boolean);
+  if (steps.length) {
+    const latest = steps[steps.length - 1];
+    const count = steps.length === 1 ? '1 step' : `${steps.length} steps`;
+    return `${count} · ${latest}`.slice(0, SUMMARY_MAX_CHARS);
+  }
+  const lines = String(streamText || '').split(/\r?\n/).map(oneLine).filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, SUMMARY_MAX_CHARS) : '';
+}
+
+/**
+ * The status a run has after an update. Most updates report none (an
+ * activity line, a stream frame, a restored snapshot's activity list), and
+ * those must leave the status alone: reading "no status" as "running" turned
+ * every finished run back into a running one on the next line of any kind.
+ */
+export function nextSubagentStatus({ reported, known, normalize = (value) => value } = {}) {
+  const text = String(reported || '').trim();
+  if (text) return normalize(text);
+  return String(known || '').trim() || 'running';
+}

package/server/public/app/usage-limit-ui.js

@@ -0,0 +1,225 @@
+// The Claude subscription's usage limit, as the open conversation sees it: a
+// banner above the composer. Before the limit it warns ("usage at 96 %"); at
+// the limit it says when the window resets; and when a turn of this
+// conversation was paused there, it says when the turn carries on, with
+// Resume now and Cancel.
+//
+// State arrives over the socket (`usage_limit_pause` per conversation,
+// `claude_usage_limit` for the account), with the conversation payload, and
+// with GET /api/status polls, so a client that missed an event catches up.
+
+import { showTransientRelayNotice } from './store.js';
+import { cancelUsageLimitPause, resumeUsageLimitPause } from './api-client.js';
+
+const BANNER_ID = 'usage-limit-banner';
+const DISMISSED_KEY = 'oar.usageLimitWarningDismissed';
+// The CLI warns from 90 % on; a report below that is not worth a banner.
+const WARNING_FROM = 0.9;
+
+let account = null;
+const pauses = new Map();
+let currentConversationId = '';
+let currentProviderType = '';
+let actionInFlight = false;
+let wakeTimer = null;
+
+function isFuture(iso, nowMs) {
+  const at = Date.parse(String(iso || ''));
+  return Number.isFinite(at) && at > nowMs;
+}
+
+/** "22:01" today, "Thu 2 Oct, 09:00" on another day. */
+export function formatUsageLimitTime(iso, nowMs = Date.now()) {
+  const at = new Date(String(iso || ''));
+  if (Number.isNaN(at.getTime())) return '';
+  const clock = at.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  if (new Date(nowMs).toDateString() === at.toDateString()) return clock;
+  const day = at.toLocaleDateString([], { weekday: 'short', day: 'numeric', month: 'short' });
+  return `${day}, ${clock}`;
+}
+
+/** The pause of a conversation while it still holds the turn back. */
+export function activeUsageLimitPause(conversationId, nowMs = Date.now()) {
+  const pause = pauses.get(String(conversationId || '')) || null;
+  if (!pause) return null;
+  // One that resumes by itself is over once its time has come.
+  if (pause.auto && !isFuture(pause.resumeAt, nowMs)) return null;
+  return pause;
+}
+
+export function usageLimitPauseText(pause, nowMs = Date.now()) {
+  if (!pause) return '';
+  const label = String(pause.label || 'usage limit');
+  if (pause.auto) {
+    return `⏸ Paused at the Claude ${label} — carries on at ${formatUsageLimitTime(pause.resumeAt, nowMs)}`;
+  }
+  if (isFuture(pause.resetsAt, nowMs)) {
+    return `⏸ Paused at the Claude ${label} — resets ${formatUsageLimitTime(pause.resetsAt, nowMs)}`;
+  }
+  if (!pause.resetsAt) return `⏸ Paused at the Claude ${label}`;
+  return `⏸ Paused at the Claude ${label} — the limit has reset`;
+}
+
+/** The account's line: a warning before the limit, the reset at the limit. */
+export function usageLimitAccountText(state, nowMs = Date.now()) {
+  if (!state || !isFuture(state.resetsAt, nowMs) || state.isUsingOverage) return '';
+  const label = String(state.label || 'usage limit');
+  const resets = formatUsageLimitTime(state.resetsAt, nowMs);
+  if (state.status === 'rejected') {
+    return `Claude ${label} reached — resets ${resets}. A turn sent before that is paused until then.`;
+  }
+  const utilization = Number(state.utilization);
+  if (state.status !== 'allowed_warning' || !Number.isFinite(utilization) || utilization < WARNING_FROM) return '';
+  return `Claude usage at ${Math.round(utilization * 100)} % of the ${label} — resets ${resets}`;
+}
+
+function dismissedKey(state) {
+  return state ? `${state.rateLimitType || ''}|${state.resetsAt || ''}|${state.status || ''}` : '';
+}
+
+function isDismissed(state) {
+  try { return localStorage.getItem(DISMISSED_KEY) === dismissedKey(state); } catch { return false; }
+}
+
+function button(label, className, onClick) {
+  const btn = document.createElement('button');
+  btn.type = 'button';
+  btn.className = `relay-toast-action ${className}`;
+  btn.textContent = label;
+  btn.disabled = actionInFlight;
+  btn.addEventListener('click', (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    void onClick();
+  });
+  return btn;
+}
+
+async function runPauseAction(action) {
+  const conversationId = currentConversationId;
+  if (actionInFlight || !conversationId) return;
+  actionInFlight = true;
+  renderUsageLimitBanner();
+  try {
+    const result = action === 'resume'
+      ? await resumeUsageLimitPause(conversationId)
+      : await cancelUsageLimitPause(conversationId);
+    if (!result?.ok) {
+      showTransientRelayNotice(action === 'resume' ? 'Failed to resume the paused turn.' : 'Failed to cancel the paused turn.', 5000);
+      return;
+    }
+    pauses.delete(conversationId);
+    if (action === 'resume') {
+      showTransientRelayNotice(result.resumed ? 'Paused turn resumed.' : 'No turn was paused.', 4000);
+    } else {
+      showTransientRelayNotice(result.cancelled ? 'Paused turn cancelled.' : 'No turn was paused.', 4000);
+    }
+  } finally {
+    actionInFlight = false;
+    renderUsageLimitBanner();
+  }
+}
+
+function dismissWarning() {
+  try { localStorage.setItem(DISMISSED_KEY, dismissedKey(account)); } catch {}
+  renderUsageLimitBanner();
+}
+
+// The banner says nothing about time passing, but it ends with it: wake up
+// when the turn carries on or the window resets.
+function syncWakeTimer(nowMs) {
+  if (wakeTimer) { clearTimeout(wakeTimer); wakeTimer = null; }
+  const pause = pauses.get(currentConversationId) || null;
+  const times = [pause?.auto ? pause.resumeAt : pause?.resetsAt, account?.resetsAt]
+    .map((iso) => Date.parse(String(iso || '')))
+    .filter((at) => Number.isFinite(at) && at > nowMs);
+  if (!times.length) return;
+  const delay = Math.min(Math.min(...times) - nowMs + 500, 0x7fffffff);
+  wakeTimer = setTimeout(() => renderUsageLimitBanner(), delay);
+  wakeTimer?.unref?.();
+}
+
+export function renderUsageLimitBanner(nowMs = Date.now()) {
+  if (typeof document === 'undefined') return;
+  const banner = document.getElementById(BANNER_ID);
+  if (!banner) return;
+  const children = [];
+  const pause = activeUsageLimitPause(currentConversationId, nowMs);
+  if (pause) {
+    const text = document.createElement('span');
+    text.className = 'usage-limit-text';
+    text.textContent = usageLimitPauseText(pause, nowMs);
+    children.push(text, button('Resume now', 'usage-limit-resume', () => runPauseAction('resume')), button('Cancel', 'usage-limit-cancel', () => runPauseAction('cancel')));
+    banner.dataset.state = 'paused';
+  } else {
+    const line = currentConversationId && currentProviderType === 'claude' && !isDismissed(account)
+      ? usageLimitAccountText(account, nowMs)
+      : '';
+    if (line) {
+      const text = document.createElement('span');
+      text.className = 'usage-limit-text';
+      text.textContent = line;
+      children.push(text, button('Hide', 'usage-limit-dismiss', async () => dismissWarning()));
+      banner.dataset.state = account.status === 'rejected' ? 'reached' : 'warning';
+    }
+  }
+  banner.replaceChildren(...children);
+  banner.classList.toggle('visible', children.length > 0);
+  banner.hidden = children.length === 0;
+  if (!children.length) delete banner.dataset.state;
+  syncWakeTimer(nowMs);
+}
+
+/** `usage_limit_pause`: one conversation's pause, or its end (`pause: null`). */
+export function applyUsageLimitPause(payload) {
+  const conversationId = String(payload?.conversationId || '').trim();
+  if (!conversationId) return;
+  if (payload.pause && typeof payload.pause === 'object') pauses.set(conversationId, payload.pause);
+  else pauses.delete(conversationId);
+  renderUsageLimitBanner();
+}
+
+/** `claude_usage_limit`: the account's latest report, or null past its reset. */
+export function applyClaudeUsageLimit(state) {
+  account = state && typeof state === 'object' ? state : null;
+  renderUsageLimitBanner();
+}
+
+/** GET /api/status carries the account and every pause. */
+export function applyUsageLimitFromStatus(status) {
+  if (!status || typeof status !== 'object' || !('usageLimit' in status)) return;
+  const usageLimit = status.usageLimit || {};
+  account = usageLimit.account && typeof usageLimit.account === 'object' ? usageLimit.account : null;
+  pauses.clear();
+  for (const pause of (Array.isArray(usageLimit.pauses) ? usageLimit.pauses : [])) {
+    const conversationId = String(pause?.conversationId || '').trim();
+    if (conversationId) pauses.set(conversationId, pause);
+  }
+  renderUsageLimitBanner();
+}
+
+/** The conversation on screen, with what its payload said about a pause. */
+export function setUsageLimitConversation(conversationId, { pause = undefined, providerType = '' } = {}) {
+  currentConversationId = String(conversationId || '').trim();
+  currentProviderType = String(providerType || '').trim().toLowerCase();
+  if (currentConversationId && pause !== undefined) {
+    if (pause && typeof pause === 'object') pauses.set(currentConversationId, pause);
+    else pauses.delete(currentConversationId);
+  }
+  renderUsageLimitBanner();
+}
+
+export function initUsageLimitUi() {
+  renderUsageLimitBanner();
+}
+
+export function __resetUsageLimitUiForTests() {
+  account = null;
+  pauses.clear();
+  currentConversationId = '';
+  currentProviderType = '';
+  actionInFlight = false;
+  if (wakeTimer) { clearTimeout(wakeTimer); wakeTimer = null; }
+  try { localStorage.removeItem(DISMISSED_KEY); } catch {}
+  renderUsageLimitBanner();
+}

package/server/public/index.html

@@ -173,7 +173,7 @@
 </script>
 <title>OAR — Open Agent Relay</title>
 <script>document.write('<scr'+'ipt src="'+__APP_BASE+'/socket.io/socket.io.js"><\/scr'+'ipt>');</script>
-<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/marked@15.0.12/marked.min.js"></script>
 <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.22/dist/katex.min.css">
 <script src="https://cdn.jsdelivr.net/npm/katex@0.16.22/dist/katex.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/katex@0.16.22/dist/contrib/mhchem.min.js"></script>
@@ -1451,6 +1451,7 @@
   .thinking-bubble a,
   .subagent-bubble a,
   .relay-question-card a,
+  .relay-board-body a,
   .workspace-file-link {
     color: var(--bubble-link);
     text-decoration-thickness: 1.2px;
@@ -1460,6 +1461,7 @@
   .thinking-bubble a:visited,
   .subagent-bubble a:visited,
   .relay-question-card a:visited,
+  .relay-board-body a:visited,
   .workspace-file-link:visited { color: var(--bubble-link); }
   .msg.user .msg-bubble code:not(pre code) {
     background: var(--user-bubble-chip-bg);
@@ -1701,6 +1703,44 @@
     margin-bottom: 6px;
     font-size: var(--fs-meta-sm);
   }
+  .subagent-bubble-header {
+    cursor: pointer;
+    -webkit-tap-highlight-color: transparent;
+  }
+  .subagent-bubble-header:focus-visible {
+    outline: 2px solid var(--accent-color);
+    outline-offset: 2px;
+    border-radius: 4px;
+  }
+  .subagent-bubble-fold {
+    flex-shrink: 0;
+    width: 1em;
+    color: var(--muted);
+    text-align: center;
+  }
+  .subagent-bubble-fold::before { content: '▾'; }
+  .subagent-bubble.folded > .subagent-bubble-header > .subagent-bubble-fold::before { content: '▸'; }
+  /* Folded: the header alone. What the run wrote, thought and did, and the
+     runs it started, come back with a tap. */
+  .subagent-bubble.folded > :not(.subagent-bubble-header) { display: none; }
+  .subagent-bubble.folded > .subagent-bubble-header { margin-bottom: 0; }
+  .subagent-stop-btn[hidden] { display: none; }
+  /* The folded header's one line about the run. It takes the room the name
+     and the controls leave and is cut with an ellipsis; on a narrow bubble
+     that is little or nothing, and the name keeps its place. */
+  .subagent-bubble-summary {
+    display: none;
+    flex: 1 1 0;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--muted);
+    font-weight: 400;
+  }
+  .subagent-bubble.folded > .subagent-bubble-header > .subagent-bubble-summary { display: block; }
+  .subagent-bubble.folded > .subagent-bubble-header > .subagent-bubble-name { flex: 0 1 auto; max-width: 55%; }
+  .subagent-bubble.folded > .subagent-bubble-header > .subagent-bubble-summary:empty { flex-grow: 1; }
   .subagent-bubble-name {
     font-weight: 600;
     color: var(--text);
@@ -2339,6 +2379,26 @@
     text-align: center;
   }
   #model-banner.visible { display: block; }
+  /* The Claude usage limit (usage-limit-ui.js): a warning before the limit,
+     and a turn paused at it with Resume now / Cancel. In the flow of the
+     composer like #model-banner, for the same reason. */
+  #usage-limit-banner {
+    display: none;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 6px 10px;
+    background: var(--bg2);
+    background: color-mix(in srgb, var(--warn) 14%, var(--bg2));
+    border: 1px solid var(--warn);
+    color: var(--warn);
+    border-radius: 8px;
+    padding: 6px 10px;
+    margin-bottom: 10px;
+    font-size: var(--fs-meta-sm);
+  }
+  #usage-limit-banner.visible { display: flex; }
+  #usage-limit-banner .usage-limit-text { flex: 1 1 12em; min-width: 0; }
+  #usage-limit-banner .relay-toast-action { flex: 0 0 auto; }
   /* Transient relay notices (saves, errors, action confirmations) float as a
      fixed toast above every overlay — the annotation editor's error paths
      rely on being readable over its full-screen modal. pointer-events: none
@@ -3008,6 +3068,17 @@
   .file-preview-markdown th, .file-preview-markdown td { border: 1px solid var(--border); padding: 6px 9px; }
   .file-preview-markdown th { background: var(--bg3); }
   .file-preview-markdown img { display: block; max-width: 100%; height: auto; }
+  /* Without a colour of their own, links fell back to the browser's default
+     blue, which cannot be read on the dark background. The accent is the
+     calmer of the two blues: the bubbles' link colour is for a tinted bubble,
+     and on the viewer's plain background it glares. */
+  .file-preview-markdown a,
+  .file-preview-markdown a:visited {
+    color: var(--accent);
+    text-decoration-thickness: 1.2px;
+    text-underline-offset: 2px;
+  }
+  .file-preview-markdown a code { color: inherit; }
   .file-preview-markdown pre,
   .file-preview-code pre {
     background: #0b0f14;
@@ -4627,6 +4698,23 @@
        and overflow horizontally. Pin to 0 so children wrap/scroll instead. */
     min-width: 0;
   }
+  /* A board inside the bubble of the reply it belongs to: set off from the
+     reply's text by a rule, not by a card of its own. */
+  .relay-board-inline {
+    display: grid;
+    gap: 10px;
+    min-width: 0;
+    margin-top: 12px;
+    padding-top: 12px;
+    border-top: 1px solid rgba(80, 227, 194, 0.35);
+  }
+  .relay-board-inline.relay-board-card { margin-top: 0; border-top: 0; }
+  .relay-board-inline .relay-board-head { color: var(--text); font-weight: 600; font-size: var(--fs-meta-md); }
+  .relay-board-outcome {
+    color: var(--muted);
+    font-size: var(--fs-meta-md);
+  }
+  .relay-board-outcome::before { content: '✓ '; color: var(--success); }
   .relay-board-head {
     display: flex;
     align-items: center;
@@ -5324,6 +5412,7 @@
     <div id="input-area">
       <div id="offline-banner">⚠️ CLI is offline — messages will queue until it reconnects</div>
       <div id="model-banner"></div>
+      <div id="usage-limit-banner" role="status" aria-live="polite" hidden></div>
       <div id="model-lock-note" hidden></div>
       <div id="model-metadata-blocker" aria-live="polite">
         <span id="model-metadata-blocker-text">Model metadata is unavailable. Refresh to choose a model and reasoning effort.</span>

package/server/repositories/message-repository.mjs

@@ -7,6 +7,14 @@ export function createMessageRepository(db) {
     const shareVisibility = createShareVisibilityStatements(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
+    // pending follow-up held until the reset. It is not work waiting for a
+    // worker, so it neither keeps one warm nor counts as queued.
+    const queueHasUsageLimitPause = db.prepare(`PRAGMA table_info(queue)`).all()
+        .some((column) => column.name === 'usage_limit_pause');
+    const notHeldForUsageLimit = (alias = '') => (queueHasUsageLimitPause
+        ? `AND NOT (${alias}usage_limit_pause IS NOT NULL AND ${alias}status = 'pending' AND ${alias}next_attempt_at IS NOT NULL AND ${alias}next_attempt_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`
+        : '');
     const messageColumns = new Set(db.prepare(`PRAGMA table_info(messages)`).all().map((column) => column.name));
     const messagesHaveSourceId = messageColumns.has('source_message_id');
     const messagesHaveResendOf = messageColumns.has('resend_of_message_id');
@@ -270,6 +278,7 @@ export function createMessageRepository(db) {
           LEFT JOIN conversations c
             ON c.id = q.conversation_id
           WHERE q.status = 'pending'
+            ${notHeldForUsageLimit('q.')}
             AND COALESCE(
               NULLIF(q.owner_sdk_session_id, ''),
               NULLIF(rs.sdk_session_id, ''),
@@ -283,7 +292,7 @@ export function createMessageRepository(db) {
           ORDER BY MIN(q.timestamp) ASC
           LIMIT ?
         `),
-        countStatus:    db.prepare(`SELECT status, COUNT(*) as cnt FROM queue WHERE status IN ('pending','processing','parked') GROUP BY status`),
+        countStatus:    db.prepare(`SELECT status, COUNT(*) as cnt FROM queue WHERE status IN ('pending','processing','parked') ${notHeldForUsageLimit()} GROUP BY status`),
         // Deferred host suspend: which conversations still hold live turns.
         listActiveQueueCountsByConversation: db.prepare(`
           SELECT q.conversation_id, COUNT(*) AS cnt, MAX(c.title) AS title

package/server/repositories/question-repository.mjs

@@ -174,6 +174,7 @@ export function createQuestionRepository(db) {
         insertBoard: db.prepare(`INSERT INTO relay_boards (id, queue_id, conversation_id, message_id, board_type, relay_mode, title, body, actions_json, recommended_action, context_json, status, selected_action, acted_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?)`),
         getBoard: db.prepare(`SELECT * FROM relay_boards WHERE id = ?`),
         findBoardByMessageType: db.prepare(`SELECT * FROM relay_boards WHERE message_id = ? AND board_type = ? ORDER BY created_at DESC LIMIT 1`),
+        listBoardsForConversation: db.prepare(`SELECT * FROM relay_boards WHERE conversation_id = ? ORDER BY created_at ASC`),
         listBoards: db.prepare(`SELECT * FROM relay_boards WHERE status = ? AND (? IS NULL OR conversation_id = ?) ORDER BY created_at ASC`),
         markBoardAction: db.prepare(`UPDATE relay_boards SET status = 'acted', selected_action = ?, acted_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'`),
         dismissBoard: db.prepare(`UPDATE relay_boards SET status = 'dismissed', selected_action = ?, acted_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'`),

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

@@ -6,6 +6,10 @@ import { normalizeRemoteRelayOrigin } from '../../shared/remote-relay-contract.m
 // conversation has unlocked (the user mentioned them), and the provenance of
 // messages and conversations another relay's agent created. Tables and
 // columns come from migrations/0005-remote-relays.mjs.
+//
+// A relay whose agent wrote to a conversation is open to that conversation as
+// well. That is read from the provenance, not stored as an unlock, so what the
+// user allowed and what another agent started stay apart.
 
 function parseOrigin(json) {
   if (!json) return null;
@@ -26,6 +30,15 @@ export function createRemoteRelayRepository(db) {
   const getMessageOrigin = db.prepare(`SELECT origin_json FROM messages WHERE id = ?`);
   const setConversationOrigin = db.prepare(`UPDATE conversations SET origin_json = ? WHERE id = ?`);
   const getConversationOrigin = db.prepare(`SELECT origin_json FROM conversations WHERE id = ?`);
+  const listUserMessageOrigins = db.prepare(`
+    SELECT DISTINCT origin_json FROM messages
+    WHERE conversation_id = ? AND role = 'user' AND origin_json IS NOT NULL
+  `);
+  const getLatestHumanMessage = db.prepare(`
+    SELECT id FROM messages
+    WHERE conversation_id = ? AND role = 'user' AND origin_json IS NULL
+    ORDER BY timestamp DESC LIMIT 1
+  `);
 
   return {
     hasUnlock(conversationId, remoteRelayId) {
@@ -66,6 +79,23 @@ export function createRemoteRelayRepository(db) {
     getConversationOrigin(conversationId) {
       return parseOrigin(getConversationOrigin.get(String(conversationId || ''))?.origin_json);
     },
+    /**
+     * Did an agent on the relay with this instance id (the `relayId` of an
+     * origin, not the local registry id) write to the conversation: by
+     * starting it, or with a prompt in it?
+     */
+    hasContactFrom(conversationId, remoteInstanceId) {
+      const conversation = String(conversationId || '').trim();
+      const instance = String(remoteInstanceId || '').trim();
+      if (!conversation || !instance) return false;
+      if (parseOrigin(getConversationOrigin.get(conversation)?.origin_json)?.relayId === instance) return true;
+      return listUserMessageOrigins.all(conversation)
+        .some((row) => parseOrigin(row.origin_json)?.relayId === instance);
+    },
+    /** The id of the latest message the user wrote themselves, or null. */
+    latestHumanMessageId(conversationId) {
+      return getLatestHumanMessage.get(String(conversationId || ''))?.id || null;
+    },
   };
 }