@oar-sh/oar 0.9.19 → 0.9.20

package/server/public/app/inbox-ui.js

@@ -13,12 +13,18 @@
 import { apiFetch, answerRelayQuestion } from './api-client.js';
 import { currentConvId, IS_SHARED_VIEW, setCurrentConv, showTransientRelayNotice } from './store.js';
 import { isStatusViewActive, leaveStatusView } from './status-view.mjs';
+import { actOnRelayBoard } from './relay-board-view.js';
 import {
   buildAskCard,
+  captureInboxFolds,
   createCoalescedRefresh,
   inboxPendingCount,
   INBOX_FILTERS,
+  INBOX_FOLD_SELECTOR,
+  noteInboxFold,
+  pruneInboxFolds,
   renderInbox,
+  restoreInboxFolds,
   sessionAsksFromInbox,
 } from './inbox-view.mjs';
 
@@ -37,6 +43,10 @@ let clickBound = false;
 let started = false;
 // Typed answers, kept across re-renders: `${relayId}:${itemId}` → text.
 const drafts = new Map();
+// The open folds (a card's Details, a plan card's plan), kept across
+// re-renders the same way: every socket change and the minute's poll draw
+// the cards anew, closed. Forgotten when the item leaves the list.
+const openFolds = new Set();
 // This relay's asks for the session cards: id → ask (each Inbox load
 // replaces it; the socket updates single asks in between).
 let sessionAsks = new Map();
