@oar-sh/oar 0.9.20 → 0.9.21

package/server/cursor-worker/cursor-session-worker.mjs

@@ -13,10 +13,12 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { resolveBuildId } from '../../shared/build-id.mjs';
 import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createCursorTurnRunner } from './cursor-turn-runner.mjs';
+import { buildCursorSteeringState } from './cursor-worker-steering.mjs';
 import { resolveCursorSessionStoreDir } from '../services/cursor-session-root-service.mjs';
 
 // Windows console launch: the launcher names the worker log, this copies
@@ -48,6 +50,10 @@ async function main() {
 
   const configPath = String(process.env.COPILOT_WEB_RELAY_CONFIG || '').trim()
     || path.resolve(__dirname, '..', 'config.json');
+  // The code this process started on, read once from the repo root and kept
+  // for its whole life: the relay recycles a worker whose build differs from
+  // its own, and a tree that moves on under us must not change our answer.
+  const buildId = resolveBuildId(path.resolve(__dirname, '..', '..')).id;
   const serverUrl = resolveRelayServerUrl({ configPath });
   const token = loadTokenFromConfig(configPath);
   const cwd = String(process.env.COPILOT_WORKSPACE_ROOT || '').trim() || process.cwd();
@@ -93,17 +99,22 @@ async function main() {
   let heartbeatTimer = null;
   const heartbeat = createHeartbeatController({
     api,
+    buildId,
     pollMs: HEARTBEAT_MS,
     getSessionReady: () => true,
     getHeartbeatTimer: () => heartbeatTimer,
     setHeartbeatTimer: (timer) => { heartbeatTimer = timer; },
     getActiveQueueMessageId: () => turnRunner.getActiveQueueMessageId(),
+    // No steering here; the snapshot tells the relay when it may replace
+    // this worker: between turns (the agent handle is rebuilt on demand).
+    getSteeringState: () => buildCursorSteeringState(turnRunner),
   });
 
   const wsLink = createWorkerWebSocketLink({
     serverUrl,
     token,
     dbg,
+    buildId,
     getSessionReady: () => true,
     getSessionId: () => sdkSessionId,
     getPid: () => process.pid,
@@ -146,7 +157,7 @@ async function main() {
     getActiveQueueMessageIds: () => [turnRunner.getActiveQueueAttempt()],
   });
 
-  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}`);
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
   heartbeat.startHeartbeat();
   wsLink.start();
 }

package/server/cursor-worker/cursor-worker-steering.mjs

@@ -0,0 +1,20 @@
+/**
+ * The Cursor worker's heartbeat steering snapshot, from its turn runner
+ * (cursor-turn-runner.mjs). A module of its own so it can be tested: the
+ * worker main runs at import.
+ *
+ * Only a turn holds the release. The Cursor SDK tells the runner of no work
+ * that outlives a run: whether a sub-agent or a background shell can keep
+ * running after the run's result is not something its types say, and the
+ * runner sees neither of them, so there is no background count to send. The
+ * relay's quiet rule (10 minutes without a delivery or a turn end) covers
+ * what the SDK does not say.
+ */
+import { buildSimpleSteeringState } from '../../shared/worker-runtime/simple-steering-state.mjs';
+
+export function buildCursorSteeringState(turnRunner) {
+  return buildSimpleSteeringState({
+    activeAttempt: turnRunner.getActiveQueueAttempt(),
+    turnActive: turnRunner.isTurnActive(),
+  });
+}

package/server/grok-worker/grok-background-tasks.mjs

@@ -235,6 +235,15 @@ export function createGrokTaskPublisher({
     stop,
     /** The ids of the live terminals, for the heartbeat's digest. */
     backgroundTaskIds: () => liveEntries().map((entry) => entry.taskId),
+    /**
+     * Terminals whose process runs and that the agent has not released, from
+     * the moment they start: a superset of the live ids, which wait out the
+     * publish grace first. What may die with the worker, so the relay must
+     * not replace it while any is open (the steering snapshot's count); a
+     * `sleep 600` started a second before a recycle is as live as one the
+     * panel already shows.
+     */
+    openTerminalCount: () => [...terminals.values()].filter((entry) => !entry.exited && !entry.released).length,
     /** The relay asked for the set again (heartbeat answer). */
     resync: () => publish({ resync: true }),
     /** The relay answered a heartbeat: settle notices kept for it go out. */

package/server/grok-worker/grok-session-worker.mjs

@@ -12,10 +12,12 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { resolveBuildId } from '../../shared/build-id.mjs';
 import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createGrokTurnRunner } from './grok-turn-runner.mjs';
+import { buildGrokSteeringState } from './grok-worker-steering.mjs';
 import { createGrokTaskPublisher } from './grok-background-tasks.mjs';
 
 // Windows console launch: the launcher names the worker log, this copies
@@ -47,6 +49,10 @@ async function main() {
 
   const configPath = String(process.env.COPILOT_WEB_RELAY_CONFIG || '').trim()
     || path.resolve(__dirname, '..', 'config.json');
+  // The code this process started on, read once from the repo root and kept
+  // for its whole life: the relay recycles a worker whose build differs from
+  // its own, and a tree that moves on under us must not change our answer.
+  const buildId = resolveBuildId(path.resolve(__dirname, '..', '..')).id;
   const serverUrl = resolveRelayServerUrl({ configPath });
   const token = loadTokenFromConfig(configPath);
   const cwd = String(process.env.COPILOT_WORKSPACE_ROOT || '').trim() || process.cwd();
@@ -96,6 +102,7 @@ async function main() {
   let heartbeatTimer = null;
   heartbeat = createHeartbeatController({
     api,
+    buildId,
     pollMs: HEARTBEAT_MS,
     getSessionReady: () => true,
     getHeartbeatTimer: () => heartbeatTimer,
@@ -106,12 +113,16 @@ async function main() {
     getBackgroundTaskIds: () => turnRunner.backgroundTaskIds(),
     onResyncBackgroundTasks: () => turnRunner.resyncBackgroundTasks(),
     onAnswered: () => turnRunner.flushKeptTaskSettles(),
+    // No steering here; the snapshot tells the relay when it may replace
+    // this worker: no turn, and no open terminal (they end with the worker).
+    getSteeringState: () => buildGrokSteeringState(turnRunner),
   });
 
   const wsLink = createWorkerWebSocketLink({
     serverUrl,
     token,
     dbg,
+    buildId,
     getSessionReady: () => true,
     // A relay that just (re)started learns of the terminals from the digest
     // on the next beat; ask for it now.
@@ -171,7 +182,7 @@ async function main() {
     getActiveQueueMessageIds: () => [turnRunner.getActiveQueueAttempt()],
   });
 
-  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}`);
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
   heartbeat.startHeartbeat();
   wsLink.start();
 }

