@oar-sh/oar 0.9.1 → 0.9.3

package/shared/copilot-model-order.mjs

@@ -0,0 +1,182 @@
+// The canonical order of the Copilot model catalog.
+//
+// The runtime's `rpc.model.list()` comes back in no useful order (the live
+// 2026-09-07 list interleaves gpt-6-astra after kimi-k2.7-code), and the
+// relay's model_variants rows used to be numbered per ingest, restarting at 0
+// for each batch of new ids — so pickers showed models in arrival order. This
+// module is the single definition of "the order a Copilot picker shows":
+//
+//   1. `auto` first;
+//   2. vendor rank: OpenAI, Anthropic, Google, xAI, Microsoft, Azure OpenAI,
+//      Moonshot AI, then any other vendor alphabetically;
+//   3. within a vendor, newest version first — the first dotted number in the
+//      id (gpt-5.6-terra → 5.6, gpt-6-astra → 6, claude-opus-4.8-fast → 4.8,
+//      kimi-k3 → 3, mai-code-1.1-flash → 1.1), compared segment-wise;
+//   4. ties: picker category powerful → versatile → lightweight → unknown;
+//   5. preview after non-preview;
+//   6. display name, natural-alpha.
+//
+// Pure: takes descriptors (any object with modelId|id and optional vendor,
+// pickerCategory, preview, displayName|name), returns a new array. Browser
+// and server neutral.
+
+export const COPILOT_VENDOR_ORDER = Object.freeze([
+  'OpenAI',
+  'Anthropic',
+  'Google',
+  'xAI',
+  'Microsoft',
+  'Azure OpenAI',
+  'Moonshot AI',
+]);
+
+const PICKER_CATEGORY_ORDER = Object.freeze(['powerful', 'versatile', 'lightweight']);
+
+export const AUTO_MODEL_ID = 'auto';
+
+const VENDOR_BY_PREFIX = [
+  ['gpt-', 'OpenAI'],
+  ['chatgpt-', 'OpenAI'],
+  ['o1-', 'OpenAI'],
+  ['o3-', 'OpenAI'],
+  ['o4-', 'OpenAI'],
+  ['codex-', 'OpenAI'],
+  ['openai/', 'OpenAI'],
+  ['claude-', 'Anthropic'],
+  ['anthropic/', 'Anthropic'],
+  ['gemini-', 'Google'],
+  ['google/', 'Google'],
+  ['grok-', 'xAI'],
+  ['mai-', 'Microsoft'],
+  ['microsoft/', 'Microsoft'],
+  ['kimi-', 'Moonshot AI'],
+];
+
+function modelIdOf(descriptor) {
+  if (typeof descriptor === 'string') return descriptor.trim();
+  return String(descriptor?.modelId ?? descriptor?.id ?? descriptor?.model ?? '').trim();
+}
+
+function displayNameOf(descriptor) {
+  if (typeof descriptor === 'string') return '';
+  return String(descriptor?.displayName ?? descriptor?.name ?? descriptor?.label ?? '').trim();
+}
+
+/**
+ * The vendor a bare model id implies, for rows that carry no runtime vendor
+ * (curated seeds, help-text ids, pre-metadata snapshots). A runtime-reported
+ * vendor always wins over this — `gpt-5-mini` is served by "Azure OpenAI".
+ */
+export function inferCopilotVendor(modelId) {
+  const lower = String(modelId || '').trim().toLowerCase();
+  if (!lower) return null;
+  if (lower === 'o1' || lower === 'o3') return 'OpenAI';
+  for (const [prefix, vendor] of VENDOR_BY_PREFIX) {
+    if (lower.startsWith(prefix)) return vendor;
+  }
+  return null;
+}
+
+function vendorOf(descriptor) {
+  const explicit = typeof descriptor === 'string' ? '' : String(descriptor?.vendor ?? '').trim();
+  return explicit || inferCopilotVendor(modelIdOf(descriptor)) || '';
+}
+
+function vendorRank(vendor) {
+  if (!vendor) return COPILOT_VENDOR_ORDER.length + 1;
+  const index = COPILOT_VENDOR_ORDER.findIndex((name) => name.toLowerCase() === vendor.toLowerCase());
+  return index === -1 ? COPILOT_VENDOR_ORDER.length : index;
+}
+
+/** The first dotted number in an id, as numeric segments; null when none. */
+export function parseModelVersion(modelId) {
+  const match = /(\d+(?:\.\d+)*)/.exec(String(modelId || ''));
+  if (!match) return null;
+  return match[1].split('.').map((segment) => Number(segment));
+}
+
+// Newest first: a missing segment is "older" than any present one (5 < 5.1),
+// and an absent version sorts after every versioned id.
+function compareVersionsDesc(a, b) {
+  if (!a && !b) return 0;
+  if (!a) return 1;
+  if (!b) return -1;
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    const left = a[index] ?? -1;
+    const right = b[index] ?? -1;
+    if (left !== right) return right - left;
+  }
+  return 0;
+}
+
+function categoryRank(descriptor) {
+  const category = typeof descriptor === 'string' ? '' : String(descriptor?.pickerCategory ?? '').trim().toLowerCase();
+  const index = PICKER_CATEGORY_ORDER.indexOf(category);
+  return index === -1 ? PICKER_CATEGORY_ORDER.length : index;
+}
+
+const naturalCollator = typeof Intl !== 'undefined' && typeof Intl.Collator === 'function'
+  ? new Intl.Collator('en', { numeric: true, sensitivity: 'base' })
+  : null;
+
+function compareNatural(a, b) {
+  if (naturalCollator) return naturalCollator.compare(a, b);
+  return a.localeCompare(b);
+}
+
+/** The comparable key of one descriptor; exported for tests and debugging. */
+export function copilotModelSortKey(descriptor) {
+  const modelId = modelIdOf(descriptor);
+  const vendor = vendorOf(descriptor);
+  return {
+    modelId,
+    auto: modelId.toLowerCase() === AUTO_MODEL_ID,
+    vendor,
+    vendorRank: vendorRank(vendor),
+    version: parseModelVersion(modelId),
+    categoryRank: categoryRank(descriptor),
+    preview: typeof descriptor !== 'string' && descriptor?.preview === true,
+    displayName: displayNameOf(descriptor) || modelId,
+  };
+}
+
+export function compareCopilotModels(a, b) {
+  const left = copilotModelSortKey(a);
+  const right = copilotModelSortKey(b);
+  if (left.auto !== right.auto) return left.auto ? -1 : 1;
+  if (left.vendorRank !== right.vendorRank) return left.vendorRank - right.vendorRank;
+  if (left.vendorRank >= COPILOT_VENDOR_ORDER.length) {
+    const byVendor = compareNatural(left.vendor, right.vendor);
+    if (byVendor !== 0) return byVendor;
+  }
+  const byVersion = compareVersionsDesc(left.version, right.version);
+  if (byVersion !== 0) return byVersion;
+  if (left.categoryRank !== right.categoryRank) return left.categoryRank - right.categoryRank;
+  if (left.preview !== right.preview) return left.preview ? 1 : -1;
+  const byName = compareNatural(left.displayName, right.displayName);
+  if (byName !== 0) return byName;
+  return compareNatural(left.modelId, right.modelId);
+}
+
+/** A new array of the descriptors in canonical order (stable). */
+export function sortCopilotModels(descriptors = []) {
+  const list = Array.isArray(descriptors) ? descriptors.filter((entry) => modelIdOf(entry)) : [];
+  return list
+    .map((descriptor, index) => ({ descriptor, index }))
+    .sort((a, b) => compareCopilotModels(a.descriptor, b.descriptor) || a.index - b.index)
+    .map((entry) => entry.descriptor);
+}
+
+/**
+ * `modelId → catalogIndex` over the canonical order. Duplicate ids keep the
+ * first position; the map is what a relay writes into sort_order.
+ */
+export function copilotCatalogIndexByModel(descriptors = []) {
+  const indexByModel = new Map();
+  for (const descriptor of sortCopilotModels(descriptors)) {
+    const modelId = modelIdOf(descriptor);
+    if (!indexByModel.has(modelId)) indexByModel.set(modelId, indexByModel.size);
+  }
+  return indexByModel;
+}