@@ -104,9 +114,11 @@ function renderInboxNow({ opening = false } = {}) {
   const host = document.getElementById('messages');
   if (!host) return;
   const focused = captureDrafts(host);
+  if (host.querySelector('.inbox-view')) captureInboxFolds(openFolds, host);
   const top = opening ? inboxScrollTop : host.scrollTop;
   host.replaceChildren(renderInbox(document, { relays, filter, now: Date.now(), loading: !loaded }));
   restoreDrafts(host, focused);
+  restoreInboxFolds(openFolds, host);
   host.scrollTop = top;
   const title = document.getElementById('chat-title');
   if (title) {
@@ -122,6 +134,7 @@ async function loadInbox() {
     loaded = true;
     // Built anew from each load: an ask withdrawn or cancelled meanwhile goes.
     sessionAsks = sessionAsksFromInbox(relays);
+    pruneInboxFolds(openFolds, relays);
   }
   syncInboxBadge();
   renderInboxNow();
@@ -268,6 +281,15 @@ async function answerCard(card, data, { choice = '' } = {}) {
   return true;
 }
 
+// A plan card's button in the Inbox: the card's own action, with
+// the plan-only question first; a card settled meanwhile just shows so.
+async function actOnPlanItem(data) {
+  const own = relays.find((relay) => relay?.self === true);
+  const item = (Array.isArray(own?.items) ? own.items : []).find((entry) => entry?.kind === 'plan' && entry.id === data.boardId) || null;
+  const board = item ? { ...item, conversationId: item.session?.id } : null;
+  return !!(await actOnRelayBoard(data.boardId, data.actionId, { board }));
+}
+
 async function handleAction(target) {
   const data = { ...target.dataset };
   const card = target.closest('.inbox-item');
@@ -294,6 +316,7 @@ async function handleAction(target) {
     else if (data.inboxAction === 'dismiss') done = await answerAsk(card, data, { dismiss: true });
     else if (data.inboxAction === 'card-choice') done = await answerCard(card, data, { choice: data.choice });
     else if (data.inboxAction === 'card-answer') done = await answerCard(card, data);
+    else if (data.inboxAction === 'plan-action') done = await actOnPlanItem(data);
   } finally {
     if (!done) for (const node of buttons) node.disabled = false;
   }
@@ -318,6 +341,13 @@ function bindClicks() {
     const key = field ? draftKey(field) : '';
     if (key) drafts.set(key, field.value);
   });
+  // A fold opened or closed by hand. `toggle` does not bubble: caught on the
+  // way down. Also covers a session's card that a transcript render dropped
+  // before renderSessionAskCards drew it again.
+  host?.addEventListener('toggle', (event) => {
+    const details = event.target instanceof Element && event.target.matches(INBOX_FOLD_SELECTOR) ? event.target : null;
+    if (details && details.isConnected) noteInboxFold(openFolds, details);
+  }, true);
 }
 
 // ─── The card in the session ──────────────────────────────────────────────────
@@ -341,6 +371,7 @@ export function renderSessionAskCards() {
   if (key === sessionCardKey && existing.length === shown.length && [...existing].every((node) => node.isConnected)) return;
   sessionCardKey = key;
   const focused = captureDrafts(host);
+  existing.forEach((node) => captureInboxFolds(openFolds, node));
   existing.forEach((node) => node.remove());
   const firstQuestion = host.querySelector('.relay-question-container');
   for (const ask of shown) {
@@ -350,6 +381,7 @@ export function renderSessionAskCards() {
     wrapper.append(buildAskCard(document, { ...ask, session: ask.session || { id } }, { relay: { id: 'self', self: true }, mode: 'session', now: Date.now() }));
     if (firstQuestion) host.insertBefore(wrapper, firstQuestion);
     else host.append(wrapper);
+    restoreInboxFolds(openFolds, wrapper);
   }
   restoreDrafts(host, focused);
 }

package/server/public/app/inbox-view.mjs

@@ -11,11 +11,26 @@
 // values of shared/relay-asks.mjs this needs are kept here, and
 // inbox-view.test.mjs asserts they match.
 
+import { boardOutcomeLine } from './relay-board-inline.mjs';
+
 export const RELAY_ASK_SOCKET_EVENT = 'relay_ask_updated';
+export const INBOX_REMOTE_CHANGED_EVENT = 'inbox_remote_changed';
 export const INBOX_ANSWERED_KEEP_MS = 24 * 60 * 60_000;
 export const INBOX_FILTERS = Object.freeze(['all', 'mine', 'agents']);
 
-const CLOSED_STATUSES = new Set(['answered', 'dismissed']);
+// The head label of a paired relay's approval card by its `variant`
+// (REMOTE_RELAY_APPROVAL_VARIANTS of shared/remote-relay-contract.mjs).
+export const INBOX_APPROVAL_VARIANT_LABELS = Object.freeze({
+  create_session: 'New session',
+  loop_guard: 'Loop guard',
+  write: 'Write',
+  session_settings: 'Session settings',
+  watch: 'Watch',
+  local_sessions: 'Start sessions',
+});
+
+// A plan card that was acted on is closed too.
+const CLOSED_STATUSES = new Set(['answered', 'dismissed', 'acted']);
 
 function toText(value) {
   return String(value ?? '').trim();
@@ -71,6 +86,11 @@ function isClosed(item) {
   return CLOSED_STATUSES.has(toText(item?.status));
 }
 
+// When an item was closed: answered, a plan card acted on, else made.
+function closedAt(item) {
+  return item?.answeredAt || item?.actedAt || item?.createdAt;
+}
+
 function newestFirst(a, b) {
   return toText(b?.createdAt).localeCompare(toText(a?.createdAt));
 }
@@ -85,8 +105,8 @@ export function inboxSections(relays, { filter = 'all', now = Date.now() } = {})
     const items = (Array.isArray(relay?.items) ? relay.items : []).filter((item) => item && toText(item.id) && inboxFilterMatches(item, filter));
     const pending = items.filter((item) => toText(item.status) === 'pending').sort(newestFirst);
     const closed = items
-      .filter((item) => isClosed(item) && now - (Date.parse(toText(item.answeredAt || item.createdAt)) || 0) <= INBOX_ANSWERED_KEEP_MS)
-      .sort((a, b) => toText(b.answeredAt || b.createdAt).localeCompare(toText(a.answeredAt || a.createdAt)));
+      .filter((item) => isClosed(item) && now - (Date.parse(toText(closedAt(item))) || 0) <= INBOX_ANSWERED_KEEP_MS)
+      .sort((a, b) => toText(closedAt(b)).localeCompare(toText(closedAt(a))));
     return {
       relay: {
         id: toText(relay?.id),
@@ -147,6 +167,59 @@ export function sessionAsksFromInbox(relays) {
   return asks;
 }
 
+// The folds a card has: an ask's `Details` and a plan card's `The plan`.
+export const INBOX_FOLD_SELECTOR = 'details.inbox-item-detail, details.inbox-plan-body';
+
+/**
+ * A fold's key: its card's relay and id, and which fold it is. Every render
+ * builds the cards anew, closed; the keys of the open ones carry them over.
+ */
+export function inboxFoldKey(details) {
+  const card = details?.closest?.('.inbox-item');
+  const itemId = toText(card?.dataset?.itemId);
+  if (!itemId) return '';
+  const fold = details.classList?.contains('inbox-plan-body') ? 'plan' : 'detail';
+  return `${toText(card.dataset.relayId) || 'self'}\n${itemId}\n${fold}`;
+}
+
+/** Notes whether `details` is open in `openFolds` (a Set of fold keys). */
+export function noteInboxFold(openFolds, details) {
+  const key = inboxFoldKey(details);
+  if (!key) return;
+  if (details.open) openFolds.add(key);
+  else openFolds.delete(key);
+}
+
+/** Notes every fold under `root`, as it is now. */
+export function captureInboxFolds(openFolds, root) {
+  for (const details of root?.querySelectorAll?.(INBOX_FOLD_SELECTOR) || []) noteInboxFold(openFolds, details);
+}
+
+/** Opens the folds under `root` that were open before its re-render. */
+export function restoreInboxFolds(openFolds, root) {
+  for (const details of root?.querySelectorAll?.(INBOX_FOLD_SELECTOR) || []) {
+    if (openFolds.has(inboxFoldKey(details))) details.open = true;
+  }
+}
+
+/**
+ * Forgets the folds of items no longer listed (an Inbox load, GET
+ * /api/inbox). A relay that did not answer keeps its folds: its items did
+ * not leave, they are just not shown.
+ */
+export function pruneInboxFolds(openFolds, relays, { now = Date.now() } = {}) {
+  const listed = new Set();
+  const kept = new Set();
+  for (const section of inboxSections(relays, { now })) {
+    if (!section.relay.reachable) kept.add(section.relay.id || 'self');
+    for (const item of [...section.pending, ...section.closed]) listed.add(`${section.relay.id || 'self'}\n${toText(item.id)}`);
+  }
+  for (const key of [...openFolds]) {
+    const [relayId, itemId] = key.split('\n');
+    if (!kept.has(relayId) && !listed.has(`${relayId}\n${itemId}`)) openFolds.delete(key);
+  }
+}
+
 /** Pending items across every relay (the sidebar's badge), whatever the filter. */
 export function inboxPendingCount(relays) {
   return (Array.isArray(relays) ? relays : [])
@@ -269,10 +342,17 @@ export function buildCardItem(doc, item, { relay = null, now = Date.now() } = {}
   card.dataset.kind = toText(item.kind) || 'ask_user';
   if (relay?.id) card.dataset.relayId = relay.id;
   card.dataset.status = toText(item.status) || 'pending';
-  card.append(headLine(doc, item, { relay, now, label: approval ? 'Approval · the session waits' : 'Question · the session waits' }));
+  // A paired relay's approval says what it is about; one from a
+  // relay without summaries (0.9.19) keeps the plain text.
+  const summary = approval && !relay?.self ? toText(item.summary) : '';
+  const variant = toText(item.variant);
+  const variantLabel = Object.hasOwn(INBOX_APPROVAL_VARIANT_LABELS, variant) ? INBOX_APPROVAL_VARIANT_LABELS[variant] : '';
+  const kindLabel = summary ? (variantLabel || 'Approval') : (approval ? 'Approval' : 'Question');
+  card.append(headLine(doc, item, { relay, now, label: `${kindLabel} · the session waits` }));
   card.append(sessionLine(doc, item, relay));
   if (toText(item.header)) card.append(el(doc, 'div', 'inbox-item-header', item.header));
-  if (toText(item.question)) card.append(el(doc, 'p', 'inbox-item-question', item.question));
+  if (summary) card.append(el(doc, 'p', 'inbox-item-question inbox-item-summary', `${toText(relay?.name) || 'that relay'} · ${summary}`));
+  else if (toText(item.question)) card.append(el(doc, 'p', 'inbox-item-question', item.question));
   else if (approval) card.append(el(doc, 'p', 'inbox-item-question', 'An Allow / Deny card on that relay.'));
   const outcome = outcomeLine(doc, item);
   if (outcome) card.append(outcome);
@@ -321,8 +401,64 @@ export function buildCardItem(doc, item, { relay = null, now = Date.now() } = {}
   return card;
 }
 
+/**
+ * A plan card in the Inbox: the plan folded, and the card's own
+ * buttons, which act as the card in its session does (a plan-only session
+ * asks first). Settled, it says what was chosen. A paired relay's shows its
+ * title alone: "Open there".
+ */
+export function buildPlanItem(doc, item, { relay = null, now = Date.now() } = {}) {
+  const card = el(doc, 'article', 'inbox-item inbox-card inbox-plan');
+  card.dataset.itemId = toText(item.id);
+  card.dataset.kind = 'plan';
+  if (relay?.id) card.dataset.relayId = relay.id;
+  card.dataset.status = toText(item.status) || 'pending';
+  card.append(headLine(doc, item, { relay, now, label: 'Plan · ready for review' }));
+  card.append(sessionLine(doc, item, relay));
+  card.append(el(doc, 'div', 'inbox-item-header', toText(item.title) || 'Plan ready for review'));
+  if (relay?.self && toText(item.body)) {
+    const details = el(doc, 'details', 'inbox-plan-body');
+    details.append(el(doc, 'summary', '', 'The plan'));
+    details.append(el(doc, 'div', 'inbox-plan-text', item.body));
+    card.append(details);
+  }
+  if (item.status !== 'pending') {
+    const outcome = boardOutcomeLine(item);
+    if (outcome) card.append(el(doc, 'div', 'inbox-item-outcome', outcome));
+    return card;
+  }
+  if (!relay?.self) {
+    const url = inboxSessionUrl(relay?.url, item?.session?.id);
+    const actions = el(doc, 'div', 'inbox-item-actions');
+    if (url) {
+      const link = el(doc, 'a', 'inbox-open-there inbox-open-there-button', 'Open there');
+      link.href = url;
+      link.target = '_blank';
+      link.rel = 'noopener noreferrer';
+      actions.append(link);
+    } else {
+      actions.append(el(doc, 'span', 'inbox-item-note', 'Answer it on that relay.'));
+    }
+    card.append(actions);
+    return card;
+  }
+  const recommended = toText(item.recommendedAction).toLowerCase();
+  const row = el(doc, 'div', 'inbox-item-options inbox-plan-actions');
+  for (const action of Array.isArray(item.actions) ? item.actions : []) {
+    const actionId = toText(action?.id).toLowerCase();
+    if (!actionId) continue;
+    const node = button(doc, `inbox-choice inbox-plan-action${actionId === recommended ? ' inbox-plan-action-recommended' : ''}`, toText(action?.label) || actionId, {
+      relayId: 'self', inboxAction: 'plan-action', boardId: item.id, actionId, sessionId: item?.session?.id,
+    });
+    row.append(node);
+  }
+  card.append(row);
+  return card;
+}
+
 function buildItem(doc, item, relay, now) {
   if (item.kind === 'ask') return buildAskCard(doc, item, { relay, now, mode: 'inbox', answerable: true });
+  if (item.kind === 'plan') return buildPlanItem(doc, item, { relay, now });
   return buildCardItem(doc, item, { relay, now });
 }
 

package/server/public/app/plan-board-shared.mjs

@@ -0,0 +1,49 @@
+// Browser mirror of the pieces of shared/plan-board-actions.mjs the web UI
+// needs. The browser cannot import shared/ (only server/public is served), so
+// these are hand-kept copies; plan-board-shared.test.mjs asserts they match.
+// Below them, the web UI's own plan-only wording.
+
+/** The actions that take the session out of plan mode for good. */
+export const PLAN_BOARD_LEAVES_PLAN = Object.freeze(['autopilot', 'autopilot_fleet', 'interactive']);
+
+export const PLAN_BOARD_LABELS = Object.freeze({
+  approve_only: 'Approve plan',
+  autopilot: 'Implement in autopilot',
+  autopilot_fleet: 'Implement with autopilot fleet',
+  interactive: 'Stop here and prompt myself',
+  exit_only: 'Stop here',
+});
+
+/** The button's label; an id the table does not know is spelled out. */
+export function planBoardActionLabel(id) {
+  const key = String(id || '').trim().toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(PLAN_BOARD_LABELS, key)) return PLAN_BOARD_LABELS[key];
+  return key.replace(/[_-]+/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase()) || 'Select';
+}
+
+/**
+ * On a plan-only session the actions that leave plan mode for good ask
+ * first; "Approve plan", "Stop here" and an action the relay does not know
+ * never do. The question, or '' when there is none.
+ */
+export function planBoardConfirmText({ planOnly = false, actionId = '', label = '' } = {}) {
+  const id = String(actionId || '').trim().toLowerCase();
+  if (planOnly !== true || !PLAN_BOARD_LEAVES_PLAN.includes(id)) return '';
+  const name = String(label || '').trim() || planBoardActionLabel(id);
+  return `This session is plan-only. ${name} leaves plan mode. Go on?`;
+}
+
+/** The mode select's hint on a plan-only session (title and the plan option's text). */
+export function planOnlyModeHint(planOnly) {
+  return planOnly === true
+    ? { title: 'Mode · plan-only: agents can\'t take this session out of plan mode', planLabel: 'Plan 🔒' }
+    : { title: 'Mode', planLabel: 'Plan' };
+}
+/**
+ * The plan-only flag after a conversation_preferences_updated broadcast: the
+ * one it carries, else the one already known (an older relay, or the mode
+ * follow-up of a plan card, says nothing about it).
+ */
+export function planOnlyAfterBroadcast(broadcast, known) {
+  return typeof broadcast === 'boolean' ? broadcast : known === true;
+}

package/server/public/app/plan-usage-view.mjs

@@ -280,7 +280,7 @@ function renderChart(chart) {
 
 function renderDetailSection(section) {
   const rows = section.rows.map((row) => `
-    <tr>
+    <tr${row.title ? ` title="${escapeHtml(row.title)}"` : ''}>
       <td class="plan-usage-detail-label">${escapeHtml(row.label)}${row.hint ? `<span class="plan-usage-detail-hint">${escapeHtml(row.hint)}</span>` : ''}</td>
       <td class="plan-usage-detail-value">${String(row.value).split(' · ').map((part) => `<span class="plan-usage-detail-part">${escapeHtml(part)}</span>`).join(' · ')}</td>
     </tr>

package/server/public/app/relay-board-inline.mjs

@@ -11,6 +11,8 @@
 // board when the agent wrote its plan as the answer. Then the text is shown
 // once, as the reply, and the board adds only its buttons.
 
+import { PLAN_BOARD_LABELS } from './plan-board-shared.mjs';
+
 function plain(text) {
   return String(text || '').replace(/\s+/g, ' ').trim().toLowerCase();
 }
@@ -32,7 +34,8 @@ export function chosenActionLabel(board) {
   if (!chosen) return '';
   const actions = Array.isArray(board?.actions) ? board.actions : [];
   const action = actions.find((item) => String(item?.id || '').trim().toLowerCase() === chosen);
-  return String(action?.label || '').trim() || chosen.replace(/[_-]+/g, ' ');
+  // A card stored before "Approve plan" existed does not list it.
+  return String(action?.label || '').trim() || (Object.hasOwn(PLAN_BOARD_LABELS, chosen) ? PLAN_BOARD_LABELS[chosen] : chosen.replace(/[_-]+/g, ' '));
 }
 
 /** The line that replaces the buttons once the board is settled; '' while it is pending. */

package/server/public/app/relay-board-view.js

@@ -1,5 +1,6 @@
 import {
   IS_SHARED_VIEW,
+  conversations,
   currentConvId,
   escHtml,
   relayBoards,
@@ -12,9 +13,11 @@ import {
   boardsOfConversation,
 } from './relay-board-inline.mjs';
 import {
+  loadRelayBoard as loadRelayBoardApi,
   loadRelayBoards as loadRelayBoardsApi,
   submitRelayBoardAction as submitRelayBoardActionApi,
 } from './api-client.js';
+import { planBoardConfirmText } from './plan-board-shared.mjs';
 import { renderMarkdownPreview } from './router.js';
 import { attachCodeCopyButtons } from './code-copy.mjs';
 import { beginOwnSend, followsTranscriptEnd, refreshJumpButton, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
@@ -203,27 +206,52 @@ export function renderRelayBoards() {
   return added;
 }
 
-export async function submitRelayBoardAction(boardId, actionId) {
+/**
+ * Settle a board, from its card or from the Inbox (`board`: what the caller
+ * shows, when the store has no copy; `controls`: the buttons to hold while
+ * it goes). On a plan-only session an action that leaves plan mode asks
+ * first. A board the other view settled meanwhile is shown as settled, with
+ * no alert. Returns the board as it is now, or null when nothing was done.
+ */
+export async function actOnRelayBoard(boardId, actionId, { board: shown = null, controls = [] } = {}) {
   const id = String(boardId || '').trim();
   const nextActionId = String(actionId || '').trim();
-  if (!id || !nextActionId) return;
-  const card = document.querySelector(`.relay-board-inline[data-board-id="${CSS.escape(id)}"]`);
-  const controls = card ? card.querySelectorAll('button') : [];
+  if (!id || !nextActionId) return null;
+  const board = relayBoards.get(id) || shown;
+  // The flag as the page knows it now; the board's own copy otherwise.
+  const conversation = conversations[String(board?.conversationId || shown?.session?.id || '').trim()] || null;
+  const planOnly = typeof conversation?.planOnly === 'boolean' ? conversation.planOnly : board?.planOnly === true;
+  const action = (Array.isArray(board?.actions) ? board.actions : [])
+    .find((item) => String(item?.id || '').trim().toLowerCase() === nextActionId.toLowerCase());
+  const question = planBoardConfirmText({ planOnly, actionId: nextActionId, label: action?.label });
+  if (question && !window.confirm(question)) return null;
   controls.forEach((control) => { control.disabled = true; });
-  const send = beginOwnSend();
-
+  let status = 0;
   try {
-    const r = await submitRelayBoardActionApi(id, nextActionId);
-    if (!r?.board) throw new Error('Failed to submit board action');
+    const r = await submitRelayBoardActionApi(id, nextActionId, { onErrorResponse: (response) => { status = response.status; } });
+    let settled = r?.board || null;
+    // Settled by the other view (or another page) meanwhile: show what was chosen.
+    if (!settled && status === 409) settled = (await loadRelayBoardApi(id))?.board || null;
+    if (!settled) throw new Error('Failed to submit board action');
     // Kept once it is settled: the reply goes on showing the plan and says
     // what was chosen.
-    relayBoards.set(id, r.board);
+    relayBoards.set(id, settled);
     window.renderConvList?.();
     renderRelayBoards();
-    scrollAfterOwnSend(send);
+    return settled;
   } catch (error) {
     controls.forEach((control) => { control.disabled = false; });
     alert(error.message || 'Failed to submit board action');
+    return null;
   }
 }
 
+export async function submitRelayBoardAction(boardId, actionId) {
+  const id = String(boardId || '').trim();
+  if (!id || !String(actionId || '').trim()) return;
+  const card = document.querySelector(`.relay-board-inline[data-board-id="${CSS.escape(id)}"]`);
+  const controls = card ? [...card.querySelectorAll('button')] : [];
+  const send = beginOwnSend();
+  if (await actOnRelayBoard(id, actionId, { controls })) scrollAfterOwnSend(send);
+}
+

package/server/public/app/relay-event-view.mjs

@@ -14,6 +14,7 @@ export const RELAY_EVENT_SOCKET_EVENT = 'relay_event_subscriptions';
 
 const EVENT_TYPES = new Set([
   'question_asked',
+  'question_answered',
   'error',
   'turn_end',
   'task_started',
@@ -21,6 +22,7 @@ const EVENT_TYPES = new Set([
   'task_failed',
   'stalled',
   'all_idle',
+  'board_settled',
   'heartbeat',
   'link_lost',
   'link_restored',
@@ -35,6 +37,7 @@ const LINE_PREFIX = '[relay event] ';
 
 const TYPE_LABELS = Object.freeze({
   question_asked: 'question',
+  question_answered: 'answer',
   error: 'error',
   turn_end: 'reply',
   task_started: 'task started',
@@ -42,6 +45,7 @@ const TYPE_LABELS = Object.freeze({
   task_failed: 'task failed',
   stalled: 'stalled',
   all_idle: 'all idle',
+  board_settled: 'plan card settled',
   heartbeat: 'heartbeat',
   link_lost: 'link lost',
   link_restored: 'link back',

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

@@ -40,7 +40,7 @@ import { applyBackgroundTasksToConversation, applyTurnStatusToConversation } fro
 import { applyRelayEventSubscriptions, loadRelayEventSubscriptions } from './relay-event-subscriptions-ui.js';
 import { applyRelaySchedules, loadRelaySchedules } from './relay-schedules-ui.js';
 import { noteInboxQuestionsChanged, noteRelayAskUpdated, refreshInbox } from './inbox-ui.js';
-import { RELAY_ASK_SOCKET_EVENT } from './inbox-view.mjs';
+import { INBOX_REMOTE_CHANGED_EVENT, RELAY_ASK_SOCKET_EVENT } from './inbox-view.mjs';
 import {
   upsertRelayQuestion,
   loadRelayQuestions,
@@ -104,6 +104,7 @@ import { stripRelayPromptContext } from './relay-prompt-sanitizer.mjs';
 import { isLikelyLiveDuplicateMessage } from './live-message-dedupe.mjs';
 import { mergeRelayThoughts } from './relay-thoughts.mjs';
 import { conversationPayloadCache } from './conversation-payload-cache.mjs';
+import { planOnlyAfterBroadcast } from './plan-board-shared.mjs';
 
 // A live row of the conversation on screen joins its kept window, so a
 // switch away and back still shows it. Rows of other conversations do not:
@@ -664,12 +665,16 @@ export async function connectSocket(overrideDeps) {
     loadRelayQuestions(currentConvId);
     noteInboxQuestionsChanged();
   });
+  // A paired relay's pending cards changed (this relay checks them every ~20 s).
+  socket.on(INBOX_REMOTE_CHANGED_EVENT, () => noteInboxQuestionsChanged());
   // Questions that don't block: one ask, after every change of it.
   socket.on(RELAY_ASK_SOCKET_EVENT, (payload) => noteRelayAskUpdated(payload));
   socket.on('relay_board', ({ board }) => upsertRelayBoard(board));
   socket.on('relay_board_updated', ({ board }) => upsertRelayBoard(board));
   socket.on('relay_board_changed', () => {
     loadRelayBoards();
+    // Plan cards are in the Inbox too.
+    noteInboxQuestionsChanged();
   });
   // Relay event subscriptions: the whole active list, after every change.
   socket.on('relay_event_subscriptions', ({ subscriptions }) => {
@@ -846,7 +851,7 @@ export async function connectSocket(overrideDeps) {
     applyConversationTitleUpdate(conversationId, title, updatedAt);
     syncChatTitleControls();
   });
-  socket.on('conversation_preferences_updated', ({ conversationId, preferredRelayMode, preferredModel, preferredReasoningEffort, autoCompactWindow, thinkingEnabled, thinkingDisplay, mayCreateSessions, senderClientId }) => {
+  socket.on('conversation_preferences_updated', ({ conversationId, preferredRelayMode, preferredModel, preferredReasoningEffort, autoCompactWindow, thinkingEnabled, thinkingDisplay, mayCreateSessions, planOnly, senderClientId }) => {
     if (senderClientId && senderClientId === CLIENT_ID) return;
     const id = String(conversationId || '').trim();
     if (!id || !conversations[id]) return;
@@ -872,6 +877,9 @@ export async function connectSocket(overrideDeps) {
       mayCreateSessions: typeof mayCreateSessions === 'boolean'
         ? mayCreateSessions
         : conversations[id].mayCreateSessions === true,
+      // Plan-only: a broadcast without it (an older relay, a board's mode
+      // follow-up) keeps the known value.
+      planOnly: planOnlyAfterBroadcast(planOnly, conversations[id].planOnly),
     };
     if (String(currentConvId || '').trim() === id) {
       applyConversationPreferencesForConversation(id, {

package/server/public/index.html

@@ -937,6 +937,10 @@
     gap: 6px;
   }
   .inbox-choice.recommended { border-color: var(--accent); }
+  /* A plan card in the Inbox: the plan folded, its own buttons. */
+  .inbox-choice.inbox-plan-action-recommended { border-color: var(--accent); }
+  .inbox-plan-body summary { cursor: pointer; color: var(--muted); font-size: var(--fs-meta-sm); }
+  .inbox-plan-text { white-space: pre-wrap; overflow-wrap: anywhere; max-height: 40vh; overflow: auto; margin-top: 4px; }
   .inbox-recommended-tag { color: var(--accent); font-size: var(--fs-meta-xs); }
   .inbox-answer { border-color: var(--accent); color: var(--accent); }
   .inbox-dismiss { color: var(--muted); }
@@ -3193,6 +3197,10 @@
   .about-usage-provider { font-size: 0.82rem; font-weight: 600; margin-top: 8px; }
   .about-usage-provider:first-child { margin-top: 0; }
   .about-state { font-weight: 600; }
+  /* A path (the database file, the backup folder) wraps anywhere rather than
+     pushing the card wider than a phone's screen. */
+  .about-section .plan-usage-detail-value { white-space: normal; overflow-wrap: anywhere; }
+  .about-section .plan-usage-detail-hint { overflow-wrap: anywhere; }
   .about-state[data-state="online"] { color: var(--success); }
   .about-state[data-state="offline"] { color: var(--warn); }
   .about-state[data-state="idle"] { color: var(--muted); }
@@ -4417,6 +4425,12 @@
     min-width: 84px; width: 84px; outline: none;
   }
   #mode-select:focus { border-color: var(--accent); }
+  /* A plan-only session: agents can't take it out of plan mode. */
+  #mode-select[data-plan-only="true"] { border-style: dashed; border-color: var(--accent); }
+  /* Room for "Plan 🔒" beside the arrow; the phone layouts size the select themselves. */
+  @media (min-width: 681px) {
+    #mode-select[data-plan-only="true"] { min-width: 104px; width: 104px; }
+  }
   #send-btn:disabled { opacity: 0.4; cursor: not-allowed; }
   #send-btn:not(:disabled):hover { opacity: 0.85; }
 

package/server/public/sw.js

@@ -191,6 +191,14 @@ async function handleNotificationClick(event) {
       if (ok) return;
     }
   }
+  // A card on a paired relay: it carries no question id, only the
+  // link of its session there, and is answered there ("Open there").
+  const url = String(data.url || '');
+  if (!data.questionId && /^https?:\/\//i.test(url)) {
+    event.notification.close();
+    await self.clients.openWindow(url);
+    return;
+  }
   event.notification.close();
   await focusOrOpenConversation(String(data.conversationId || ''));
 }

package/server/relay-heap-guard.mjs

@@ -141,7 +141,9 @@ export function configuredHeapLimit({ configPath, fsImpl = fs } = {}) {
   return Number.isInteger(mb) && mb >= MIN_HEAP_LIMIT_MB ? { mb } : { invalid: value };
 }
 
-function freeBytes(dir, fsImpl) {
+// Free bytes on the disk of `dir`, or null when unknown. Also used by the
+// database backup's space check (db-backup-service.mjs), with diskBytes.
+export function freeBytes(dir, fsImpl) {
   try {
     if (typeof fsImpl.statfsSync !== 'function') return null;
     const stats = fsImpl.statfsSync(dir);
@@ -151,6 +153,17 @@ function freeBytes(dir, fsImpl) {
   }
 }
 
+// The size of the disk of `dir`, or null when unknown.
+export function diskBytes(dir, fsImpl) {
+  try {
+    if (typeof fsImpl.statfsSync !== 'function') return null;
+    const stats = fsImpl.statfsSync(dir);
+    return Number(stats.blocks) * Number(stats.bsize);
+  } catch {
+    return null;
+  }
+}
+
 /** A path for the log: `~` for the home folder, so a log line names no user. */
 export function displayPath(target, homeDir = os.homedir()) {
   const resolved = path.resolve(String(target || ''));