package/server/grok-worker/grok-turn-runner.mjs

@@ -667,6 +667,9 @@ export function createGrokTurnRunner({
     // The terminals as background tasks: the heartbeat's digest and resync,
     // the panel's Stop, kept settle notices.
     backgroundTaskIds: () => terminalTasks?.backgroundTaskIds() || [],
+    // Every terminal that runs and is not released, published or not yet:
+    // the steering snapshot's background count (grok-worker-steering.mjs).
+    openTerminalCount: () => terminalTasks?.openTerminalCount?.() || 0,
     resyncBackgroundTasks: () => terminalTasks?.resync(),
     stopBackgroundTask: (taskId) => terminalTasks?.stop(taskId) || false,
     flushKeptTaskSettles: () => terminalTasks?.flushKeptSettles(),

package/server/grok-worker/grok-worker-steering.mjs

@@ -0,0 +1,23 @@
+/**
+ * The Grok worker's heartbeat steering snapshot, from its turn runner
+ * (grok-turn-runner.mjs). A module of its own so it can be tested: the worker
+ * main runs at import.
+ *
+ * A turn holds the release, then any open terminal: it dies with the worker.
+ * Counted from the terminal's start (`openTerminalCount`), not from when it
+ * becomes a panel row (`backgroundTaskIds`, after a 2 s grace), so a command
+ * started just before a recycle sweep still holds it.
+ */
+import { buildSimpleSteeringState } from '../../shared/worker-runtime/simple-steering-state.mjs';
+
+export function buildGrokSteeringState(turnRunner) {
+  const open = Number(turnRunner.openTerminalCount?.()) || 0;
+  // The live ids are open terminals too; the larger count wins should the two
+  // ever disagree.
+  const listed = turnRunner.backgroundTaskIds?.().length || 0;
+  return buildSimpleSteeringState({
+    activeAttempt: turnRunner.getActiveQueueAttempt(),
+    turnActive: turnRunner.isTurnActive(),
+    backgroundTaskCount: Math.max(open, listed),
+  });
+}

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

@@ -1,4 +1,4 @@
-// ⋯ → About OAR: the menu entry's label and the modal (about-view.mjs builds
+// ︙ → About OAR: the menu entry's label and the modal (about-view.mjs builds
 // its HTML from GET /api/about).
 
 import {

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

@@ -256,6 +256,23 @@ function backupsRow(backups, formatDateTime) {
   return row('Backups', esc(value), { hint });
 }
 
+/**
+ * The running workers and how many still run the code before the last deploy
+ * (the relay recycles those once idle): "14, all on this build", "14, 3 on an
+ * older build", or the bare count when the relay cannot tell. Empty when no
+ * worker runs, so the row is left out.
+ */
+export function workersBuildText(workers) {
+  const total = finite(workers?.total) || 0;
+  if (total <= 0) return '';
+  const count = formatCount(total);
+  // Number(null) is 0: an unknown count must not read as "all on this build".
+  const other = workers?.onOtherBuild === null || workers?.onOtherBuild === undefined ? null : finite(workers.onOtherBuild);
+  if (other === null) return count;
+  if (other <= 0) return total === 1 ? `${count}, on this build` : `${count}, all on this build`;
+  return `${count}, ${formatCount(other)} on an older build`;
+}
+
 /**
  * @param {object} about the GET /api/about payload
  * @param {object} [options]
@@ -270,8 +287,10 @@ export function buildAboutModalHtml(about = {}, {
 
   const commit = String(about.commit || '').trim();
   const install = about.installMethod === 'git-checkout' ? 'git checkout' : (about.installMethod === 'npm-global' ? 'npm package' : '');
+  const workersText = workersBuildText(about.workers);
   sections.push(section('build', 'OAR', table([
     row('Version', esc(about.version || '–'), install ? { hint: install } : {}),
+    ...(workersText ? [row('Workers', esc(workersText))] : []),
     ...(commit ? [row('Commit', `<code>${esc(commit.slice(0, 7))}</code>`, { title: commit })] : []),
     row('Started', esc(about.startedAt ? formatDateTime(about.startedAt) : '–')),
     row('Uptime', esc(formatUptime(about.uptimeSeconds))),

package/server/public/app/action-confirmations.js

@@ -107,7 +107,7 @@ export async function confirmKillCurrentSession() {
   }
 }
 
-// ⋯ → Restart web relay first shows what the restart would wait for and
+// ︙ → Restart web relay first shows what the restart would wait for and
 // leave running (relay-restart-ui.js); its buttons land in
 // confirmRestartWebRelay below or in confirmRestartRelayNow.
 export { openRestartRelayConfirmation };

package/server/public/app/api-client.js

@@ -982,7 +982,9 @@ export async function loadConversation(id, options = {}) {
   const aroundMessageId = String(options.aroundMessageId || '').trim();
   if (aroundMessageId) params.set('aroundMessageId', aroundMessageId);
   const query = params.toString();
-  return apiFetch(`/api/conversation/${convId}${query ? `?${query}` : ''}`);
+  // `onErrorResponse` tells a conversation the relay does not know (404) from a failed load.
+  const onErrorResponse = typeof options.onErrorResponse === 'function' ? options.onErrorResponse : undefined;
+  return apiFetch(`/api/conversation/${convId}${query ? `?${query}` : ''}`, onErrorResponse ? { onErrorResponse } : undefined);
 }
 
 export async function refreshConversationHistory(id, options = {}) {
@@ -1247,7 +1249,7 @@ export async function createConversationShareLink(id) {
   });
 }
 
-// Share management (Settings → Shared conversations, the ⋯ menu). These throw
+// Share management (Settings → Shared conversations, the ︙ menu). These throw
 // with the relay's reason, so the caller can say why an action failed.
 export async function listConversationShares() {
   return apiFetchOrThrow('/api/shares');

package/server/public/app/ask-user-view.js

@@ -17,6 +17,7 @@ import { questionCardHeadLabel } from './conversation-provider-indicator.mjs';
 import { questionAcceptsFreeText } from './question-answer-rule.mjs';
 import { beginOwnSend, followsTranscriptEnd, refreshJumpButton, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
 import { renderSessionAskCards } from './inbox-ui.js';
+import { isConversationAutoOpenHeld } from './session-history-ui.js';
 
 let relayQuestionRenderHash = '';
 let renderedRelayQuestionIds = new Set();
@@ -124,13 +125,20 @@ export async function loadRelayQuestions(conversationId) {
   window.renderConvList?.();
   window.syncComposerButtonState?.();
 
-  if (!conversationId && pending.length) {
+  // Nothing open: the latest question's conversation opens. Not from the
+  // Inbox or Status, which show nothing open too: they are being read. And
+  // in place of the empty screen, not as a step of its own in history. Nor
+  // after a link the relay did not know: its notice keeps the screen empty
+  // until the reader opens something.
+  const readingAView = document.body?.classList?.contains('inbox-view-active')
+    || document.body?.classList?.contains('status-view-active');
+  if (!conversationId && pending.length && !readingAView && !isConversationAutoOpenHeld()) {
     const latest = pending
       .slice()
       .sort((a, b) => new Date(b.createdAt || 0) - new Date(a.createdAt || 0))[0];
     const targetConversationId = String(latest?.conversationId || '').trim();
     if (targetConversationId && targetConversationId !== currentConvId && conversations[targetConversationId]) {
-      await window.openConversation?.(targetConversationId);
+      await window.openConversation?.(targetConversationId, { history: 'replace' });
       return;
     }
   }
@@ -171,10 +179,16 @@ export function updatePendingQuestionBanner() {
   banner.dataset.targetQuestionId = String(latest?.id || '').trim();
   const count = pending.length;
   const currentCount = currentConvId ? pending.filter((q) => q?.conversationId === currentConvId).length : 0;
-  const convTitle = escHtml(conversations[targetConversationId]?.title || targetConversationId || 'conversation');
-  banner.innerHTML = currentCount > 0
-    ? `❓ ${count} open question${count === 1 ? '' : 's'}`
-    : `❓ ${count} open question${count === 1 ? '' : 's'} · latest in ${convTitle}`;
+  const rawTitle = String(conversations[targetConversationId]?.title || targetConversationId || 'conversation');
+  const countText = `❓ ${count} open question${count === 1 ? '' : 's'}`;
+  const tailText = currentCount > 0 ? '' : ` · latest in ${rawTitle}`;
+  // The full text, and the compact chip "❓ N" the header fit switches to
+  // (data-compact) where the row is short. Either way the button's name and
+  // tooltip are the full text.
+  banner.innerHTML = `<span class="pending-question-full"><span class="pending-question-count">${escHtml(countText)}</span>${tailText ? `<span class="pending-question-tail">${escHtml(tailText)}</span>` : ''}</span>`
+    + `<span class="pending-question-compact" aria-hidden="true">❓ ${count}</span>`;
+  banner.title = `${countText}${tailText}`;
+  banner.setAttribute('aria-label', `${countText}${tailText}`);
   banner.classList.add('visible');
   banner.disabled = false;
 }

package/server/public/app/attachments-view.js

@@ -277,7 +277,7 @@ export function renderAttachmentPreview() {
     const annotatable = att.isImage && att.previewUrl && isAnnotatableImageType(att.type);
     const thumb = att.isImage && att.previewUrl
       ? `<img src="${escHtml(att.previewUrl)}" alt="${escHtml(att.name)}"${annotatable ? ` onclick="openAnnotateEditorForPending(${idx})" title="Annotate ${escHtml(att.name)}" style="cursor: pointer;"` : ''}>`
-      : `<div class="attachment-preview-meta" style="height:88px;display:flex;align-items:center;justify-content:center">📎</div>`;
+      : `<div class="attachment-preview-meta" style="height:calc(88px * var(--ui-scale));display:flex;align-items:center;justify-content:center">📎</div>`;
     const annotateBadge = annotatable
       ? `<span class="attachment-preview-annotate" aria-hidden="true">🖍️</span>`
       : '';

package/server/public/app/back-guard.mjs

@@ -9,7 +9,26 @@
 
 export const BACK_GUARD_FLOOR = 'oarBackGuardFloor';
 export const BACK_GUARD_APP = 'oarApp';
-const FIRST_INTERACTION_EVENTS = ['pointerdown', 'keydown', 'touchstart'];
+// Every entry the app writes carries its place in the stack, so a pop tells
+// back from forward (session-history.mjs, viewer-history.mjs).
+export const HISTORY_POSITION = 'oarPos';
+// The visit's base (the floor, the phone's session list) is laid: a reload
+// on any later entry must not lay it again.
+export const VISIT_LAID = 'oarLaid';
+// The place in the stack of the visit's lowest own entry (the phone's list,
+// else the first session): back from above it stays in the app.
+export const VISIT_BASE = 'oarBase';
+export const FIRST_INTERACTION_EVENTS = Object.freeze(['pointerdown', 'keydown', 'touchstart']);
+
+/** The marks every later entry of the visit carries over from the one below. */
+export function inheritedVisitMarks(state) {
+  const marks = {};
+  if (!state || typeof state !== 'object') return marks;
+  if (state[BACK_GUARD_APP]) marks[BACK_GUARD_APP] = true;
+  if (state[VISIT_LAID]) marks[VISIT_LAID] = state[VISIT_LAID];
+  if (Number.isFinite(state[VISIT_BASE])) marks[VISIT_BASE] = state[VISIT_BASE];
+  return marks;
+}
 
 /**
  * Lay the floor at the first touch or key, not at start-up: an entry a page
@@ -19,13 +38,13 @@ const FIRST_INTERACTION_EVENTS = ['pointerdown', 'keydown', 'touchstart'];
  * interaction nothing a page does keeps back from leaving; from then on
  * the floor holds.
  */
-export function armBackGuardOnFirstInteraction({ history, enabled = true, target, onFloor = null } = {}) {
+export function armBackGuardOnFirstInteraction({ history, enabled = true, target, onFloor = null, entryAgain = null } = {}) {
   if (!enabled || !history || !target) return null;
   const state = { guard: null };
   const arm = () => {
     for (const eventName of FIRST_INTERACTION_EVENTS) target.removeEventListener(eventName, arm, true);
     if (state.guard) return;
-    state.guard = installBackGuard({ history, enabled: true, onFloor });
+    state.guard = installBackGuard({ history, enabled: true, onFloor, entryAgain });
     target.addEventListener('popstate', () => state.guard.onPopState());
   };
   for (const eventName of FIRST_INTERACTION_EVENTS) target.addEventListener(eventName, arm, true);
@@ -38,8 +57,12 @@ export function armBackGuardOnFirstInteraction({ history, enabled = true, target
  * lets the next back leave unless the user touches the app in between:
  * one swallowed press, then the app closes — the pattern phones use, and
  * the moment to say "press back again to close".
+ *
+ * `entryAgain` names the entry pushed back above the floor: `{ state, url }`
+ * (the session list on a phone, else the session on screen). Without it a
+ * bare app entry goes back up.
  */
-export function installBackGuard({ history, enabled = true, onFloor = null } = {}) {
+export function installBackGuard({ history, enabled = true, onFloor = null, entryAgain = null } = {}) {
   if (!enabled || !history) return null;
   const current = history.state && typeof history.state === 'object' ? history.state : {};
   // After a reload on the app's entry the floor already lies beneath it.
@@ -51,7 +74,10 @@ export function installBackGuard({ history, enabled = true, onFloor = null } = {
     /** Feed every popstate here. */
     onPopState() {
       if (!history.state?.[BACK_GUARD_FLOOR]) return;
-      history.pushState({ [BACK_GUARD_APP]: true }, '');
+      const again = typeof entryAgain === 'function' ? entryAgain() : null;
+      if (again?.state && again.url) history.pushState({ ...again.state, [BACK_GUARD_APP]: true }, '', again.url);
+      else if (again?.state) history.pushState({ ...again.state, [BACK_GUARD_APP]: true }, '');
+      else history.pushState({ [BACK_GUARD_APP]: true }, '');
       onFloor?.();
     },
   };