package/shared/media-embed-instructions.mjs

@@ -0,0 +1,35 @@
+// How agents embed media inline in their reply messages, taught once per
+// provider. The rendering work is client-side (sanitizePreviewHtml resolves
+// bare absolute paths to the drive/workspace file routes and upgrades
+// media-extension images to players); this module only carries the words.
+//
+// One constant, four seams — Claude (system-prompt append), Copilot (relay
+// tool guidance document), Cursor and Grok (once-per-worker prompt prefix) —
+// following preview-tool-core.mjs: providers cannot drift apart on wording
+// because there is exactly one wording.
+
+export const MEDIA_EMBED_INSTRUCTION_HEADING = '## Embedding media in replies';
+
+export const MEDIA_EMBED_INSTRUCTION_TEXT =
+  'To show the user an image, video, or audio clip inline in a reply, write a '
+  + 'markdown image whose target is the file\'s absolute path on this machine, '
+  + 'e.g. ![what it shows](/home/user/screenshots/result.png) or '
+  + '![demo clip](C:\\Users\\user\\Videos\\demo.mp4). The web app renders it '
+  + 'inline for the signed-in user — video and audio files become players — '
+  + 'with no upload, URL-encoding, or extra tooling needed. Media does not '
+  + 'render in shared/public transcript views.';
+
+export function renderMediaEmbedInstructionBlock() {
+  return `${MEDIA_EMBED_INSTRUCTION_HEADING}\n\n${MEDIA_EMBED_INSTRUCTION_TEXT}`;
+}
+
+/**
+ * Append the media-embed block to a guidance document unless it already
+ * carries one (idempotent, so a doc that gains the section statically or via a
+ * second apply pass is not taught twice).
+ */
+export function applyMediaEmbedInstructions(baseInstructions = '') {
+  const base = String(baseInstructions || '').trimEnd();
+  if (base.includes(MEDIA_EMBED_INSTRUCTION_HEADING)) return base;
+  return [base, renderMediaEmbedInstructionBlock()].filter(Boolean).join('\n\n');
+}

