@oar-sh/oar 0.9.11 → 0.9.13

package/server/services/conversation-history-page.mjs

@@ -0,0 +1,199 @@
+'use strict';
+
+// One page of a conversation's history, selected in SQL.
+//
+// The history route used to load every message, hydrate every reply and only
+// then cut the page out (selectConversationHistoryPage in sessions-routes.mjs),
+// so each page and each live poll paid for the whole conversation. This module
+// selects the page's rows in SQL with the same cursor rules and the same
+// pageInfo, so only the page is hydrated.
+//
+// The JS order is (timestamp in ms, then id by localeCompare). SQL orders by
+// (timestamp text, id text). The two agree when every timestamp has the fixed
+// ISO shape the relay writes (YYYY-MM-DDTHH:MM:SS.mmmZ) and every id is made
+// of lowercase letters, digits and dashes (the relay's UUIDs). A conversation
+// with any other row is not paged here: the selector returns null and the
+// caller keeps the in-memory path, which handles every shape.
+
+const ISO_TIMESTAMP_GLOB = '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9][0-9]Z';
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const ORDERABLE_ID_PATTERN = /^[-0-9a-z]+$/;
+
+export function normalizeConversationTimestampMs(value) {
+  const text = String(value || '').trim();
+  if (!text) return 0;
+  const sqliteUtcLike = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)$/;
+  const hasExplicitTimezone = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(text);
+  let normalized = text;
+  if (!hasExplicitTimezone && sqliteUtcLike.test(text)) {
+    const [, day, time] = text.match(sqliteUtcLike) || [];
+    normalized = `${day}T${time}Z`;
+  }
+  const parsed = Date.parse(normalized);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function normalizeConversationHistoryLimit(value, fallback = 20) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.min(100, Math.max(1, Math.trunc(numeric)));
+}
+
+/**
+ * The pageInfo of a history page: `pageMessages` in conversation order, and
+ * whether the conversation has rows before the first and after the last.
+ */
+export function buildConversationHistoryPageInfo(pageMessages = [], { hasMoreOlder = false, hasMoreNewer = false } = {}) {
+  const firstMessage = pageMessages[0] || null;
+  const lastMessage = pageMessages[pageMessages.length - 1] || null;
+  return {
+    hasMore: hasMoreOlder,
+    hasMoreOlder,
+    hasMoreNewer,
+    nextCursor: firstMessage ? {
+      beforeMessageId: String(firstMessage.id || '').trim(),
+      beforeTimestamp: String(firstMessage.timestamp || '').trim() || null,
+    } : null,
+    olderCursor: firstMessage ? {
+      beforeMessageId: String(firstMessage.id || '').trim(),
+      beforeTimestamp: String(firstMessage.timestamp || '').trim() || null,
+    } : null,
+    newerCursor: lastMessage ? {
+      afterMessageId: String(lastMessage.id || '').trim(),
+      afterTimestamp: String(lastMessage.timestamp || '').trim() || null,
+    } : null,
+  };
+}
+
+/**
+ * The prepared statements for paging one conversation. `sharedOnly` pages
+ * over the rows a shared view shows (not hidden from shares).
+ */
+export function createConversationHistoryPageStatements(db) {
+  const messageColumns = new Set(db.prepare(`PRAGMA table_info(messages)`).all().map((column) => column.name));
+  const sharedFilter = messageColumns.has('hidden_from_shares') ? 'AND hidden_from_shares = 0' : '';
+  const hasResendColumns = messageColumns.has('source_message_id') && messageColumns.has('resend_of_message_id');
+  const build = (visibility) => {
+    const base = `FROM messages WHERE conversation_id = @conversationId ${visibility}`;
+    const older = `(timestamp < @timestamp OR (timestamp = @timestamp AND @id IS NOT NULL AND id < @id))`;
+    const newer = `(timestamp > @timestamp OR (timestamp = @timestamp AND @id IS NOT NULL AND id > @id))`;
+    return {
+      irregular: db.prepare(`
+        SELECT EXISTS (
+          SELECT 1 ${base}
+          AND NOT (timestamp GLOB '${ISO_TIMESTAMP_GLOB}' AND id <> '' AND id NOT GLOB '*[^-0-9a-z]*')
+        ) AS irregular
+      `),
+      findById: db.prepare(`SELECT id, timestamp ${base} AND id = @id`),
+      older: db.prepare(`SELECT * ${base} AND ${older} ORDER BY timestamp DESC, id DESC LIMIT @limit`),
+      newer: db.prepare(`SELECT * ${base} AND ${newer} ORDER BY timestamp ASC, id ASC LIMIT @limit`),
+      fromInclusive: db.prepare(`
+        SELECT * ${base} AND (timestamp > @timestamp OR (timestamp = @timestamp AND id >= @id))
+        ORDER BY timestamp ASC, id ASC LIMIT @limit
+      `),
+      tail: db.prepare(`SELECT * ${base} ORDER BY timestamp DESC, id DESC LIMIT @limit`),
+      existsOlder: db.prepare(`SELECT EXISTS (SELECT 1 ${base} AND ${older}) AS found`),
+      existsNewer: db.prepare(`SELECT EXISTS (SELECT 1 ${base} AND ${newer}) AS found`),
+      // What liveResendsByOriginal reads, for the whole conversation: a
+      // stopped marker on the page may have its Resend outside it.
+      resendIndex: hasResendColumns
+        ? db.prepare(`SELECT id, role, source_message_id, resend_of_message_id ${base} ORDER BY timestamp ASC`)
+        : null,
+    };
+  };
+  const all = build('');
+  const shared = build(sharedFilter);
+  return {
+    selectConversationHistoryPage(conversationId, options = {}) {
+      return selectConversationHistoryPageFromStatements(options.sharedOnly ? shared : all, conversationId, options);
+    },
+    listConversationResendIndex(conversationId, { sharedOnly = false } = {}) {
+      const statement = (sharedOnly ? shared : all).resendIndex;
+      return statement ? statement.all({ conversationId }) : [];
+    },
+  };
+}
+
+// A cursor as the in-memory selector resolves it, in the SQL shape: the
+// message's own timestamp when its id is in the conversation, else the given
+// timestamp. Null when there is no cursor; `unsupported` when the given
+// values cannot be compared in SQL the way the selector compares them.
+function resolveCursor(statements, conversationId, { messageId = '', timestamp = '' } = {}) {
+  const cursorMessageId = String(messageId || '').trim();
+  const cursorTimestampText = String(timestamp || '').trim();
+  if (cursorMessageId) {
+    const row = statements.findById.get({ conversationId, id: cursorMessageId });
+    if (row) return { id: cursorMessageId, timestamp: String(row.timestamp) };
+  }
+  if (!cursorTimestampText) return null;
+  if (cursorMessageId && !ORDERABLE_ID_PATTERN.test(cursorMessageId)) return 'unsupported';
+  let canonical = cursorTimestampText;
+  if (!ISO_TIMESTAMP_PATTERN.test(canonical)) {
+    canonical = new Date(normalizeConversationTimestampMs(cursorTimestampText)).toISOString();
+    if (!ISO_TIMESTAMP_PATTERN.test(canonical)) return 'unsupported';
+  }
+  return { id: cursorMessageId || null, timestamp: canonical };
+}
+
+/**
+ * The page of rows (raw message rows, in conversation order) and its
+ * pageInfo, by the rules of selectConversationHistoryPage; null when the
+ * conversation or the cursor cannot be paged in SQL (see the top note).
+ */
+function selectConversationHistoryPageFromStatements(statements, conversationId, {
+  limit = 20,
+  beforeMessageId = '',
+  beforeTimestamp = '',
+  afterMessageId = '',
+  afterTimestamp = '',
+  aroundMessageId = '',
+} = {}) {
+  if (statements.irregular.get({ conversationId })?.irregular) return null;
+  const pageLimit = normalizeConversationHistoryLimit(limit);
+  const aroundId = String(aroundMessageId || '').trim();
+  const requestedAroundWindow = !!aroundId;
+  const requestedAfterWindow = !!String(afterMessageId || '').trim();
+  const beforeCursor = resolveCursor(statements, conversationId, { messageId: beforeMessageId, timestamp: beforeTimestamp });
+  const afterCursor = resolveCursor(statements, conversationId, { messageId: afterMessageId, timestamp: afterTimestamp });
+  if (beforeCursor === 'unsupported' || afterCursor === 'unsupported') return null;
+
+  let rows = [];
+  if (aroundId) {
+    const anchor = statements.findById.get({ conversationId, id: aroundId });
+    if (anchor) {
+      // Enough rows on both sides for the in-memory window rules to give the
+      // same window as over the whole conversation.
+      const before = statements.older
+        .all({ conversationId, timestamp: anchor.timestamp, id: anchor.id, limit: pageLimit - 1 })
+        .reverse();
+      const fromAnchor = statements.fromInclusive
+        .all({ conversationId, timestamp: anchor.timestamp, id: anchor.id, limit: pageLimit });
+      const local = [...before, ...fromAnchor];
+      const aroundIndex = before.length;
+      const halfWindow = Math.floor((pageLimit - 1) / 2);
+      let start = Math.max(0, aroundIndex - halfWindow);
+      const end = Math.min(local.length, start + pageLimit);
+      if ((end - start) < pageLimit) start = Math.max(0, end - pageLimit);
+      rows = local.slice(start, end);
+    }
+  }
+  if (!rows.length && !requestedAroundWindow && afterCursor) {
+    rows = statements.newer.all({ conversationId, ...afterCursor, limit: pageLimit });
+  }
+  if (!rows.length && !requestedAfterWindow && !requestedAroundWindow) {
+    rows = (beforeCursor
+      ? statements.older.all({ conversationId, ...beforeCursor, limit: pageLimit })
+      : statements.tail.all({ conversationId, limit: pageLimit })
+    ).reverse();
+  }
+
+  const first = rows[0] || null;
+  const last = rows[rows.length - 1] || null;
+  const hasMoreOlder = first
+    ? !!statements.existsOlder.get({ conversationId, timestamp: first.timestamp, id: first.id })?.found
+    : false;
+  const hasMoreNewer = last
+    ? !!statements.existsNewer.get({ conversationId, timestamp: last.timestamp, id: last.id })?.found
+    : false;
+  return { rows, pageInfo: buildConversationHistoryPageInfo(rows, { hasMoreOlder, hasMoreNewer }) };
+}

