@oar-sh/oar 0.9.21 → 0.9.23

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
@@ -4582,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,7 @@ 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';
@@ -174,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,
@@ -239,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;
@@ -247,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
@@ -271,6 +280,6 @@ export async function runClaudeSessionWorker({
   });
 
   dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'}${backend ? ` backend=${backend.id}` : ''} build=${buildId || 'unknown'}`);
-  heartbeat.startHeartbeat();
+  keepalive.start();
   wsLink.start();
 }

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

@@ -5133,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,7 @@ 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 {
@@ -158,10 +159,16 @@ 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,
@@ -213,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
@@ -246,7 +255,7 @@ async function main() {
   });
 
   dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
-  heartbeat.startHeartbeat();
+  keepalive.start();
   wsLink.start();
 }
 

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

@@ -13,6 +13,7 @@ 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';
@@ -110,8 +111,13 @@ async function main() {
     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,
@@ -128,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
@@ -158,7 +166,7 @@ async function main() {
   });
 
   dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
-  heartbeat.startHeartbeat();
+  keepalive.start();
   wsLink.start();
 }
 

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

@@ -248,6 +248,7 @@ export function createGrokTaskPublisher({
     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,6 +12,7 @@ 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';
@@ -113,13 +114,19 @@ 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,
@@ -154,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 {}
@@ -183,7 +192,7 @@ async function main() {
   });
 
   dbg(`starting session=${sdkSessionId.slice(0, 8)} server=${serverUrl} cwd=${cwd} model=${defaultModel || 'default'} build=${buildId || 'unknown'}`);
-  heartbeat.startHeartbeat();
+  keepalive.start();
   wsLink.start();
 }
 

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

@@ -673,6 +673,7 @@ export function createGrokTurnRunner({
     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/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);
+  }
+}

package/server/migrations/0038-turn-seq.mjs

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * Migration: one order across a turn's thoughts and tool lines.
+ *
+ * `relay_activity.turn_seq` and `relay_thought.turn_seq`: a number per queue
+ * message shared by both tables (repositories/question-repository.mjs
+ * nextTurnSeq), given when a row is first written, so the stream view can
+ * show a turn's thoughts and tool calls in the order they happened. NULL for
+ * every row from before this migration and for rows a session-history
+ * rebuild writes; a turn with such a row keeps the grouped layout.
+ *
+ * Indexes on (queue_message_id, turn_seq), partial (only numbered rows): the
+ * next number is a max() over them. Not unique: one counter spans two tables.
+ *
+ * Not in SCHEMA_SQL (db-schema.mjs): that block runs before the migrations,
+ * so an index on the column there would fail on every existing database.
+ *
+ * Additive and idempotent. Safe to run on every boot; a table that does not
+ * exist yet is left alone. Rolling back needs no data change: older code
+ * ignores the columns.
+ *
+ * Usage: node server/migrations/0038-turn-seq.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';
+
+export const TURN_SEQ_TABLES = Object.freeze(['relay_activity', 'relay_thought']);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function hasTurnSeqColumn(db, table) {
+  try {
+    return db.prepare(`PRAGMA table_info(${table})`).all().some((column) => column.name === 'turn_seq');
+  } catch {
+    return false;
+  }
+}
+
+export function migrateTurnSeq(db) {
+  let columnsAdded = 0;
+  let indexesAdded = 0;
+  for (const table of TURN_SEQ_TABLES) {
+    if (!tableExists(db, table)) continue;
+    if (!hasTurnSeqColumn(db, table)) {
+      db.exec(`ALTER TABLE ${table} ADD COLUMN turn_seq INTEGER`);
+      columnsAdded += 1;
+    }
+    const index = `idx_${table}_queue_turn_seq`;
+    const present = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?`).get(index);
+    if (!present) {
+      db.exec(`CREATE INDEX ${index} ON ${table}(queue_message_id, turn_seq) WHERE turn_seq IS NOT NULL`);
+      indexesAdded += 1;
+    }
+  }
+  return { applied: columnsAdded + indexesAdded > 0, columnsAdded, indexesAdded };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateTurnSeq(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 0038 on ${dbPath}`);
+    console.log(result.applied
+      ? `  turn order: columns added ${result.columnsAdded}, indexes added ${result.indexesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0038 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}