@oar-sh/oar 0.9.12 → 0.9.14

package/server/services/package-data-rescue-preinstall.mjs

@@ -0,0 +1,22 @@
+/**
+ * The `preinstall` of @oar-sh/oar. Nothing of OAR loads before the `try`:
+ * a module of this package that cannot load (a broken file, a missing one)
+ * must not fail the install on any platform. Only a copy of an old
+ * database that failed (RescueCopyError) exits 1, so npm stops the update
+ * and puts the old package, data and all, back in place; anything else is
+ * one line and exit 0, as this script only ever copies. See
+ * package-data-rescue.mjs.
+ */
+import { fileURLToPath } from 'node:url';
+
+try {
+  const { rescuePackageData } = await import('./package-data-rescue.mjs');
+  rescuePackageData({ packageRoot: fileURLToPath(new URL('../..', import.meta.url)) });
+} catch (error) {
+  if (error?.rescueCopyFailed === true) {
+    console.error(`[oar] ${error.message}`);
+    process.exitCode = 1;
+  } else {
+    console.error(`[oar] Did not copy the data of the version being replaced: ${error?.message || error}`);
+  }
+}

package/server/services/package-data-rescue.mjs

@@ -0,0 +1,137 @@
+/**
+ * The preinstall's work (package-data-rescue-preinstall.mjs), on every
+ * platform. Relays before 0.9.14 could run on the database and uploads
+ * inside the package (Windows autostart, a plain `gh copilot`), and
+ * `npm i -g` deletes the old package. While install scripts run, npm keeps
+ * it as its retired folder (npmRetiredPath; a scan for npm-shaped names only
+ * when that is missing): its database (-wal, -shm), Cursor stores, uploads
+ * and config.json are copied, copy only, to
+ * `<data folder>/rescued-package-data/<time>/` (written as `.partial`, then
+ * renamed), and the relay takes them over at its next start. Any of them
+ * makes the old package a source (its uploads beyond the README.md and
+ * image_input.md it ships). Nothing to copy, or not an installed package:
+ * nothing happens, nothing is printed. A failed copy throws
+ * RescueCopyError: exit 1, npm puts the old package back. npm hides a successful script's output, hence the README.txt.
+ */
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+
+import { RESCUE_DIR_NAME, copyMissing, isRetiredName } from './earlier-database-service.mjs';
+import { resolveRelayStateDirs, resolveStateLayout } from './oar-state-layout.mjs';
+
+const DB_FILES = ['copilot.db', 'copilot.db-wal', 'copilot.db-shm'];
+
+// What a relay left in a package's server folder; a folder that cannot be
+// read throws (no copy failure: nothing was detected yet).
+function hasRelayData(fsImpl, serverDir) {
+  const has = (...parts) => fsImpl.existsSync(path.join(serverDir, ...parts));
+  const anyUpload = (...parts) => has(...parts) && fsImpl.readdirSync(path.join(serverDir, ...parts)).some((name) => /^[a-f0-9]{64}$/.test(name));
+  return has('data', 'copilot.db') || has('data', 'cursor-agents') || has('config.json') || anyUpload('uploads') || anyUpload('data', 'uploads');
+}
+
+/** Where npm's reify moves a package it replaces (@npmcli/arborist retire-path.js). */
+export function npmRetiredPath(packageDir) {
+  const hash = crypto.createHash('sha1').update(packageDir).digest('base64').replace(/[^a-zA-Z0-9]+/g, '').slice(0, 8);
+  return path.resolve(path.dirname(packageDir), `.${path.basename(packageDir)}-${hash}`);
+}
+
+/** A copy of an old database failed: the one error that stops the install. */
+export class RescueCopyError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = 'RescueCopyError';
+    this.rescueCopyFailed = true;
+  }
+}
+
+/**
+ * Returns { status: 'not-installed' | 'nothing' | 'rescued', rescued: [{ from,
+ * to }] }; throws a RescueCopyError, naming what to save, when a copy fails.
+ */
+export function rescuePackageData({
+  packageRoot,
+  env = process.env,
+  platform = process.platform,
+  now = () => new Date(),
+  fsImpl = fs,
+  logger = console,
+} = {}) {
+  const resolvedRoot = path.resolve(String(packageRoot || ''));
+  const scope = path.dirname(resolvedRoot);
+  if (path.basename(scope) !== '@oar-sh' || path.basename(path.dirname(scope)) !== 'node_modules') {
+    return { status: 'not-installed', rescued: [] };
+  }
+  // Detection: npm's retired name, else a scan for npm-shaped names (a path
+  // in another case hashes differently). Failing here is no copy failure.
+  let sources;
+  try {
+    const exact = npmRetiredPath(resolvedRoot);
+    const retired = fsImpl.existsSync(exact)
+      ? [exact]
+      : fsImpl.readdirSync(scope).filter((name) => isRetiredName(name, path.basename(resolvedRoot))).map((name) => path.join(scope, name));
+    sources = retired.filter((dir) => hasRelayData(fsImpl, path.join(dir, 'server')));
+  } catch (error) {
+    throw new Error(`Could not look for the data of the version being replaced: ${error?.message || error}`, { cause: error });
+  }
+  if (!sources.length) return { status: 'nothing', rescued: [] };
+
+  // Old data is there: any failure from here stops the install.
+  const exists = (file) => fsImpl.existsSync(file);
+  const kept = path.join(resolvedRoot, 'server');
+  const copyFailed = (from, to, error) => new RescueCopyError(
+    `Could not copy the data of the version being replaced (${from}) to ${to}: ${error?.message || error}. `
+    + `The update stops and the version installed stays as it is; copy ${path.join(kept, 'data')} and ${path.join(kept, 'uploads')} somewhere safe by hand, then update again.`,
+    { cause: error },
+  );
+  let rescueRoot;
+  try {
+    const layout = resolveStateLayout({ packageRoot: resolvedRoot, env, platform });
+    rescueRoot = path.join(resolveRelayStateDirs({ packageRoot: resolvedRoot, env, platform, layout }).dataDir, RESCUE_DIR_NAME);
+  } catch (error) {
+    throw copyFailed(path.join(sources[0], 'server'), 'the OAR data folder', error);
+  }
+  const stamp = now().toISOString().replace(/[:.]/g, '-');
+  const rescued = [];
+  for (const [index, source] of sources.entries()) {
+    const serverDir = path.join(source, 'server');
+    let target = path.join(rescueRoot, sources.length > 1 ? `${stamp}-${index}` : stamp);
+    // Written under a .partial name and renamed when complete: a half copy
+    // is never taken for a rescue.
+    try {
+      for (let n = 1; exists(target) || exists(`${target}.partial`); n += 1) target = `${path.join(rescueRoot, stamp)}-${n}`;
+      const partial = `${target}.partial`;
+      fsImpl.mkdirSync(rescueRoot, { recursive: true });
+      fsImpl.mkdirSync(partial);
+      fsImpl.mkdirSync(path.join(partial, 'data'));
+      for (const name of DB_FILES) {
+        const from = path.join(serverDir, 'data', name);
+        if (exists(from)) fsImpl.copyFileSync(from, path.join(partial, 'data', name), fs.constants.COPYFILE_EXCL);
+      }
+      if (exists(path.join(serverDir, 'data', 'cursor-agents'))) {
+        copyMissing(fsImpl, path.join(serverDir, 'data', 'cursor-agents'), path.join(partial, 'data', 'cursor-agents'));
+      }
+      // Uploads of server/uploads and server/data/uploads, content-addressed.
+      for (const uploads of [path.join(serverDir, 'uploads'), path.join(serverDir, 'data', 'uploads')]) {
+        if (exists(uploads)) copyMissing(fsImpl, uploads, path.join(partial, 'uploads'));
+      }
+      if (exists(path.join(serverDir, 'config.json'))) {
+        fsImpl.copyFileSync(path.join(serverDir, 'config.json'), path.join(partial, 'config.json'), fs.constants.COPYFILE_EXCL);
+      }
+      fsImpl.writeFileSync(path.join(partial, 'README.txt'), [
+        `Copied by the @oar-sh/oar update on ${now().toISOString()} from`,
+        `${serverDir}`,
+        'before npm deleted the version it replaced. The relay takes the',
+        'database in data\\ over at its next start if it is newer than the',
+        'one it has. Nothing here is deleted by OAR.',
+        '',
+      ].join('\r\n'));
+      fsImpl.renameSync(partial, target);
+    } catch (error) {
+      throw copyFailed(serverDir, target, error);
+    }
+    rescued.push({ from: serverDir, to: target });
+    logger.log?.(`[oar] Copied the data of the version being replaced from ${serverDir} to ${target}; the relay takes it over at its next start.`);
+  }
+  return { status: 'rescued', rescued };
+}