package/shared/model-descriptors.mjs

@@ -5,12 +5,42 @@ import { isValidModelId, normalizeModelIdCandidate } from './model-id.mjs';
 // of its own would inherit a sibling's.
 const MODEL_CONTAINER_KEYS = ['data', 'models', 'list', 'available', 'items', 'entries', 'result', 'response'];
 
+/**
+ * Every reasoning-effort level any Copilot catalog entry has been observed to
+ * advertise, in ladder order. `none` is the GPT family's explicit "no
+ * reasoning" level (and the relay's "model default" convention for
+ * effort-less models); `minimal` is Gemini's floor. Consumers validate against
+ * THIS list, not a per-family guess.
+ */
+export const KNOWN_REASONING_EFFORTS = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+
+export const MODEL_PICKER_CATEGORIES = Object.freeze(['powerful', 'versatile', 'lightweight']);
+
 export function normalizeContextLimitTokens(value) {
   const numeric = Number(value);
   if (!Number.isFinite(numeric) || numeric <= 0) return null;
   return Math.round(numeric);
 }
 
+/**
+ * The effort levels a catalog entry advertises, tolerant of both shapes the
+ * runtime speaks: the client-level `ModelInfo` (`supportedReasoningEfforts`)
+ * and the session-level `rpc.model.list()` entry, which is the RAW CAPI
+ * record carrying the list at `capabilities.supports.reasoning_effort`
+ * (live-verified on runtime 1.0.83 — the typed field never appears there;
+ * validating against it failed every effort-carrying turn, burn-in session
+ * ed5febdd). `null` = the entry carries no list: for an authoritative catalog
+ * entry that means the model has no effort control at all; callers that
+ * validate must stay PERMISSIVE on null, the runtime is the authority.
+ */
+export function supportedEffortsOf(entry) {
+  const typed = entry?.supportedReasoningEfforts;
+  if (Array.isArray(typed)) return typed.map((v) => String(v || '').trim().toLowerCase()).filter(Boolean);
+  const wire = entry?.capabilities?.supports?.reasoning_effort;
+  if (Array.isArray(wire)) return wire.map((v) => String(v || '').trim().toLowerCase()).filter(Boolean);
+  return null;
+}
+
 function findContextLimitTokens(value) {
   if (!value || typeof value !== 'object') return null;
   const candidates = [
@@ -52,36 +82,123 @@ function normalizePrice(value) {
   return Number.isFinite(numeric) && numeric >= 0 ? numeric : null;
 }
 
+// Both spellings the runtime uses: the typed client `ModelInfo` is camelCase
+// (`tokenPrices.longContext.inputPrice`), the raw CAPI record on the session
+// list is snake_case (`token_prices.long_context.input_price`).
 function normalizePricing(value, fallbackBatchSize = null) {
   if (!value || typeof value !== 'object') return null;
-  const batchSize = normalizeContextLimitTokens(value.batchSize) ?? normalizeContextLimitTokens(fallbackBatchSize);
+  const batchSize = normalizeContextLimitTokens(value.batchSize ?? value.batch_size)
+    ?? normalizeContextLimitTokens(fallbackBatchSize);
   const rates = {
-    input: normalizePrice(value.inputPrice),
-    output: normalizePrice(value.outputPrice),
-    cacheRead: normalizePrice(value.cacheReadPrice ?? value.cachePrice),
-    cacheWrite: normalizePrice(value.cacheWritePrice),
+    input: normalizePrice(value.inputPrice ?? value.input_price),
+    output: normalizePrice(value.outputPrice ?? value.output_price),
+    cacheRead: normalizePrice(value.cacheReadPrice ?? value.cache_read_price ?? value.cachePrice ?? value.cache_price),
+    cacheWrite: normalizePrice(value.cacheWritePrice ?? value.cache_write_price),
   };
   // batchSize alone is a denominator, not evidence of real pricing.
   if (!Object.values(rates).some((entry) => entry !== null)) return null;
   return { ...rates, batchSize };
 }
 
+function tokenPricesOf(value) {
+  return value?.billing?.tokenPrices
+    || value?.billing?.token_prices
+    || value?.tokenPrices
+    || value?.token_prices
+    || null;
+}
+
+function longContextPricesOf(tokenPrices, value) {
+  return tokenPrices?.longContext || tokenPrices?.long_context || value?.longContext || value?.long_context || null;
+}
+
+function defaultPricesOf(tokenPrices) {
+  // The raw record nests the default tier under `default`; the typed shape
+  // puts the default rates directly on tokenPrices.
+  return tokenPrices?.default && typeof tokenPrices.default === 'object' ? tokenPrices.default : tokenPrices;
+}
+
+function limitsOf(value) {
+  return value?.capabilities?.limits || value?.limits || {};
+}
+
+/** `capabilities.limits.max_context_window_tokens` — the REAL window. */
+function contextWindowTokensOf(value) {
+  const limits = limitsOf(value);
+  return normalizeContextLimitTokens(
+    limits.max_context_window_tokens ?? limits.maxContextWindowTokens ?? value?.maxContextWindowTokens,
+  );
+}
+
+function maxPromptTokensOf(value) {
+  const limits = limitsOf(value);
+  return normalizeContextLimitTokens(limits.max_prompt_tokens ?? limits.maxPromptTokens ?? value?.maxPromptTokens);
+}
+
+function maxOutputTokensOf(value) {
+  const limits = limitsOf(value);
+  return normalizeContextLimitTokens(limits.max_output_tokens ?? limits.maxOutputTokens ?? value?.maxOutputTokens) || 0;
+}
+
+/**
+ * The context budget of a pricing tier: prompt budget + output budget. The
+ * real window (`max_context_window_tokens`) caps it — a runtime's advertised
+ * prompt+output pair can exceed the window (haiku: 128000+32000 vs a 144000
+ * window) and the cap is what stops the auto-compact thresholds from being
+ * computed against tokens the model cannot actually hold. When no tier budget
+ * is advertised the window itself is the limit.
+ */
 function contextLimitForTier(value, tier = 'default') {
-  const limits = value?.capabilities?.limits || value?.limits || {};
-  const outputTokens = normalizeContextLimitTokens(
-    limits.max_output_tokens ?? limits.maxOutputTokens ?? value?.maxOutputTokens,
-  ) || 0;
-  const tokenPrices = value?.billing?.tokenPrices || value?.tokenPrices || null;
+  const outputTokens = maxOutputTokensOf(value);
+  const window = contextWindowTokensOf(value);
+  const capToWindow = (tokens) => (tokens !== null && window !== null ? Math.min(tokens, window) : tokens);
+  const tokenPrices = tokenPricesOf(value);
   if (tier === 'long_context') {
-    const longContext = tokenPrices?.longContext
-      || value?.longContext;
-    const promptTokens = findPromptBudgetTokens(longContext);
-    return promptTokens === null ? null : promptTokens + outputTokens;
+    const promptTokens = findPromptBudgetTokens(longContextPricesOf(tokenPrices, value));
+    return promptTokens === null ? null : capToWindow(promptTokens + outputTokens);
   }
-  const defaultPromptTokens = findPromptBudgetTokens(tokenPrices)
-    ?? normalizeContextLimitTokens(limits.max_prompt_tokens ?? limits.maxPromptTokens);
-  if (defaultPromptTokens !== null) return defaultPromptTokens + outputTokens;
-  return findContextLimitTokens(value);
+  const defaultPromptTokens = findPromptBudgetTokens(defaultPricesOf(tokenPrices))
+    ?? maxPromptTokensOf(value);
+  if (defaultPromptTokens !== null) return capToWindow(defaultPromptTokens + outputTokens);
+  return window ?? findContextLimitTokens(value);
+}
+
+function normalizeText(value) {
+  const text = String(value ?? '').trim();
+  return text || null;
+}
+
+function normalizePickerCategory(value) {
+  const text = String(value || '').trim().toLowerCase();
+  return MODEL_PICKER_CATEGORIES.includes(text) ? text : null;
+}
+
+/**
+ * One descriptor per catalog entry, from EITHER wire shape (raw CAPI record
+ * or typed `ModelInfo`). Every field the API contract carries is decided
+ * here and nowhere else, so the worker's session list and the discovery
+ * service's client list yield identical metadata for the same model.
+ */
+function describeEntry(modelId, value) {
+  const tokenPrices = tokenPricesOf(value);
+  const defaultPrices = defaultPricesOf(tokenPrices);
+  const batchSize = tokenPrices?.batchSize ?? tokenPrices?.batch_size ?? null;
+  return {
+    modelId,
+    contextLimitTokens: contextLimitForTier(value),
+    longContextLimitTokens: contextLimitForTier(value, 'long_context'),
+    pricing: {
+      default: normalizePricing(defaultPrices, batchSize),
+      longContext: normalizePricing(longContextPricesOf(tokenPrices, value), batchSize),
+    },
+    displayName: normalizeText(value.name ?? value.displayName),
+    vendor: normalizeText(value.vendor),
+    pickerCategory: normalizePickerCategory(value.model_picker_category ?? value.modelPickerCategory),
+    preview: value.preview === true,
+    contextWindowTokens: contextWindowTokensOf(value),
+    maxPromptTokens: maxPromptTokensOf(value),
+    supportedEfforts: supportedEffortsOf(value),
+  };
 }
 
 export function extractModelDescriptors(value, out = []) {
@@ -98,21 +215,55 @@ export function extractModelDescriptors(value, out = []) {
   if (typeof value !== 'object') return out;
 
   const modelId = normalizeModelIdCandidate(value.modelId || value.id || value.model || null);
-  if (isValidModelId(modelId)) {
-    const tokenPrices = value?.billing?.tokenPrices || value?.tokenPrices || null;
-    out.push({
-      modelId,
-      contextLimitTokens: contextLimitForTier(value),
-      longContextLimitTokens: contextLimitForTier(value, 'long_context'),
-      pricing: {
-        default: normalizePricing(tokenPrices),
-        longContext: normalizePricing(tokenPrices?.longContext, tokenPrices?.batchSize),
-      },
-    });
-  }
+  if (isValidModelId(modelId)) out.push(describeEntry(modelId, value));
   for (const key of MODEL_CONTAINER_KEYS) {
     const nested = value[key];
     if (nested !== undefined && nested !== null) extractModelDescriptors(nested, out);
   }
   return out;
 }
+
+/**
+ * The per-model metadata object of the catalog API contract
+ * (`modelMetadataByModel[modelId]` on GET /api/models, GET /api/model-variants
+ * and the models_updated socket payload), built from one descriptor. All three
+ * snapshot producers publish exactly this; `catalogIndex` is assigned by the
+ * relay from the canonical order, never by a producer.
+ */
+export function modelMetadataFromDescriptor(descriptor = {}) {
+  return {
+    defaultContextLimitTokens: normalizeContextLimitTokens(descriptor.contextLimitTokens),
+    longContextLimitTokens: normalizeContextLimitTokens(descriptor.longContextLimitTokens),
+    pricing: descriptor.pricing && typeof descriptor.pricing === 'object' ? descriptor.pricing : null,
+    displayName: normalizeText(descriptor.displayName),
+    vendor: normalizeText(descriptor.vendor),
+    pickerCategory: normalizePickerCategory(descriptor.pickerCategory),
+    preview: descriptor.preview === true,
+    contextWindowTokens: normalizeContextLimitTokens(descriptor.contextWindowTokens),
+    maxPromptTokens: normalizeContextLimitTokens(descriptor.maxPromptTokens),
+    supportedEfforts: Array.isArray(descriptor.supportedEfforts)
+      ? descriptor.supportedEfforts.map((v) => String(v || '').trim().toLowerCase()).filter(Boolean)
+      : null,
+    catalogIndex: null,
+  };
+}
+
+/**
+ * The `{ models, contextLimitsByModel, modelMetadataByModel }` triple every
+ * `/api/models/snapshot` publisher sends, so the worker, the standalone relay
+ * and the server-side discovery cannot drift in what they publish.
+ */
+export function buildModelSnapshotFields(descriptors = []) {
+  const list = Array.isArray(descriptors) ? descriptors.filter((entry) => entry?.modelId) : [];
+  return {
+    models: list.map((entry) => entry.modelId),
+    contextLimitsByModel: Object.fromEntries(
+      list
+        .filter((entry) => normalizeContextLimitTokens(entry.contextLimitTokens) !== null)
+        .map((entry) => [entry.modelId, normalizeContextLimitTokens(entry.contextLimitTokens)]),
+    ),
+    modelMetadataByModel: Object.fromEntries(
+      list.map((entry) => [entry.modelId, modelMetadataFromDescriptor(entry)]),
+    ),
+  };
+}

package/shared/model-id.mjs

@@ -1,9 +1,15 @@
+// The families the Copilot catalog has been observed to serve. This is the
+// validator's baseline, not a whitelist of "models we like": an id the runtime
+// itself lists must pass, or the model silently vanishes from every picker
+// (grok-* and kimi-* did exactly that — 4 of 27 live catalog entries).
 const MODEL_ID_PREFIXES = [
   'gpt-',
   'chatgpt-',
   'claude-',
   'gemini-',
   'mai-',
+  'grok-',
+  'kimi-',
   'o1-',
   'o3-',
   'o4-',

package/shared/pwa-app-name.mjs

@@ -0,0 +1,44 @@
+// The installed-PWA app name, stored once per relay in app_settings and served
+// to every browser through /manifest.webmanifest. It must live server-side:
+// Android's WebAPK update check re-fetches the manifest outside any page
+// session, so a name the server does not know reverts on the phone with an
+// accept-or-uninstall prompt.
+
+export const PWA_APP_NAME_DEFAULT = 'OAR';
+export const PWA_APP_NAME_MAX_LENGTH = 60;
+
+/** Empty is valid and means "use the default name". */
+export function normalizePwaAppName(rawValue) {
+  const value = String(rawValue ?? '').replace(/\s+/g, ' ').trim();
+  if (value.length > PWA_APP_NAME_MAX_LENGTH) {
+    return { ok: false, error: `App name must be ${PWA_APP_NAME_MAX_LENGTH} characters or fewer` };
+  }
+  return { ok: true, value };
+}
+
+/** Stored DB value -> custom name, or '' when unset/junk (meaning default). */
+export function readPwaAppNameSetting(storedValue) {
+  const normalized = normalizePwaAppName(storedValue);
+  return normalized.ok ? normalized.value : '';
+}
+
+/**
+ * Launcher labels get very little room: the first word when it fits, otherwise
+ * a hard slice of the full name.
+ */
+export function derivePwaShortName(name) {
+  const text = String(name || '').trim();
+  if (!text) return PWA_APP_NAME_DEFAULT;
+  const firstWord = text.split(/\s+/)[0] || text;
+  if (firstWord.length <= 12) return firstWord;
+  return text.slice(0, 12).trim() || PWA_APP_NAME_DEFAULT;
+}
+
+export function resolvePwaManifestNames(customName, templateName) {
+  const custom = String(customName || '').trim();
+  if (custom) {
+    return { name: custom, short_name: derivePwaShortName(custom) };
+  }
+  const fallback = String(templateName || '').trim() || PWA_APP_NAME_DEFAULT;
+  return { name: fallback, short_name: derivePwaShortName(fallback) };
+}

package/shared/question-multi-select.mjs

@@ -0,0 +1,16 @@
+// Whether a choice question reads as "pick several" — for providers whose
+// ask-user tool has no multi-select flag (Copilot's `ask_user`; Claude's
+// AskUserQuestion carries `multiSelect: true` itself). The card then offers
+// checkmarks instead of one-shot buttons and answers with the selected labels
+// joined by ", ". Conservative on purpose: an ordinary "which one?" keeps its
+// buttons, because a wrongly multi-select card costs the user a second click
+// while a wrongly single-select one forces them into the free-text field.
+export function looksLikeMultiSelectQuestion(questionText, choices = []) {
+  if (!Array.isArray(choices) || choices.length < 2) return false;
+  const text = String(questionText || '');
+  return /\ball that apply\b/i.test(text)
+    || /\bmulti-?select\b/i.test(text)
+    || /\b(select|choose|pick|check|tick|enable|turn on)\b[^.!?\n]{0,40}\b(all|multiple|several|any number|one or more|as many|more than one)\b/i.test(text)
+    || /\bmultiple (choices|options|selections|answers)\b/i.test(text)
+    || /\bone or more\b/i.test(text);
+}

package/shared/relay-stop-failure.mjs

@@ -0,0 +1,15 @@
+// The terminal outcome of a turn the user stopped — what the relay records
+// when a worker acknowledges an abort control. Shared so a worker that dies
+// before its ack lands fails the stopped row the same way instead of letting
+// it be requeued (a requeue re-runs a prompt the user explicitly stopped).
+export function buildRelayStopFailure() {
+  return {
+    kind: 'turn-aborted',
+    error: 'turn-aborted',
+    code: 'turn-aborted',
+    stableCode: 'relay.turn-aborted',
+    message: 'System note: This turn was stopped from the relay UI before completion.',
+    guidance: 'Send a new message to continue when you are ready.',
+    failedAt: new Date().toISOString(),
+  };
+}

package/shared/slash-command-guard.mjs

@@ -0,0 +1,76 @@
+// Keeps a "/x" message the relay delivers to the Claude CLI plain text.
+//
+// The relay itself runs only /compact and /preview as commands, and neither
+// reaches a worker as text: the composer (and the /api/message route, for
+// /compact) intercept them. Any other "/x" the composer sends only after its
+// warn-once guard ("press send again to send as text"), and the API accepts
+// it as-is — so it must reach the model as the text the user typed. The Claude
+// CLI, however, runs a prompt as a slash command when the string, or its LAST
+// text block trimmed, starts with "/". Between turns that ran "/help what is
+// 3 + 4?" as the CLI's /help (a `local_command` with "isn't available in this
+// environment" as its output): the model never saw the question, and the
+// relay attributed the next turn's reply to that row (live, 2026-09-26).
+//
+// The guard is a zero-width space in front of the "/". JavaScript's trim()
+// does not strip U+200B, so neither the CLI's command check nor its queue's
+// "is this a command" check fires, and the message is handled exactly like
+// any other plain-text prompt (live probe, CLI 2.1.283: no local_command, the
+// model answered the question, the transcript keeps the character). The
+// relay stores and shows the user's own text; only the CLI sees the guard.
+//
+// A steered message needs none: the steer note (shared/steer-note.mjs) already
+// leads its text, so the guard only applies where the text itself starts
+// with "/".
+//
+// Not the SDK's per-message `client_composed: true`: that suppresses the
+// dispatch too (same probe), but older CLIs ignore the field, it also turns
+// off `@path` expansion and drops part of the turn-start context for that
+// message (the probe lost the token-budget reminder), and per the CLI bundle
+// its queue still classifies the text by the leading "/" (e.g. never merges
+// it with other queued prompts) — the guard makes it plain text everywhere.
+
+export const SLASH_COMMAND_GUARD = '\u200B';
+
+function readsAsSlashCommand(text) {
+  return typeof text === 'string' && text.trim().startsWith('/');
+}
+
+/** Prefix the guard when the CLI would read the text as a slash command. */
+export function withSlashCommandGuard(text) {
+  return readsAsSlashCommand(text) ? `${SLASH_COMMAND_GUARD}${text}` : text;
+}
+
+/**
+ * The guard applied to Claude user content: a string, or every text block of a
+ * content-block array (the CLI inspects the last block; guarding each keeps
+ * that true whatever the block order). Returns the input itself when nothing
+ * needed a guard; never mutates it.
+ */
+export function withSlashCommandGuardContent(content) {
+  if (typeof content === 'string') return withSlashCommandGuard(content);
+  if (!Array.isArray(content)) return content;
+  if (!content.some((block) => block?.type === 'text' && readsAsSlashCommand(block.text))) return content;
+  return content.map((block) => (block?.type === 'text' && readsAsSlashCommand(block.text)
+    ? { ...block, text: withSlashCommandGuard(block.text) }
+    : block));
+}
+
+/**
+ * The user's own text from a guarded prompt: the leading guard is dropped only
+ * where it stands in front of a "/", so other text is returned unchanged.
+ */
+export function stripSlashCommandGuard(text) {
+  const value = String(text ?? '');
+  return value.startsWith(SLASH_COMMAND_GUARD) && readsAsSlashCommand(value.slice(SLASH_COMMAND_GUARD.length))
+    ? value.slice(SLASH_COMMAND_GUARD.length)
+    : value;
+}
+
+/** stripSlashCommandGuard over a string or each text block of a content array. */
+export function stripSlashCommandGuardContent(content) {
+  if (typeof content === 'string') return stripSlashCommandGuard(content);
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => (block?.type === 'text' && typeof block.text === 'string'
+    ? { ...block, text: stripSlashCommandGuard(block.text) }
+    : block));
+}