package/server/services/conversation-model-fallback.mjs

@@ -0,0 +1,57 @@
+'use strict';
+
+// What a send to an existing conversation runs with when the request names no
+// model or no effort. The answer is the conversation's own choice, never the
+// relay-wide catalog default: a plain POST /api/message from a script or an
+// agent used to switch a Copilot conversation to the catalog's first model and
+// to effort 'none', and then saved that as the conversation's preference.
+//
+// The effort clamp is the composer's own (public/app/conversation-preferences.mjs),
+// so the relay and the page settle on the same level for the same model.
+import { nearestSupportedReasoningEffort } from '../public/app/conversation-preferences.mjs';
+
+const AUTO_MODEL = 'auto';
+
+function toText(value) {
+  return String(value ?? '').trim();
+}
+
+/**
+ * The model an existing conversation was last set to, in this order:
+ *   1. the conversation's saved preference (what the composer shows);
+ *   2. the runtime session's model (provider_model, else model);
+ *   3. the model of the latest user message.
+ * 'auto' is not a model a later turn can run on, so it is skipped. Null when
+ * the conversation has none of these: the caller falls back to the catalog.
+ */
+export function inheritedConversationModel({
+  conversation = null,
+  runtimeSession = null,
+  latestUserMessageModel = '',
+} = {}) {
+  // provider_model and model are looked at one by one, so an 'auto' in one
+  // does not hide a real model in the other.
+  const candidates = [
+    { source: 'conversation', model: toText(conversation?.preferred_model) },
+    { source: 'runtime', model: toText(runtimeSession?.provider_model) },
+    { source: 'runtime', model: toText(runtimeSession?.model) },
+    { source: 'message', model: toText(latestUserMessageModel) },
+  ];
+  return candidates.find((entry) => entry.model && entry.model.toLowerCase() !== AUTO_MODEL) || null;
+}
+
+/**
+ * The effort for a turn that names none: the first candidate the model
+ * supports (or the nearest level to it), else the model's lowest level that
+ * is not 'none'. 'none' comes back only when it is the only level, or when a
+ * candidate asks for it and the model has it. '' when the model lists no
+ * levels at all. A provider whose own default is better than "the lowest
+ * level" passes `fallback`, returned when no candidate matches or clamps.
+ */
+export function fallbackReasoningEffort(candidates = [], supportedEfforts = [], { fallback } = {}) {
+  return nearestSupportedReasoningEffort(
+    (Array.isArray(candidates) ? candidates : [candidates]).map(toText).filter(Boolean),
+    supportedEfforts,
+    { fallback },
+  );
+}

package/server/services/host-suspend-command.mjs

@@ -14,6 +14,7 @@ import { windowsSystemToolPath } from '../../shared/windows-system-tools.mjs';
 export function runHostSuspendToRam({
   platform = process.platform,
   spawnImpl = spawn,
+  systemToolPath = windowsSystemToolPath,
   dryRun = /^(1|true|yes|on)$/i.test(String(process.env.OAR_HOST_SUSPEND_DRY_RUN || '')),
   logger = console,
 } = {}) {
@@ -26,7 +27,7 @@ export function runHostSuspendToRam({
     return { ok: true, command, dryRun: true };
   }
   try {
-    const child = spawnImpl(windowsSystemToolPath('rundll32.exe'), ['powrprof.dll,SetSuspendState', '0,0,0'], {
+    const child = spawnImpl(systemToolPath('rundll32.exe'), ['powrprof.dll,SetSuspendState', '0,0,0'], {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,

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/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

@@ -10,7 +10,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';
@@ -35,11 +35,12 @@ const EVENT_LABELS = Object.freeze({
   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.' },
 });
 
 // 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);
@@ -493,8 +494,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,