@oar-sh/oar 0.9.20 → 0.9.22

package/server/claude-worker/claude-session-process.mjs

@@ -18,6 +18,7 @@ import { createClaudeSessionRootResolver } from '../services/claude-session-root
 import {
   startClaudeSession,
   createCanUseTool,
+  isPersonOnlyAsk,
   readContextUsage,
   readPlanUsage,
   normalizeClaudeEffort,
@@ -2354,9 +2355,10 @@ export function createClaudeSessionRunner({
     // nothing else is left: the cap exists to bound a retry storm's chatter,
     // while a structured entry carries transcript geometry no later line can
     // restore (a compaction boundary buffered between turns, then 50 task
-    // notifications, used to lose its break row silently). The client's
-    // capRelayActivityEntries protects structured rows too, but head-caps the
-    // prose it keeps; here the newest lines are the informative ones.
+    // notifications, used to lose its break row silently). The relay's
+    // capRelayActivityEntries protects structured rows too and keeps the
+    // newest prose of each thread; here too the newest lines are the
+    // informative ones.
     while (proc.pendingActivities.length > MAX_PENDING_ACTIVITIES) {
       const proseIndex = proc.pendingActivities.findIndex((carried) => typeof carried === 'string');
       proc.pendingActivities.splice(proseIndex === -1 ? 0 : proseIndex, 1);
@@ -3806,8 +3808,9 @@ export function createClaudeSessionRunner({
         // denied. Register a continuation turn first: it is born processing,
         // gives the card a real queue row, and the flow's eventual top-level
         // result (or stream end) closes it like any other continuation.
+        // A person-only safety ask is a question card too.
         if (
-          toolName === 'AskUserQuestion'
+          (toolName === 'AskUserQuestion' || isPersonOnlyAsk(options))
           && proc === processRef
           && !processRef.activeCtx
           && !processRef.pendingDelivered.length
@@ -4250,11 +4253,17 @@ export function createClaudeSessionRunner({
     // `releasable`: the relay may replace this worker now (a billing swap):
     // no CLI process and no delivery on its way in, or a process
     // canReleaseForRespawn would let go of.
+    // `cliAlive`: the CLI child is still up. The relay's recycle replaces a
+    // stale worker only once it is releasable AND its CLI is gone; a
+    // releasable worker whose CLI is up sits in the idle window, where a
+    // scheduled job may still wake it, and is left to its own idle-out. A
+    // closing process is not gone yet, so it still counts as alive.
     if (!proc || proc.closing || proc.aborted) {
       const admitting = admittingDeliveries > 0;
       return {
         turnActive: false, canSteer: false, holdReason: null, messageId: null, supported: true, autoCompactWindow: null,
         releasable: !admitting, releaseHold: admitting ? 'turn' : null, backgroundTaskCount: 0,
+        cliAlive: Boolean(proc),
       };
     }
     const ctx = proc.activeCtx || null;
@@ -4293,6 +4302,7 @@ export function createClaudeSessionRunner({
       releasable: !hold,
       releaseHold: hold || null,
       backgroundTaskCount: proc.liveTasks.size,
+      cliAlive: true,
     };
   }
 
@@ -4575,6 +4585,8 @@ export function createClaudeSessionRunner({
     backgroundTaskIds,
     resyncBackgroundTasks,
     flushKeptTaskSettles,
+    // Settle notices still kept for the relay: the keepalive stays busy.
+    keptTaskSettleCount: () => keptTaskSettles.size(),
     shutdown,
     // Test seams / observability.
     _getProcess: () => proc,

package/server/claude-worker/claude-session-worker-main.mjs

@@ -14,6 +14,8 @@ 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 { createWorkerKeepalive } from '../../shared/worker-runtime/worker-keepalive.mjs';
+import { resolveBuildId } from '../../shared/build-id.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { resolveDeliveredAutoCompactWindow } from '../../shared/auto-compact-window.mjs';
 import { resolveDeliveredThinking } from '../../shared/claude-thinking.mjs';
@@ -59,6 +61,10 @@ export async function runClaudeSessionWorker({
 
   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();
@@ -143,6 +149,7 @@ export async function runClaudeSessionWorker({
   let heartbeatTimer = null;
   heartbeat = createHeartbeatController({
     api,
+    buildId,
     // What this worker runs on: the relay hands it only rows of that billing.
     workerKind: turnRunner.workerKind,
     pollMs: HEARTBEAT_MS,
@@ -168,10 +175,16 @@ export async function runClaudeSessionWorker({
     getBackgroundTaskIds: () => turnRunner.backgroundTaskIds(),
     onResyncBackgroundTasks: () => turnRunner.resyncBackgroundTasks(),
     onAnswered: () => turnRunner.flushKeptTaskSettles(),
+    getKeptPostCount: () => turnRunner.keptTaskSettleCount?.() || 0,
   });
 
+  // One timer for the heartbeat and the socket's readiness refresh: 10 s
+  // while working, 30 s while idle on a relay that allows it.
+  let keepalive = null;
   const wsLink = createWorkerWebSocketLink({
     serverUrl,
+    readyRefreshMs: 0,
+    onRelayFrame: () => keepalive?.nudge(),
     token,
     dbg,
     getSessionReady: () => true,
@@ -191,6 +204,7 @@ export async function runClaudeSessionWorker({
     getSessionId: () => sdkSessionId,
     getPid: () => process.pid,
     workerKind: turnRunner.workerKind,
+    buildId,
     onDeliver: async (pending, reason) => {
       dbg('queue.deliver received', `reason=${reason}`, `msgId=${pending?.message?.id || 'none'}`);
       const deliveredTimeout = Number(pending?.settings?.backgroundTaskTimeoutMs);
@@ -232,6 +246,7 @@ export async function runClaudeSessionWorker({
       dbg('unknown worker control ignored', type || '(none)');
     },
   });
+  keepalive = createWorkerKeepalive({ heartbeat, link: wsLink, busyMs: HEARTBEAT_MS });
   linkBridge.attach(wsLink);
 
   let shuttingDown = false;
@@ -240,6 +255,7 @@ export async function runClaudeSessionWorker({
     shuttingDown = true;
     dbg(`shutting down (${signal})`);
     try { wsLink.stop(); } catch {}
+    try { keepalive.stop(); } catch {}
     try { heartbeat.stopHeartbeat(); } catch {}
     try { controlPoller.stop(); } catch {}
     // Consumed steers still settling must fail, not be left for dead-worker
@@ -263,7 +279,7 @@ export async function runClaudeSessionWorker({
     onBeforeExit: () => { try { turnRunner.shutdown({ graceful: false }); } catch {} },
   });
 
-  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}${backend ? ` backend=${backend.id}` : ''}`);
-  heartbeat.startHeartbeat();
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}${backend ? ` backend=${backend.id}` : ''} build=${buildId || 'unknown'}`);
+  keepalive.start();
   wsLink.start();
 }

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -709,6 +709,12 @@ export function createCopilotSdkSessionRunner({
   // card), so they hold the stall watchdog and the idle shutdown too — but
   // not steering: nobody is answering a card here.
   let pendingRelayToolCalls = 0;
+  // Deliveries `handlePendingPayload` is still working on. Most become (or
+  // steer into) `activeTurn` at once, but a steer that waits on the turn's
+  // send, its row or the relay context can find the turn gone and open its
+  // own afterwards: in that gap no turn exists, and the worker must still
+  // not read as replaceable (`releaseHold`).
+  let admittingDeliveries = 0;
   // `relay_tool` is registered only while this relay has paired remotes.
   // Asked once when the worker starts; a session build waits for that first
   // answer (it is async anyway), and every runtime stop asks again so the
@@ -4739,7 +4745,62 @@ export function createCopilotSdkSessionRunner({
     const canSteer = canAcceptSteering();
     const holdReason = turnActive && !canSteer ? steeringHoldReason(turn) : null;
     const messageId = String(turn?.currentOwner?.message?.id || turn?.message?.id || '').trim() || null;
-    return { turnActive, canSteer, holdReason, messageId, supported: true, cancellableIds: cancellableIds() };
+    // `releasable`: the relay may stop this worker and launch a fresh one now
+    // (its recycle after a deploy), the same fields the Claude worker sends.
+    const hold = releaseHold();
+    return {
+      turnActive,
+      canSteer,
+      holdReason,
+      messageId,
+      supported: true,
+      cancellableIds: cancellableIds(),
+      releasable: !hold,
+      releaseHold: hold || null,
+      // As the task panel counts them: with the registry it is the truth, and
+      // the event-scraped shell set would count its shells a second time.
+      backgroundTaskCount: sessionRpc.tasks ? backgroundTasks.size : backgroundShells.size(),
+      // The runtime process (the CLI child) is up: a client or a session
+      // handle exists until `stopRuntime` clears both. The relay's recycle
+      // replaces a stale worker only once it is releasable AND this is false;
+      // releasable with the runtime up is the idle window, left to the idle
+      // shutdown.
+      cliAlive: Boolean(client || session),
+    };
+  }
+
+  /**
+   * What keeps this worker from being replaced now ('' when nothing does):
+   * the idle shutdown's gates (`evaluateLifecycle`) and the runtime tree's
+   * busy check, named with the relay's hold words. Stopping the worker ends
+   * the runtime, and with it the turn, the card a human is answering, a
+   * compaction, and every background shell and agent.
+   *
+   *  - 'question': a question card or an ask-mode approval is open;
+   *  - 'compaction': the runtime is compacting the session;
+   *  - 'turn': a turn is running or still publishing its rows, a `relay_tool`
+   *    call is out, an image row is on the relay's image routes, or a
+   *    delivery is on its way in;
+   *  - 'background': a background shell or agent is live, a settled shell's
+   *    continuation is due (`continuationGraceMs`), a registry read is due
+   *    or under way, or the task registry has failed to answer: in the last
+   *    two "nothing is running" is not known (`backgroundWorkHoldsRuntime`
+   *    holds the runtime on the same grounds).
+   */
+  function releaseHold() {
+    if (pendingHumanRequests > 0) return 'question';
+    if (isCompacting()) return 'compaction';
+    if (
+      activeTurn || publishingTurns.size > 0 || pendingRelayToolCalls > 0
+      || directImageMessages.size > 0 || admittingDeliveries > 0
+    ) return 'turn';
+    if (backgroundShells.size() > 0 || backgroundTasks.size > 0) return 'background';
+    if (continuationDueSince && Date.now() - continuationDueSince < continuationGraceMs) return 'background';
+    // A read of the registry that is debounced, queued or on its way may
+    // still find a live agent or shell the last answer did not have.
+    if (sessionRpc.tasks && (taskRefreshTimer || taskRefreshQueued > 0 || taskRefreshInFlight)) return 'background';
+    if (sessionRpc.tasks && taskRefreshFailures > 0 && taskRefreshFailures < MAX_TASK_REFRESH_FAILURES) return 'background';
+    return '';
   }
 
   /**
@@ -4883,6 +4944,18 @@ export function createCopilotSdkSessionRunner({
   }
 
   async function handlePendingPayload(pending) {
+    // A payload without a message is refused at once, as it always was: it
+    // admits nothing.
+    if (!pending?.message) return false;
+    admittingDeliveries += 1;
+    try {
+      return await admitPendingPayload(pending);
+    } finally {
+      admittingDeliveries -= 1;
+    }
+  }
+
+  async function admitPendingPayload(pending) {
     const message = pending?.message || null;
     if (!message) return false;
     // An image model is no chat model: its row goes to the relay's image
@@ -5060,6 +5133,7 @@ export function createCopilotSdkSessionRunner({
     resyncBackgroundTasks,
     // The relay answered a heartbeat: settle notices kept for it go out.
     flushKeptTaskSettles: () => keptTaskSettles.flush(),
+    keptTaskSettleCount: () => keptTaskSettles.size(),
     cancelPushedMessage,
     // The task panel's per-card Stop (`rpc.tasks.cancel`); also what a
     // subagent lane's Stop tries — the runtime tracks sync agents in the same

package/server/copilot-worker/copilot-sdk-session-worker.mjs

@@ -20,6 +20,8 @@ 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 { createWorkerKeepalive } from '../../shared/worker-runtime/worker-keepalive.mjs';
+import { resolveBuildId } from '../../shared/build-id.mjs';
 import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import {
   createRunnerLinkBridge,
@@ -52,6 +54,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;
   // Two reads of the same small file. Collapsing them to one would mean
   // re-implementing `resolveRelayServerUrl`'s env override, host
   // normalisation and port defaulting inside this worker — a live contract
@@ -129,6 +135,7 @@ async function main() {
   let heartbeatTimer = null;
   heartbeat = createHeartbeatController({
     api,
+    buildId,
     pollMs: HEARTBEAT_MS,
     getSessionReady: () => true,
     getHeartbeatTimer: () => heartbeatTimer,
@@ -152,12 +159,19 @@ async function main() {
     onResyncBackgroundTasks: () => turnRunner.resyncBackgroundTasks(),
     // The relay answered: settle notices it missed go out.
     onAnswered: () => turnRunner.flushKeptTaskSettles?.(),
+    getKeptPostCount: () => turnRunner.keptTaskSettleCount?.() || 0,
   });
 
+  // One timer for the heartbeat and the socket's readiness refresh: 10 s
+  // while working, 30 s while idle on a relay that allows it.
+  let keepalive = null;
   const wsLink = createWorkerWebSocketLink({
     serverUrl,
+    readyRefreshMs: 0,
+    onRelayFrame: () => keepalive?.nudge(),
     token,
     dbg,
+    buildId,
     getSessionReady: () => true,
     getSessionId: () => sdkSessionId,
     getPid: () => process.pid,
@@ -206,11 +220,13 @@ async function main() {
       dbg('worker control ignored (unsupported by the SDK worker)', type || '(none)');
     },
   });
+  keepalive = createWorkerKeepalive({ heartbeat, link: wsLink, busyMs: HEARTBEAT_MS });
   linkBridge.attach(wsLink);
 
   const shutdown = async (signal) => {
     dbg(`shutting down (${signal})`);
     try { wsLink.stop(); } catch {}
+    try { keepalive.stop(); } catch {}
     try { heartbeat.stopHeartbeat(); } catch {}
     try { controlPoller.stop(); } catch {}
     // Rows whose prompt the runtime consumed and whose settle marker has not
@@ -238,8 +254,8 @@ async function main() {
     getActiveQueueMessageIds: () => turnRunner.getActiveQueueMessageIds(),
   });
 
-  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}`);
-  heartbeat.startHeartbeat();
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
+  keepalive.start();
   wsLink.start();
 }
 

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

@@ -13,10 +13,13 @@ 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 { createWorkerKeepalive } from '../../shared/worker-runtime/worker-keepalive.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 +51,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 +100,27 @@ 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),
   });
 
+  // One timer for the heartbeat and the socket's readiness refresh: 10 s
+  // while working, 30 s while idle on a relay that allows it.
+  let keepalive = null;
   const wsLink = createWorkerWebSocketLink({
     serverUrl,
+    readyRefreshMs: 0,
+    onRelayFrame: () => keepalive?.nudge(),
     token,
     dbg,
+    buildId,
     getSessionReady: () => true,
     getSessionId: () => sdkSessionId,
     getPid: () => process.pid,
@@ -117,10 +134,12 @@ async function main() {
       }
     },
   });
+  keepalive = createWorkerKeepalive({ heartbeat, link: wsLink, busyMs: HEARTBEAT_MS });
 
   const shutdown = async (signal) => {
     dbg(`shutting down (${signal})`);
     try { wsLink.stop(); } catch {}
+    try { keepalive.stop(); } catch {}
     try { heartbeat.stopHeartbeat(); } catch {}
     try { controlPoller.stop(); } catch {}
     // The agent handle owns a SQLite store; close it before exiting — but
@@ -146,8 +165,8 @@ async function main() {
     getActiveQueueMessageIds: () => [turnRunner.getActiveQueueAttempt()],
   });
 
-  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}`);
-  heartbeat.startHeartbeat();
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
+  keepalive.start();
   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/db-schema.mjs

@@ -42,6 +42,8 @@ import { migrateClaudeApiUsageCheckpoints } from './migrations/0033-claude-api-u
 import { migrateClaudeApiUsageTotals } from './migrations/0034-claude-api-usage-totals.mjs';
 import { migrateConversationPlanOnly } from './migrations/0035-conversation-plan-only.mjs';
 import { migrateTokenUsage } from './migrations/0036-token-usage.mjs';
+import { migrateRelayAsksQueueId } from './migrations/0037-relay-asks-queue-id.mjs';
+import { migrateTurnSeq } from './migrations/0038-turn-seq.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -1077,6 +1079,23 @@ try {
   console.warn(`[token-usage] migration 0036 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// The turn an ask was made in: one column on 0023's table. The ask service
+// works without it, so a failure is logged and retried next boot like 0023.
+try {
+  migrateRelayAsksQueueId(db);
+} catch (error) {
+  console.warn(`[relay-asks] migration 0037 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// One order across a turn's thoughts and tool lines (the stream view). The
+// repository checks for the column and works without it (no numbers, the
+// grouped layout), so a failure is logged and retried next boot.
+try {
+  migrateTurnSeq(db);
+} catch (error) {
+  console.warn(`[turn-seq] migration 0038 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const conversationColumns = db.prepare(`PRAGMA table_info(conversations)`).all().map((c) => c.name);
 if (!conversationColumns.includes('archived')) {
   db.exec(`ALTER TABLE conversations ADD COLUMN archived INTEGER NOT NULL DEFAULT 0`);

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

@@ -235,10 +235,20 @@ 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. */
     flushKeptSettles: () => keptSettles.flush(),
+    keptSettleCount: () => keptSettles.size(),
     sweep,
     close() {
       clearInterval(sweepTimer);

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

@@ -12,10 +12,13 @@ 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 { createWorkerKeepalive } from '../../shared/worker-runtime/worker-keepalive.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 +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();
@@ -96,6 +103,7 @@ async function main() {
   let heartbeatTimer = null;
   heartbeat = createHeartbeatController({
     api,
+    buildId,
     pollMs: HEARTBEAT_MS,
     getSessionReady: () => true,
     getHeartbeatTimer: () => heartbeatTimer,
@@ -106,12 +114,22 @@ async function main() {
     getBackgroundTaskIds: () => turnRunner.backgroundTaskIds(),
     onResyncBackgroundTasks: () => turnRunner.resyncBackgroundTasks(),
     onAnswered: () => turnRunner.flushKeptTaskSettles(),
+    getKeptPostCount: () => turnRunner.keptTaskSettleCount?.() || 0,
+    // 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),
   });
 
+  // One timer for the heartbeat and the socket's readiness refresh: 10 s
+  // while working, 30 s while idle on a relay that allows it.
+  let keepalive = null;
   const wsLink = createWorkerWebSocketLink({
     serverUrl,
+    readyRefreshMs: 0,
+    onRelayFrame: () => keepalive?.nudge(),
     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.
@@ -143,10 +161,12 @@ async function main() {
       dbg('unknown worker control ignored', type || '(none)');
     },
   });
+  keepalive = createWorkerKeepalive({ heartbeat, link: wsLink, busyMs: HEARTBEAT_MS });
 
   const shutdown = async (signal) => {
     dbg(`shutting down (${signal})`);
     try { wsLink.stop(); } catch {}
+    try { keepalive.stop(); } catch {}
     try { heartbeat.stopHeartbeat(); } catch {}
     try { controlPoller.stop(); } catch {}
     try { taskPublisher.close(); } catch {}
@@ -171,8 +191,8 @@ async function main() {
     getActiveQueueMessageIds: () => [turnRunner.getActiveQueueAttempt()],
   });
 
-  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}`);
-  heartbeat.startHeartbeat();
+  dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
+  keepalive.start();
   wsLink.start();
 }
 

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

@@ -667,9 +667,13 @@ 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(),
+    keptTaskSettleCount: () => terminalTasks?.keptSettleCount?.() || 0,
     setTurnCeilingMs(value) {
       const ms = Number(value);
       turnCeilingMs = Number.isFinite(ms) && ms >= 0 ? ms : null;

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/migrations/0037-relay-asks-queue-id.mjs

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Migration: the turn an ask was made in.
+ *
+ * `relay_asks.queue_id`: the queue row of the turn that was live in the
+ * asking conversation when its agent asked (services/relay-ask-service.mjs
+ * create), so the browser can show the ask in that turn's bubble. NULL for
+ * an ask made on behalf of another session, one a paired relay's agent made
+ * here, a mirror, and every ask from before this migration. No index: it is
+ * read with the row, never looked up by.
+ *
+ * Not one of RELAY_ASK_COLUMNS (0023): the ask service works without it and
+ * then stores nothing.
+ *
+ * Additive and idempotent. Safe to run on every boot; nothing to do while
+ * there is no relay_asks table (0023 not run yet). Rolling back needs no
+ * data change: older code ignores the column.
+ *
+ * Usage: node server/migrations/0037-relay-asks-queue-id.mjs [path/to/oar.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+import { cliDbPath } from '../services/database-file.mjs';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateRelayAsksQueueId(db) {
+  if (!tableExists(db, 'relay_asks')) return { applied: false, columnsAdded: 0 };
+  const present = new Set(db.prepare(`PRAGMA table_info(relay_asks)`).all().map((column) => column.name));
+  if (present.has('queue_id')) return { applied: false, columnsAdded: 0 };
+  db.exec(`ALTER TABLE relay_asks ADD COLUMN queue_id TEXT`);
+  return { applied: true, columnsAdded: 1 };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateRelayAsksQueueId(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  try {
+    // The given path, else the database in server/data (oar.db, else the
+    // name before 0.9.20); never a new one.
+    const dbPath = cliDbPath(process.argv[2], new URL('..', import.meta.url));
+    const result = migrate(dbPath);
+    console.log(`Migration 0037 on ${dbPath}`);
+    console.log(result.applied ? `  relay asks: columns added ${result.columnsAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0037 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}