package/server/services/preview-proxy-server.mjs

@@ -261,6 +261,10 @@ export function createPreviewProxyServer({
   // open HMR connection would therefore hang shutdown forever unless the lane
   // tracks the pairs itself.
   const upgradedSockets = new Set();
+  // Upgrades still waiting on the dev server's answer, by their teardown: the
+  // client socket is detached from the http.Server already, so it would hold
+  // close() open just the same.
+  const pendingUpgrades = new Set();
 
   function trackUpgradedSocket(socket) {
     if (!socket) return;
@@ -411,14 +415,20 @@ export function createPreviewProxyServer({
     let upstreamReq = null;
     let upstreamSocket = null;
     const teardown = () => {
+      pendingUpgrades.delete(teardown);
       try { socket.destroy(); } catch {}
       try { upstreamSocket?.destroy(); } catch {}
       try { upstreamReq?.destroy(); } catch {}
     };
+    pendingUpgrades.add(teardown);
     socket.on('error', teardown);
     // A client that leaves before the dev server answers abandons the
     // handshake. Once both sides are piped, an orderly close travels through
-    // the pipes, so the pending writes still reach the other side.
+    // the pipes, so the pending writes still reach the other side. Leaving
+    // can arrive as a bare FIN: the server's sockets allow half-open
+    // connections, so 'end' alone never closes this one, and nothing reads
+    // it again to notice a reset that follows the FIN.
+    socket.once('end', teardown);
     socket.once('close', teardown);
     const reply = (text) => {
       if (socket.destroyed) return;
@@ -477,7 +487,9 @@ export function createPreviewProxyServer({
       reply(`${lines.join('\r\n')}\r\n\r\n`);
       if (upstreamHead?.length) reply(upstreamHead);
       if (head?.length) upstreamSocket.write(head);
+      socket.removeListener('end', teardown);
       socket.removeListener('close', teardown);
+      pendingUpgrades.delete(teardown);
       trackUpgradedSocket(socket);
       trackUpgradedSocket(upstreamSocket);
       upstreamSocket.pipe(socket);
@@ -527,6 +539,7 @@ export function createPreviewProxyServer({
       try { socket.destroy(); } catch {}
     }
     upgradedSockets.clear();
+    for (const teardown of [...pendingUpgrades]) teardown();
     return new Promise((resolve) => {
       if (!server) return resolve();
       const current = server;

package/server/services/preview-registry-service.mjs

@@ -687,8 +687,9 @@ export function createPreviewRegistry({
       ok: false,
       status: 429,
       error: `Too many live previews (max ${settings.maxLive}); previews stay until closed. `
-        + `Oldest: ${oldest.join('; ')}. Close ${toClose === 1 ? 'one' : toClose} in Settings → Previews, with the preview tool's `
-        + `close action (list shows the tokens), or with DELETE /api/previews/:token.`,
+        + `Oldest: ${oldest.join('; ')}. Close ${toClose === 1 ? 'one' : toClose} in Settings → Previews; an agent can close `
+        + `its own conversation's with the preview tool's close action (list shows their tokens) or with `
+        + `DELETE /api/previews/:token?conversationId=<conv>.`,
     };
   }
 

package/server/services/process-list-service.mjs

@@ -67,10 +67,11 @@ export function createProcessLister({
   readdirSyncImpl = fs.readdirSync,
   readFileSyncImpl = fs.readFileSync,
   execFileImpl = execFile,
+  systemToolPath,
   inspector = null,
 } = {}) {
   if (platform === 'win32') {
-    const windows = inspector || createSessionWorkerProcessInspector({ platform, execFileImpl });
+    const windows = inspector || createSessionWorkerProcessInspector({ platform, execFileImpl, systemToolPath });
     return {
       // A child keeps the pid of its parent after the parent has ended.
       orphansKeepParent: true,

package/server/services/provider-model-selection.mjs

@@ -89,3 +89,198 @@ export function resolveProviderModelSelection({
     availableModels: Array.from(index.values()),
   };
 }
+
+// ─── Checking a model an agent names (remote_relay create_session / send) ───
+
+const PROVIDER_LABELS = Object.freeze({
+  github: 'Copilot',
+  openai: 'OpenAI',
+  claude: 'Claude',
+  cursor: 'Cursor',
+  grok: 'Grok',
+  'claude-cloud': 'Claude Cloud',
+});
+const CLAUDE_PROVIDERS = new Set(['claude', 'claude-cloud']);
+const LONG_CONTEXT_SUFFIX = /\[1m\]$/i;
+// A Copilot model with its effort, as the composer sends it ("gpt-5.4-high").
+const EFFORT_VARIANT_SUFFIX = /-(none|minimal|low|medium|high|xhigh|max)$/i;
+// A Claude alias ("opus", "sonnet[1m]"): one word, no version.
+const CLAUDE_ALIAS = /^([a-z]+)(\[1m\])?$/i;
+const SUGGESTIONS_MAX = 3;
+
+/** How a relay calls a provider in its messages. */
+export function providerModelLabel(provider) {
+  return PROVIDER_LABELS[String(provider || '').trim().toLowerCase()] || String(provider || '').trim() || 'this provider';
+}
+
+/** Lower case, no tier suffix, letters and digits only: "GPT-5.4" and "gpt-5-4" meet as "gpt54". */
+function looseModelKey(value) {
+  return normalizeProviderModelId(value).toLowerCase().replace(LONG_CONTEXT_SUFFIX, '').replace(/[^a-z0-9]+/g, '');
+}
+
+function editDistance(a, b) {
+  if (a === b) return 0;
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j += 1) {
+      current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    previous = current;
+  }
+  return previous[b.length];
+}
+
+/**
+ * The ids of `availableModels` closest to `requestedModel`, best first, at
+ * most `max`: the same id written with other separators or casing, then ids
+ * a few edits away, then ids that contain what was asked for.
+ */
+export function suggestProviderModelIds(requestedModel, availableModels = [], { max = SUGGESTIONS_MAX } = {}) {
+  const requested = normalizeProviderModelId(requestedModel).toLowerCase().replace(LONG_CONTEXT_SUFFIX, '');
+  const loose = looseModelKey(requestedModel);
+  if (!requested || !loose) return [];
+  const scored = [];
+  for (const candidate of buildCanonicalModelIndex(availableModels).values()) {
+    const plain = candidate.toLowerCase().replace(LONG_CONTEXT_SUFFIX, '');
+    const candidateLoose = looseModelKey(candidate);
+    let score = null;
+    if (candidateLoose === loose) score = 0;
+    else {
+      // A few edits for a real id, none for a stub ("x" is no typo of "o3").
+      const allowed = requested.length >= 4 ? Math.max(1, Math.floor(requested.length / 4)) : 0;
+      const distance = allowed ? editDistance(requested, plain) : Infinity;
+      if (distance <= allowed) score = 1 + distance;
+      else if (loose.length >= 3 && candidateLoose.includes(loose)) score = 100 + candidateLoose.length - loose.length;
+    }
+    if (score !== null) scored.push({ candidate, score });
+  }
+  return scored
+    .sort((a, b) => a.score - b.score || a.candidate.localeCompare(b.candidate))
+    .slice(0, Math.max(0, max))
+    .map((entry) => entry.candidate);
+}
+
+const DATE_SUFFIX = /-\d{8}$/;
+
+/** "claude-opus-4-1-20250805" → { version: [4, 1], dated: true }. */
+function claudeVersionOf(model, prefix) {
+  const rest = model.toLowerCase().slice(prefix.length);
+  const dated = DATE_SUFFIX.test(rest);
+  const version = rest.replace(DATE_SUFFIX, '').split(/[^0-9]+/).filter(Boolean).map(Number);
+  return { version, dated };
+}
+
+function compareVersionsDescending(a, b) {
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    const difference = (b[index] ?? -1) - (a[index] ?? -1);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+/**
+ * The newest listed Claude model of an alias's family ("opus" →
+ * "claude-opus-5-5" over "claude-opus-5" and "claude-opus-4-1-20250805"):
+ * by version number, a date suffix ignored, the undated id before a dated
+ * one of the same version. "[1m]" ids are not the family's; with `longContext`
+ * the chosen model's "[1m]" id is taken when it is listed. Returns
+ * `{ model, tierDropped }`, or null for a family with no listed model.
+ */
+function resolveClaudeAlias(word, index, longContext) {
+  const prefix = `claude-${word.toLowerCase()}-`;
+  const members = (tiered) => [...index.values()]
+    .filter((model) => LONG_CONTEXT_SUFFIX.test(model) === tiered && model.toLowerCase().startsWith(prefix))
+    .map((model) => ({ model, ...claudeVersionOf(model.replace(LONG_CONTEXT_SUFFIX, ''), prefix) }))
+    .filter((entry) => entry.version.length);
+  let family = members(false);
+  // A list that holds the family only as "[1m]" ids: those are its models.
+  if (!family.length) {
+    family = members(true);
+    if (!family.length) return null;
+    family.sort((a, b) => compareVersionsDescending(a.version, b.version) || Number(a.dated) - Number(b.dated) || a.model.localeCompare(b.model));
+    return { model: family[0].model, tierDropped: false };
+  }
+  family.sort((a, b) => compareVersionsDescending(a.version, b.version) || Number(a.dated) - Number(b.dated) || a.model.localeCompare(b.model));
+  const chosen = family[0].model;
+  if (!longContext) return { model: chosen, tierDropped: false };
+  const tiered = index.get(`${chosen}[1m]`.toLowerCase());
+  return tiered ? { model: tiered, tierDropped: false } : { model: chosen, tierDropped: true };
+}
+
+/**
+ * Whether a provider offers the model an agent asked for, by the list New
+ * Chat offers for it. `models` is that list, or null when it is not known
+ * (discovery has not run, the relay did not answer). Returns one of:
+ *
+ * - `{ status: 'known', model }`: offered; `model` is the provider's own
+ *   casing, the same Claude model without its "[1m]" tier when only the
+ *   base is listed (`tierDropped`), or "auto". A Copilot model with its
+ *   effort ("gpt-5.4-high") also has `base` (the listed id) and `effort`:
+ *   the bootstrap knows base ids only, so callers pass them apart. Taken so
+ *   only when `effortsFor(base)` (the efforts the catalogue lists for it)
+ *   holds that effort; else the id is unknown, with the base suggested.
+ * - `{ status: 'alias', model, tierDropped }`: a Claude alias ("opus",
+ *   "sonnet[1m]"), taken as the newest listed model of its family.
+ * - `{ status: 'unchecked', model }`: no list to check against; the request
+ *   goes on as asked.
+ * - `{ status: 'unknown', model, suggestions, models }`: not offered.
+ */
+export function checkRequestedProviderModel({ requestedModel = '', provider = '', models = null, defaultModel = '', effortsFor = null } = {}) {
+  const requested = normalizeProviderModelId(requestedModel);
+  if (!requested || isAutoModelId(requested)) return { status: 'known', model: requested };
+  if (!Array.isArray(models)) return { status: 'unchecked', model: requested };
+  // "auto" is listed before discovery has run too: it makes no list.
+  const list = [...buildCanonicalModelIndex([defaultModel, ...models]).values()].filter((model) => !isAutoModelId(model));
+  if (!list.length) return { status: 'unchecked', model: requested };
+  const index = buildCanonicalModelIndex(list);
+  const exact = index.get(requested.toLowerCase());
+  if (exact) return { status: 'known', model: exact };
+  const claude = CLAUDE_PROVIDERS.has(String(provider || '').trim().toLowerCase());
+  if (claude && LONG_CONTEXT_SUFFIX.test(requested)) {
+    const base = index.get(requested.replace(LONG_CONTEXT_SUFFIX, '').toLowerCase());
+    if (base) return { status: 'known', model: base, tierDropped: true };
+  }
+  if (claude) {
+    const alias = CLAUDE_ALIAS.exec(requested);
+    const resolved = alias ? resolveClaudeAlias(alias[1], index, !!alias[2]) : null;
+    if (resolved) return { status: 'alias', ...resolved };
+  }
+  const variant = EFFORT_VARIANT_SUFFIX.exec(requested);
+  const base = variant ? requested.slice(0, variant.index) : '';
+  // Only Copilot takes a model with its effort in the id, and only an effort
+  // the listed model is known to take: "gpt-5.1-codex-max" is a model of its
+  // own, not gpt-5.1-codex at effort max.
+  const listedBase = base && String(provider || '').trim().toLowerCase() === 'github' ? index.get(base.toLowerCase()) : '';
+  const effort = variant ? variant[1].toLowerCase() : '';
+  if (listedBase) {
+    const efforts = typeof effortsFor === 'function' ? effortsFor(listedBase) : null;
+    if (Array.isArray(efforts) && efforts.map((value) => String(value || '').trim().toLowerCase()).includes(effort)) {
+      return { status: 'known', model: `${listedBase}-${effort}`, base: listedBase, effort };
+    }
+  }
+  const suggestions = suggestProviderModelIds(requested, list);
+  const baseFirst = listedBase ? [listedBase, ...suggestions.filter((model) => model !== listedBase)] : suggestions;
+  return {
+    status: 'unknown',
+    model: requested,
+    suggestions: (baseFirst.length || !base ? baseFirst : suggestProviderModelIds(base, list)).slice(0, SUGGESTIONS_MAX),
+    models: list,
+  };
+}
+
+const MODELS_LISTED_MAX = 20;
+
+/** The refusal of an unknown model: "Unknown model 'gpt-5-4' for Copilot; did you mean 'gpt-5.4'? …". */
+export function unknownProviderModelText({ model, provider, suggestions = [], models = [], where = '' } = {}) {
+  const label = providerModelLabel(provider);
+  const quoted = (value) => `'${value}'`;
+  const parts = [`Unknown model ${quoted(model)} for ${label}${where ? ` ${where}` : ''}`];
+  if (suggestions.length) parts.push(`; did you mean ${suggestions.map(quoted).join(' or ')}?`);
+  else parts.push('.');
+  const shown = models.slice(0, MODELS_LISTED_MAX);
+  if (shown.length) {
+    parts.push(` Valid ids: ${shown.join(', ')}${models.length > shown.length ? ` (and ${models.length - shown.length} more)` : ''}.`);
+  }
+  return parts.join('');
+}

package/server/services/push-dispatch-service.mjs

@@ -1,5 +1,7 @@
 'use strict';
 
+import { providerDisplayName } from '../public/app/conversation-provider-indicator.mjs';
+
 /**
  * Web Push dispatch: decides whether a push should go out at all (suppressed
  * while any device is actively foregrounded), renders the notification per
@@ -10,7 +12,7 @@
  * reports outcomes through the status-events store instead.
  */
 
-export const PUSH_EVENT_TYPES = Object.freeze(['question', 'turnComplete', 'turnFailed', 'board', 'cliOffline', 'hostSuspend']);
+export const PUSH_EVENT_TYPES = Object.freeze(['question', 'turnComplete', 'turnFailed', 'board', 'cliOffline', 'hostSuspend', 'relayRestart']);
 
 export const VAPID_PUBLIC_KEY_SETTING = 'push_vapid_public_key';
 export const VAPID_PRIVATE_KEY_SETTING = 'push_vapid_private_key';
@@ -29,17 +31,25 @@ const FAILURE_PRUNE_THRESHOLD = 8;
 const PUSH_TTL_SECONDS = 12 * 60 * 60;
 
 const EVENT_LABELS = Object.freeze({
-  question: { title: 'Copilot needs your input', generic: 'The agent asked a question.' },
+  // A question's title names the provider that asks (questionTitle).
+  question: { title: 'An agent needs your input', generic: 'The agent asked a question.' },
   turnComplete: { title: 'Turn completed', generic: 'The agent finished its turn.' },
   turnFailed: { title: 'Turn failed', generic: 'The agent turn failed.' },
   board: { title: 'Plan ready for review', generic: 'The agent posted a board for review.' },
   cliOffline: { title: 'CLI offline', generic: 'The relay lost its connection to the CLI host.' },
   hostSuspend: { title: 'Host suspend', generic: 'The queued host suspend changed state.' },
+  relayRestart: { title: 'Relay restart waiting', generic: 'The queued relay restart has waited its maximum time.' },
 });
 
+function eventTitle(type, providerName) {
+  const name = String(providerName || '').trim();
+  if (type === 'question' && name) return `${name} needs your input`;
+  return EVENT_LABELS[type].title;
+}
+
 // System events carry their own body: no conversation text to preview, and
 // the body is the message itself regardless of the preview preference.
-const SYSTEM_BODY_TYPES = new Set(['hostSuspend']);
+const SYSTEM_BODY_TYPES = new Set(['hostSuspend', 'relayRestart']);
 
 function clampInt(value, min, max, fallback) {
   const numeric = Number(value);
@@ -78,7 +88,7 @@ export function normalizePushPreferences(raw) {
  * Render the notification payload for one subscription. Pure so every content
  * preference combination is unit-testable.
  *
- * @param {{ type: string, conversationTitle?: string|null, body?: string|null, data?: object }} event
+ * @param {{ type: string, conversationTitle?: string|null, providerName?: string|null, body?: string|null, data?: object }} event
  * @param {object} preferences canonical shape from normalizePushPreferences
  */
 export function renderPushNotification(event, preferences) {
@@ -86,10 +96,11 @@ export function renderPushNotification(event, preferences) {
   const prefs = normalizePushPreferences(preferences);
   const labels = EVENT_LABELS[type];
 
-  let title = labels.title;
+  const baseTitle = eventTitle(type, event?.providerName);
+  let title = baseTitle;
   const conversationTitle = String(event?.conversationTitle || '').trim();
   if (prefs.content.includeTitle && conversationTitle) {
-    title = `${labels.title} — ${conversationTitle}`.slice(0, MAX_TITLE_CHARS);
+    title = `${baseTitle} — ${conversationTitle}`.slice(0, MAX_TITLE_CHARS);
   }
 
   let body = labels.generic;
@@ -115,7 +126,7 @@ export function renderPushNotification(event, preferences) {
   return {
     title,
     body,
-    tag: `copilot-${type}-${tagSeed}`,
+    tag: `oar-${type}-${tagSeed}`,
     timestamp: Date.now(),
     data,
   };
@@ -340,6 +351,21 @@ export function createPushDispatchService({
     }
   }
 
+  // The provider of a question's conversation, for the push title. Prepared
+  // lazily: a schema without runtime sessions just means "not known".
+  let providerTypeStatement = null;
+  function conversationProviderName(conversationId) {
+    const id = String(conversationId || '').trim();
+    if (!id) return null;
+    try {
+      providerTypeStatement ??= db.prepare(`SELECT provider_type FROM runtime_sessions WHERE conversation_id = ?`);
+      // Named as the question card's head names it; unknown stays neutral.
+      return providerDisplayName(providerTypeStatement.get(id)?.provider_type) || null;
+    } catch {
+      return null;
+    }
+  }
+
   async function sendToSubscription(row, event) {
     const preferences = normalizePushPreferences(parseJsonObject(row.preferences_json));
     const payload = renderPushNotification(event, preferences);
@@ -383,7 +409,7 @@ export function createPushDispatchService({
    * Fire-and-forget push for one event. Never throws; suppression failures
    * fail closed (no push when the active-device state is unknown).
    */
-  async function dispatch({ type, conversationId = null, body = null, data = {} }) {
+  async function dispatch({ type, conversationId = null, body = null, data = {}, providerName = null }) {
     try {
       if (!PUSH_EVENT_TYPES.includes(type)) return { outcome: 'invalid-type' };
 
@@ -409,6 +435,7 @@ export function createPushDispatchService({
       const event = {
         type,
         conversationTitle: conversationTitle(conversationId),
+        providerName,
         body,
         data: { ...data, conversationId: conversationId || undefined },
       };
@@ -444,6 +471,7 @@ export function createPushDispatchService({
     return dispatch({
       type: 'question',
       conversationId: question?.conversationId || null,
+      providerName: conversationProviderName(question?.conversationId),
       body: question?.prompt || null,
       data: {
         questionId: question?.id || undefined,
@@ -493,8 +521,14 @@ export function createPushDispatchService({
     return dispatch({ type: 'hostSuspend', body: body || null, data: { hostSuspendAt: Date.now() } });
   }
 
+  // The queued restart's maximum wait ran out: it asks, it does not restart.
+  function notifyRelayRestart({ body = null } = {}) {
+    return dispatch({ type: 'relayRestart', body: body || null, data: { relayRestartAt: Date.now() } });
+  }
+
   return {
     notifyHostSuspend,
+    notifyRelayRestart,
     listDevices,
     getDevice,
     upsertSubscription,