@oar-sh/oar 0.9.20 → 0.9.22

package/server/services/about-service.mjs

@@ -3,6 +3,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { normalizeBuildId, readGitCommit, resolveBuildCommit } from '../../shared/build-id.mjs';
+import { isWorkerOnOtherBuild } from './worker-recycle-service.mjs';
+
+// The commit readers moved to shared/ so the workers can state their build id
+// too; they are re-exported here so the routes and tests importing them keep
+// their import.
+export { readGitCommit, resolveBuildCommit };
+
 // What the About OAR modal shows: the running build, the providers that are
 // on, what this relay has stored over its life, and how it is doing now.
 //
@@ -64,58 +72,6 @@ function readFileText(fsImpl, filePath) {
   }
 }
 
-const COMMIT_PATTERN = /^[0-9a-f]{40}$/i;
-
-/**
- * The commit a git checkout has checked out, read from its .git files rather
- * than from a `git` process: HEAD, then the loose ref, then packed-refs. A
- * linked worktree's .git is a file naming its git dir, whose refs live in the
- * common dir. Anything unexpected reads as null. `pathImpl` is the host's path
- * module; tests pass path.posix and path.win32.
- */
-export function readGitCommit(root, { fsImpl = fs, pathImpl = path } = {}) {
-  if (!root) return null;
-  const dotGit = pathImpl.join(root, '.git');
-  let gitDir = dotGit;
-  const pointer = readFileText(fsImpl, dotGit);
-  if (pointer !== null) {
-    const match = pointer.match(/^gitdir:\s*(.+)$/m);
-    if (!match) return null;
-    gitDir = pathImpl.resolve(root, match[1].trim());
-  }
-  const head = readFileText(fsImpl, pathImpl.join(gitDir, 'HEAD'));
-  if (head === null) return null;
-  const headText = head.trim();
-  if (COMMIT_PATTERN.test(headText)) return headText.toLowerCase();
-  const refMatch = headText.match(/^ref:\s*(\S+)$/);
-  if (!refMatch) return null;
-  const ref = refMatch[1];
-  const commonDirText = readFileText(fsImpl, pathImpl.join(gitDir, 'commondir'));
-  const commonDir = commonDirText ? pathImpl.resolve(gitDir, commonDirText.trim()) : gitDir;
-  for (const dir of new Set([gitDir, commonDir])) {
-    const loose = readFileText(fsImpl, pathImpl.join(dir, ...ref.split('/')));
-    if (loose && COMMIT_PATTERN.test(loose.trim())) return loose.trim().toLowerCase();
-  }
-  const packed = readFileText(fsImpl, pathImpl.join(commonDir, 'packed-refs')) || '';
-  for (const line of packed.split(/\r?\n/)) {
-    const [hash, name] = line.trim().split(/\s+/);
-    if (name === ref && COMMIT_PATTERN.test(hash || '')) return hash.toLowerCase();
-  }
-  return null;
-}
-
-/** The commit this build came from: the checkout's HEAD, else a `gitHead` stamp in package.json. */
-export function resolveBuildCommit(packageRoot, { fsImpl = fs, pathImpl = path } = {}) {
-  const fromGit = readGitCommit(packageRoot, { fsImpl, pathImpl });
-  if (fromGit) return fromGit;
-  try {
-    const stamp = String(JSON.parse(readFileText(fsImpl, pathImpl.join(packageRoot, 'package.json')) || '{}')?.gitHead || '').trim();
-    return COMMIT_PATTERN.test(stamp) ? stamp.toLowerCase() : null;
-  } catch {
-    return null;
-  }
-}
-
 export function readInstalledPackageVersion(packageRoot, packageName, { fsImpl = fs } = {}) {
   if (!packageRoot || !packageName) return null;
   try {
@@ -338,6 +294,7 @@ async function fileSize(fsImpl, filePath) {
  * @param {string|null} [deps.dbPath] the database file; its -wal file is counted too
  * @param {string} deps.version
  * @param {string|null} [deps.commit]
+ * @param {string|null} [deps.buildId] the relay's build id (shared/build-id.mjs), to tell the workers on other code
  * @param {string} [deps.installMethod]
  * @param {string} deps.startedAt ISO time this relay process started
  * @param {() => object} [deps.getProviderSettings] `{ github: { enabled, engine }, claude: { enabled }, … }`
@@ -354,6 +311,7 @@ export function createAboutService({
   describeBackups = null,
   version = '0.0.0',
   commit = null,
+  buildId = null,
   installMethod = null,
   startedAt,
   packageRoot = null,
@@ -397,20 +355,30 @@ export function createAboutService({
     return totalsInFlight;
   }
 
+  // The running workers, by provider and by build: after a deploy the
+  // workers keep the code they started with until the recycle replaces them,
+  // and About shows how many still do. A relay that does not know its own
+  // build id cannot tell, so both build counts are null then.
   function runningWorkersByProvider() {
     const counts = new Map();
     let total = 0;
+    const relayBuildId = normalizeBuildId(buildId);
+    let onOtherBuild = 0;
     for (const worker of listWorkers() || []) {
       const status = String(worker?.status || '').trim().toLowerCase();
       if (!ACTIVE_WORKER_STATUSES.has(status) || !isPidAlive(worker?.pid)) continue;
       total += 1;
+      if (isWorkerOnOtherBuild(worker, relayBuildId)) onOtherBuild += 1;
       const conversationId = String(worker?.conversationId || '').trim();
       const provider = conversationId
         ? normalizeProviderId(providerForConversation.get(conversationId)?.provider_type)
         : 'unassigned';
       counts.set(provider, (counts.get(provider) || 0) + 1);
     }
-    return { total, counts };
+    const builds = relayBuildId
+      ? { total, onThisBuild: total - onOtherBuild, onOtherBuild }
+      : { total, onThisBuild: null, onOtherBuild: null };
+    return { total, counts, builds };
   }
 
   function describeProviders(workerCounts) {
@@ -474,6 +442,7 @@ export function createAboutService({
       startedAt: startedAt || null,
       uptimeSeconds,
       providers: describeProviders(workers.counts),
+      workers: workers.builds,
       stats: {
         conversations: totals.conversations.total,
         archivedConversations: totals.conversations.archived,

package/server/services/claude-billing-swap-service.mjs

@@ -28,29 +28,16 @@
  * the fence lets them through, and the waiting state ages out.
  */
 
+import { workerReleaseHold } from './worker-replacement.mjs';
+
 export const CLAUDE_BILLING_SWAP_WAIT_TTL_MS = 15_000;
 
 /**
- * What keeps a worker from being replaced now: null when nothing does, else
- * 'turn', 'question', 'compaction' or 'background'. From the steering
- * snapshot its heartbeat sends; a worker too old to say `releasable` is read
- * from the rest of it.
+ * What keeps a worker from being replaced now (worker-replacement.mjs, which
+ * the worker recycle shares). Kept under its old name for the importers that
+ * know it by that.
  */
-export function claudeWorkerReleaseHold(worker) {
-  if (!worker) return null;
-  const steering = worker.steering || null;
-  if (steering && typeof steering.releasable === 'boolean') {
-    return steering.releasable ? null : (steering.releaseHold || 'turn');
-  }
-  if (steering) {
-    if (steering.holdReason === 'question') return 'question';
-    if (steering.holdReason === 'compaction') return 'compaction';
-    if (steering.turnActive) return 'turn';
-    if (steering.autoCompactWindow?.backgroundWork) return 'background';
-    return null;
-  }
-  return String(worker.status || '') === 'processing' ? 'turn' : null;
-}
+export const claudeWorkerReleaseHold = workerReleaseHold;
 
 export function createClaudeBillingSwapService({
   // sid → the registry's entry for the session's worker, or null.
@@ -208,7 +195,7 @@ export function createClaudeBillingSwapService({
       running = true;
       noteProbeFailure(sid, state, fence, error);
     }
-    const hold = running ? 'turn' : claudeWorkerReleaseHold(worker);
+    const hold = running ? 'turn' : workerReleaseHold(worker);
     if (hold) {
       setPending(sid, state, {
         to: fence.rowBilling,

package/server/services/claude-cloud-session-service.mjs

@@ -157,12 +157,9 @@ export function buildClaudeCloudDelivery({ conversation = null, runtimeSession =
   if (!isClaudeCloudProviderType(runtimeSession?.provider_type)) return null;
   const source = parseCloudSourceJson(conversation?.cloud_source_json);
   if (!source) return null;
-  const sessionId = toText(runtimeSession?.claude_cloud_session_id);
-  const lastSequence = toText(runtimeSession?.claude_cloud_last_sequence);
   const fallback = toText(fallbackEnvironmentId);
   return {
-    sessionId: isSafeClaudeCloudId(sessionId) ? sessionId : null,
-    lastSequence: SEQUENCE_PATTERN.test(lastSequence) ? lastSequence : null,
+    ...readStoredClaudeCloudBinding(runtimeSession),
     repoUrl: source.repoUrl,
     branch: source.branch,
     environmentId: source.environmentId || (isSafeClaudeCloudId(fallback) ? fallback : null),
@@ -170,6 +167,20 @@ export function buildClaudeCloudDelivery({ conversation = null, runtimeSession =
   };
 }
 
+/**
+ * The cloud session a runtime session row is bound to and the cursor its
+ * worker reads on from: `{ sessionId, lastSequence }`, each null when absent
+ * or not in the shape the worker may put into a request path.
+ */
+export function readStoredClaudeCloudBinding(runtimeSession = null) {
+  const sessionId = toText(runtimeSession?.claude_cloud_session_id);
+  const lastSequence = toText(runtimeSession?.claude_cloud_last_sequence);
+  return {
+    sessionId: isSafeClaudeCloudId(sessionId) ? sessionId : null,
+    lastSequence: SEQUENCE_PATTERN.test(lastSequence) ? lastSequence : null,
+  };
+}
+
 /** The larger of two sequence numbers (strings of digits), so a late report never moves the cursor back. */
 function laterSequence(stored, reported) {
   const a = SEQUENCE_PATTERN.test(toText(stored)) ? toText(stored) : null;
@@ -264,6 +275,31 @@ export function createClaudeCloudSessionService({
     return { ok: true, cloud };
   }
 
+  /**
+   * GET /api/claude-cloud-session: the binding a starting worker attaches to
+   * before any delivery (so it follows the turns the session starts by
+   * itself, as the worker it replaces did). `id` is the conversation id or
+   * the runtime session's sdk session id, which is all a worker knows of its
+   * conversation. A known conversation that has no cloud session (none yet,
+   * or another provider) answers `sessionId: null`; only an unknown id is
+   * 404. Returns `{ ok, statusCode, error }` or `{ ok: true, sessionId,
+   * lastSequence }`.
+   */
+  function describeStoredBinding(id = '') {
+    const key = toText(id);
+    if (!key) return { ok: false, statusCode: 400, error: 'Missing conversationId' };
+    const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(key)
+      || stmts.getRuntimeSessionBySdkSessionId?.get?.(key)
+      || null;
+    if (!runtimeSession && !stmts.getConvAnyStatus?.get?.(key)) {
+      return { ok: false, statusCode: 404, error: 'Conversation not found' };
+    }
+    if (!runtimeSession || !isClaudeCloudProviderType(runtimeSession.provider_type)) {
+      return { ok: true, sessionId: null, lastSequence: null };
+    }
+    return { ok: true, ...readStoredClaudeCloudBinding(runtimeSession) };
+  }
+
   /**
    * Archives the cloud session of a conversation that is being deleted or
    * archived here. Best effort: it returns at once (true when an archive was
@@ -322,5 +358,11 @@ export function createClaudeCloudSessionService({
     return true;
   }
 
-  return { cloudPayloadFor, recordWorkerReport, archiveSessionInBackground, unarchiveSessionInBackground };
+  return {
+    cloudPayloadFor,
+    recordWorkerReport,
+    describeStoredBinding,
+    archiveSessionInBackground,
+    unarchiveSessionInBackground,
+  };
 }

package/server/services/cloudflared-tunnel-service.mjs

@@ -211,6 +211,9 @@ export function createCloudflaredTunnelManager({
   io = null,
   logger = console,
   runtimeShutdownRef = () => false,
+  // The tunnel stopped blocking queue delivery (it connected): the relay
+  // hands out what waited for it.
+  onBlockingLifted = () => {},
   platform = process.platform,
   spawnImpl = spawn,
   nowIso = () => new Date().toISOString(),
@@ -267,7 +270,11 @@ export function createCloudflaredTunnelManager({
   };
 
   const updateBlockingState = () => {
+    const wasBlocking = state.blocking;
     state.blocking = state.required && state.mode === 'managed' && !state.connected;
+    if (wasBlocking && !state.blocking) {
+      try { onBlockingLifted(); } catch {}
+    }
   };
 
   const scheduleReconnect = (spawnTunnel, { slowest = false } = {}) => {

package/server/services/idle-timers.mjs

@@ -0,0 +1,184 @@
+'use strict';
+
+// Timers a relay keeps only while there is something to time: the CLI
+// presence deadline and the intervals armed by work and disarmed by their own
+// tick. An idle relay runs neither.
+
+// ─── CLI presence ──────────────────────────────────────────────────────────────
+
+// Whether "the CLI" (the relay's workers) has been heard from recently, kept
+// without a polling timer. Every touch moves the last-seen time; one one-shot
+// deadline timer, armed only while something was seen, notices when the
+// window ran out. A deadline that fires early (a touch moved last-seen) arms
+// again for the remainder, so an online relay wakes about once per window and
+// an offline one not at all.
+//
+// The window depends on the worker sockets: an idle worker beats only every
+// 30 s (shared/worker-runtime/worker-keepalive.mjs), so while a worker socket
+// is open the window is wide enough for one lost beat. With no socket left a
+// relay whose workers are all gone still reads offline within the short
+// window, as before.
+
+export const CLI_ONLINE_WINDOW_MS = 10_000;
+export const CLI_ONLINE_WINDOW_WITH_WORKER_SOCKETS_MS = 45_000;
+
+export function createCliPresence({
+  windowMs = CLI_ONLINE_WINDOW_MS,
+  socketWindowMs = CLI_ONLINE_WINDOW_WITH_WORKER_SOCKETS_MS,
+  // Called once when the window ran out after a touch (the deadline timer, or
+  // the last worker socket closing). The presence is cleared before the call.
+  onExpired = () => {},
+  now = () => Date.now(),
+  setTimeoutImpl = setTimeout,
+  clearTimeoutImpl = clearTimeout,
+} = {}) {
+  let lastSeenMs = null;
+  let workerSocketCount = 0;
+  let deadlineTimer = null;
+
+  function currentWindowMs() {
+    return workerSocketCount > 0 ? socketWindowMs : windowMs;
+  }
+
+  function remainingMs() {
+    if (lastSeenMs === null) return 0;
+    return lastSeenMs + currentWindowMs() - now();
+  }
+
+  function disarm() {
+    if (!deadlineTimer) return;
+    clearTimeoutImpl(deadlineTimer);
+    deadlineTimer = null;
+  }
+
+  function arm(delayMs) {
+    disarm();
+    deadlineTimer = setTimeoutImpl(onDeadline, Math.max(1, delayMs));
+    deadlineTimer?.unref?.();
+  }
+
+  function expire() {
+    disarm();
+    lastSeenMs = null;
+    try { onExpired(); } catch {}
+  }
+
+  function onDeadline() {
+    deadlineTimer = null;
+    if (lastSeenMs === null) return;
+    const left = remainingMs();
+    if (left > 0) {
+      arm(left);
+      return;
+    }
+    expire();
+  }
+
+  function touch() {
+    lastSeenMs = now();
+    // An armed deadline is left alone: when it fires it finds the newer
+    // touch and arms again for what is left.
+    if (!deadlineTimer) arm(currentWindowMs());
+  }
+
+  /** The worker socket count changed: the window may have shrunk. */
+  function noteWorkerSocketCount(count) {
+    workerSocketCount = Math.max(0, Number(count) || 0);
+    if (lastSeenMs === null) return;
+    const left = remainingMs();
+    if (left <= 0) {
+      expire();
+      return;
+    }
+    arm(left);
+  }
+
+  /** Forget the last touch without calling onExpired (an explicit offline). */
+  function clear() {
+    disarm();
+    lastSeenMs = null;
+  }
+
+  function isFresh() {
+    return remainingMs() > 0;
+  }
+
+  return {
+    touch,
+    clear,
+    isFresh,
+    noteWorkerSocketCount,
+    status: () => ({
+      lastSeenMs,
+      workerSocketCount,
+      windowMs: currentWindowMs(),
+      armed: deadlineTimer !== null,
+    }),
+  };
+}
+
+// ─── Armable interval ──────────────────────────────────────────────────────────
+
+// An interval that runs only while there is something for it to do: armed by
+// whoever creates that work (a share viewer arriving, a pending row waiting
+// for its worker), disarmed by its own tick once the work is gone. An idle
+// relay then has no such timer at all. The timer is unref'd, and stop() (the
+// runtime's shutdown) disarms it for good.
+
+export function createArmableInterval({
+  intervalMs,
+  // One tick. Returns (or resolves to) `false` to disarm: nothing is left to
+  // do. Anything else keeps the interval running. An arm that lands while a
+  // tick is still running (the tick awaits) keeps the interval running even
+  // if that tick returns false: the work it was armed for may be newer than
+  // what the tick looked at.
+  tick,
+  onError = () => {},
+  setIntervalImpl = setInterval,
+  clearIntervalImpl = clearInterval,
+} = {}) {
+  if (typeof tick !== 'function') throw new Error('createArmableInterval requires tick');
+  const periodMs = Math.max(1, Number(intervalMs) || 1);
+  let timer = null;
+  let stopped = false;
+  let generation = 0;
+
+  function disarm() {
+    if (!timer) return;
+    clearIntervalImpl(timer);
+    timer = null;
+  }
+
+  async function runTick() {
+    const armedAt = generation;
+    let keep;
+    try {
+      keep = await tick();
+    } catch (error) {
+      try { onError(error); } catch {}
+      return;
+    }
+    if (keep === false && generation === armedAt) disarm();
+  }
+
+  function arm() {
+    if (stopped) return false;
+    generation += 1;
+    if (timer) return false;
+    timer = setIntervalImpl(() => { void runTick(); }, periodMs);
+    timer?.unref?.();
+    return true;
+  }
+
+  function stop() {
+    stopped = true;
+    disarm();
+  }
+
+  return {
+    arm,
+    disarm,
+    stop,
+    isArmed: () => timer !== null,
+  };
+}

package/server/services/queue-wake-hook.mjs

@@ -0,0 +1,145 @@
+'use strict';
+
+// Wakes the relay's queue delivery from the database itself. Every write
+// that can make a queue row deliverable (a new pending row, a requeue, a
+// retry time or owner or provider changed, a turn ending, a pending row
+// cancelled or deleted) fires a TEMP trigger on this connection, which calls
+// a JS function that only notes the reason and schedules one wake for after
+// the current tick, so after the write's transaction. The function never
+// touches the database and never throws.
+//
+// No row path has to remember to wake the queue, and none added later can
+// forget: without it, a path that wrote a row and did not wake waited for
+// the next poll. The triggers are TEMP (this connection only, nothing in the
+// schema or the migrations). Their conditions name only the columns the
+// queue table has, a self-test compiles every trigger inside a rolled-back
+// savepoint, and on any error the triggers are dropped again and the caller
+// falls back to polling: a broken trigger would fail every write to the
+// queue.
+
+export const QUEUE_WAKE_FUNCTION = 'oar_queue_wake';
+const TRIGGER_PREFIX = 'oar_queue_wake_';
+const TRIGGER_NAMES = ['insert', 'pending', 'settle', 'leave_pending', 'delete'].map((name) => `${TRIGGER_PREFIX}${name}`);
+// A bulk statement calls the function once per row: the reasons of one tick
+// are kept as a small set.
+const MAX_REASONS = 8;
+
+function queueColumns(db) {
+  return new Set(db.prepare('PRAGMA table_info(queue)').all().map((column) => String(column.name)));
+}
+
+/** The CREATE TEMP TRIGGER statements, their conditions built from the columns there are. */
+export function buildQueueWakeTriggerSql(columns) {
+  const has = (name) => columns.has(name);
+  if (!has('status')) throw new Error('queue has no status column');
+  const changed = ["OLD.status IS NOT 'pending'"];
+  for (const column of ['next_attempt_at', 'owner_sdk_session_id', 'provider']) {
+    if (has(column)) changed.push(`OLD.${column} IS NOT NEW.${column}`);
+  }
+  const call = (reason) => `BEGIN SELECT ${QUEUE_WAKE_FUNCTION}('${reason}'); END`;
+  return [
+    // A new pending row.
+    `CREATE TEMP TRIGGER ${TRIGGER_PREFIX}insert AFTER INSERT ON main.queue
+      WHEN NEW.status = 'pending' ${call('insert')}`,
+    // A row that became pending, or a pending row whose retry time, owner or
+    // provider changed (a requeue, a hold released, a row moved to another
+    // worker). A claim leaves pending and a lease refresh stays processing:
+    // neither wakes.
+    `CREATE TEMP TRIGGER ${TRIGGER_PREFIX}pending AFTER UPDATE ON main.queue
+      WHEN NEW.status = 'pending' AND (${changed.join(' OR ')}) ${call('requeue')}`,
+    // A turn ended: its session's next row, or one held behind it by the plan
+    // boundary, may go now.
+    `CREATE TEMP TRIGGER ${TRIGGER_PREFIX}settle AFTER UPDATE ON main.queue
+      WHEN OLD.status = 'processing' AND NEW.status IS NOT 'processing' ${call('settle')}`,
+    // A pending row cancelled, failed or parked: a row held behind it may go.
+    `CREATE TEMP TRIGGER ${TRIGGER_PREFIX}leave_pending AFTER UPDATE ON main.queue
+      WHEN OLD.status = 'pending' AND NEW.status NOT IN ('pending', 'processing') ${call('cancel')}`,
+    // A pending or running row deleted (the cancel routes): the same.
+    `CREATE TEMP TRIGGER ${TRIGGER_PREFIX}delete AFTER DELETE ON main.queue
+      WHEN OLD.status IN ('pending', 'processing') ${call('delete')}`,
+  ];
+}
+
+function dropTriggers(db) {
+  for (const name of TRIGGER_NAMES) {
+    try { db.exec(`DROP TRIGGER IF EXISTS temp.${name}`); } catch {}
+  }
+}
+
+/**
+ * Compiles every trigger by preparing a write of each kind, and runs one real
+ * update, inside a savepoint that is rolled back: a condition naming a column
+ * the table lacks fails here instead of on the first real write.
+ */
+function selfTestTriggers(db) {
+  db.exec('SAVEPOINT oar_queue_wake_self_test');
+  try {
+    db.prepare('UPDATE queue SET status = status WHERE rowid = (SELECT rowid FROM queue LIMIT 1)').run();
+    db.prepare('UPDATE queue SET status = status WHERE 0').run();
+    db.prepare('DELETE FROM queue WHERE 0').run();
+    db.prepare('INSERT INTO queue SELECT * FROM queue WHERE 0').run();
+  } finally {
+    db.exec('ROLLBACK TO oar_queue_wake_self_test');
+    db.exec('RELEASE oar_queue_wake_self_test');
+  }
+}
+
+/**
+ * Installs the triggers on `db`. `onWake(reason)` runs once per tick in which
+ * queue writes fired them, with the reasons joined. Returns `{ installed }`;
+ * when false the triggers are gone again and the caller must poll.
+ */
+export function installQueueWakeHook(db, {
+  onWake = () => {},
+  log = () => {},
+  schedule = setImmediate,
+  selfTest = selfTestTriggers,
+} = {}) {
+  const reasons = new Set();
+  let scheduled = false;
+  let muted = false;
+
+  function flush() {
+    scheduled = false;
+    const reason = [...reasons].join(',') || 'queue-write';
+    reasons.clear();
+    try {
+      onWake(reason);
+    } catch (error) {
+      log(`queue wake failed: ${error?.message || error}`);
+    }
+  }
+
+  // Called by SQLite from inside a write: no database access, no throw.
+  function wakeFromTrigger(reason) {
+    try {
+      if (muted) return null;
+      if (reasons.size < MAX_REASONS) reasons.add(String(reason || 'queue-write'));
+      if (!scheduled) {
+        scheduled = true;
+        schedule(flush);
+      }
+    } catch {}
+    return null;
+  }
+
+  try {
+    const sql = buildQueueWakeTriggerSql(queueColumns(db));
+    // The function first: a trigger calling a function that does not exist
+    // yet would fail the write.
+    db.function(QUEUE_WAKE_FUNCTION, { deterministic: false }, wakeFromTrigger);
+    dropTriggers(db);
+    for (const statement of sql) db.exec(statement);
+    muted = true;
+    try {
+      selfTest(db);
+    } finally {
+      muted = false;
+    }
+    return { installed: true, triggers: [...TRIGGER_NAMES] };
+  } catch (error) {
+    dropTriggers(db);
+    log(`queue wake triggers not installed, the queue is polled instead: ${error?.message || error}`);
+    return { installed: false, error };
+  }
+}