@oar-sh/oar 0.9.2 → 0.9.4

package/server/services/github-ci-activity-service.mjs

@@ -0,0 +1,199 @@
+'use strict';
+
+import { execFile } from 'node:child_process';
+
+/**
+ * Open GitHub Actions runs for a set of workspace roots, via the `gh` CLI the
+ * host already has (same credentials the agents use). Nothing in the relay
+ * models CI, so this is a best-effort outside view: a repo whose runs cannot
+ * be read counts as "unknown" and blocks for a grace period, after which it is
+ * ignored rather than keeping the host awake forever over a GitHub outage.
+ */
+
+const DEFAULT_CACHE_MS = 20 * 1000;
+const DEFAULT_UNKNOWN_GRACE_MS = 15 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 20 * 1000;
+const RUN_LIST_LIMIT = 30;
+
+const OPEN_RUN_STATUSES = new Set(['queued', 'in_progress', 'waiting', 'requested', 'pending']);
+
+/** `git@github.com:o/r.git`, `https://github.com/o/r`, `ssh://git@github.com/o/r.git` → `o/r`. */
+export function parseGitHubRepoSlug(remoteUrl) {
+  const text = String(remoteUrl || '').trim();
+  if (!text) return null;
+  const match = text.match(/github\.com[:/]+([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  if (!match) return null;
+  return `${match[1]}/${match[2]}`;
+}
+
+export function isOpenCiRunStatus(status) {
+  const value = String(status || '').trim().toLowerCase();
+  if (!value) return false;
+  return OPEN_RUN_STATUSES.has(value) || value !== 'completed';
+}
+
+function execText(execFileImpl, file, args, { cwd = undefined, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    try {
+      execFileImpl(file, args, { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+        if (settled) return;
+        settled = true;
+        if (error) {
+          const detail = String(stderr || error.message || '').trim().split('\n')[0] || 'command failed';
+          reject(new Error(detail.slice(0, 200)));
+          return;
+        }
+        resolve(String(stdout || ''));
+      });
+    } catch (error) {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    }
+  });
+}
+
+export function createGitHubCiActivityService({
+  execFileImpl = execFile,
+  now = () => Date.now(),
+  cacheMs = DEFAULT_CACHE_MS,
+  unknownGraceMs = DEFAULT_UNKNOWN_GRACE_MS,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  logger = console,
+} = {}) {
+  // root → { slug: string|null, at }
+  const slugByRoot = new Map();
+  // slug → { runs, error, at, unknownSince, inFlight }
+  const runsBySlug = new Map();
+
+  async function resolveSlug(root) {
+    const key = String(root || '').trim();
+    if (!key) return null;
+    const cached = slugByRoot.get(key);
+    if (cached && cached.at !== null && now() - cached.at < 10 * cacheMs) return cached.slug;
+    let slug = null;
+    try {
+      const url = await execText(execFileImpl, 'git', ['-C', key, 'remote', 'get-url', 'origin'], { timeoutMs });
+      slug = parseGitHubRepoSlug(url);
+    } catch {
+      slug = null;
+    }
+    slugByRoot.set(key, { slug, at: now() });
+    return slug;
+  }
+
+  async function fetchRuns(slug) {
+    const entry = runsBySlug.get(slug) || { runs: [], error: null, at: null, unknownSince: null, inFlight: null };
+    runsBySlug.set(slug, entry);
+    if (entry.inFlight) return entry.inFlight;
+    if (entry.at !== null && now() - entry.at < cacheMs) return entry;
+    entry.inFlight = (async () => {
+      try {
+        const out = await execText(execFileImpl, 'gh', [
+          'run', 'list', '-R', slug, '--limit', String(RUN_LIST_LIMIT),
+          '--json', 'status,name,headBranch,databaseId,event',
+        ], { timeoutMs });
+        const parsed = JSON.parse(out || '[]');
+        entry.runs = (Array.isArray(parsed) ? parsed : [])
+          .filter((run) => run && isOpenCiRunStatus(run.status))
+          .map((run) => ({
+            id: run.databaseId ?? null,
+            name: String(run.name || 'workflow').slice(0, 120),
+            headBranch: String(run.headBranch || '').slice(0, 160),
+            status: String(run.status || '').slice(0, 40),
+            event: String(run.event || '').slice(0, 40),
+          }));
+        entry.error = null;
+        entry.unknownSince = null;
+      } catch (error) {
+        entry.error = String(error?.message || error || 'gh failed').slice(0, 200);
+        if (entry.unknownSince === null) entry.unknownSince = now();
+        try { logger.warn?.(`[host-suspend] CI state for ${slug} unknown: ${entry.error}`); } catch {}
+      } finally {
+        entry.at = now();
+        entry.inFlight = null;
+      }
+      return entry;
+    })();
+    return entry.inFlight;
+  }
+
+  /**
+   * @param {string[]} workspaceRoots
+   * @returns {Promise<{ repos: Array<{ repo, runs }>, unknown: Array<{ repo, error, since, ignored }>, blockers: Array<object> }>}
+   */
+  async function describeRuns(workspaceRoots = []) {
+    const roots = [...new Set((Array.isArray(workspaceRoots) ? workspaceRoots : []).map((r) => String(r || '').trim()).filter(Boolean))];
+    const slugs = new Set();
+    for (const root of roots) {
+      const slug = await resolveSlug(root);
+      if (slug) slugs.add(slug);
+    }
+    const repos = [];
+    const unknown = [];
+    const blockers = [];
+    for (const slug of slugs) {
+      const entry = await fetchRuns(slug);
+      if (entry.error) {
+        const since = entry.unknownSince === null ? now() : entry.unknownSince;
+        const ignored = now() - since >= unknownGraceMs;
+        unknown.push({ repo: slug, error: entry.error, since: new Date(since).toISOString(), ignored });
+        if (!ignored) {
+          blockers.push({ kind: 'ci-unknown', detail: `CI state of ${slug} unknown (${entry.error})`, title: slug });
+        }
+        continue;
+      }
+      if (entry.runs.length) {
+        repos.push({ repo: slug, runs: entry.runs.map((r) => ({ ...r })) });
+        const what = entry.runs.slice(0, 4).map((r) => `${r.name} on ${r.headBranch || '?'} (${r.status})`).join(', ');
+        blockers.push({ kind: 'ci', title: slug, count: entry.runs.length, detail: what });
+      }
+    }
+    return { repos, unknown, blockers };
+  }
+
+  /**
+   * Last known picture without touching git/gh — for synchronous collectors
+   * that kick describeRuns() off in the background. A root or repo that has
+   * never been resolved yet reports a `ci-checking` blocker so the host does
+   * not sleep during the very first lookup.
+   */
+  function snapshot(workspaceRoots = []) {
+    const blockers = [];
+    const repos = [];
+    const unknown = [];
+    const slugs = new Set();
+    let checking = 0;
+    // Several busy conversations usually share one workspace; count it once.
+    const roots = new Set((Array.isArray(workspaceRoots) ? workspaceRoots : []).map((root) => String(root || '').trim()));
+    for (const key of roots) {
+      if (!key) continue;
+      const cached = slugByRoot.get(key);
+      if (!cached) { checking += 1; continue; }
+      if (cached.slug) slugs.add(cached.slug);
+    }
+    for (const slug of slugs) {
+      const entry = runsBySlug.get(slug);
+      if (!entry || entry.at === null) { checking += 1; continue; }
+      if (entry.error) {
+        const since = entry.unknownSince === null ? now() : entry.unknownSince;
+        const ignored = now() - since >= unknownGraceMs;
+        unknown.push({ repo: slug, error: entry.error, since: new Date(since).toISOString(), ignored });
+        if (!ignored) blockers.push({ kind: 'ci-unknown', title: slug, detail: `CI state of ${slug} unknown (${entry.error})` });
+        continue;
+      }
+      if (entry.runs.length) {
+        repos.push({ repo: slug, runs: entry.runs.map((r) => ({ ...r })) });
+        const what = entry.runs.slice(0, 4).map((r) => `${r.name} on ${r.headBranch || '?'} (${r.status})`).join(', ');
+        blockers.push({ kind: 'ci', title: slug, count: entry.runs.length, detail: what });
+      }
+    }
+    if (checking > 0) {
+      blockers.push({ kind: 'ci-checking', count: checking, detail: `Checking CI state of ${checking} workspace${checking === 1 ? '' : 's'}` });
+    }
+    return { repos, unknown, blockers };
+  }
+
+  return { describeRuns, snapshot, parseGitHubRepoSlug };
+}

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

@@ -0,0 +1,38 @@
+'use strict';
+
+import { spawn } from 'node:child_process';
+
+/**
+ * The actual suspend-to-RAM call. Windows only: `SetSuspendState 0,0,0` puts
+ * the box into S3 (hibernation is not enabled on the host, so this never
+ * hibernates). Detached so the relay does not wait on it.
+ *
+ * `OAR_HOST_SUSPEND_DRY_RUN=1` logs instead of sleeping the machine, which is
+ * how the deferred-suspend flow gets exercised on a dev box.
+ */
+export function runHostSuspendToRam({
+  platform = process.platform,
+  spawnImpl = spawn,
+  dryRun = /^(1|true|yes|on)$/i.test(String(process.env.OAR_HOST_SUSPEND_DRY_RUN || '')),
+  logger = console,
+} = {}) {
+  if (platform !== 'win32') {
+    return { ok: false, statusCode: 501, error: 'Host suspend is only supported on Windows' };
+  }
+  const command = 'rundll32.exe powrprof.dll,SetSuspendState 0,0,0';
+  if (dryRun) {
+    try { logger.log?.(`[host-suspend] DRY RUN — would run: ${command}`); } catch {}
+    return { ok: true, command, dryRun: true };
+  }
+  try {
+    const child = spawnImpl('rundll32.exe', ['powrprof.dll,SetSuspendState', '0,0,0'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+    child.unref?.();
+    return { ok: true, command };
+  } catch (error) {
+    return { ok: false, statusCode: 500, error: error?.message || 'Failed to launch host suspend command' };
+  }
+}

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

@@ -0,0 +1,254 @@
+'use strict';
+
+/**
+ * Deferred host suspend: a "💤 Suspend host" request is queued and fulfilled
+ * only once nothing is running any more — no queued/processing turn, no live
+ * background task, no open CI run of a watched workspace — for a sustained
+ * idle window. Idle at request time means a short countdown instead, so the
+ * banner still gives the user a moment to cancel.
+ *
+ * Everything lives in memory: a relay restart drops the request (dispose()
+ * reports it so the caller can push a notice). The service is pure
+ * orchestration; the activity collector, the suspend command and the timers
+ * are injected so the state machine is unit-testable with fake clocks.
+ */
+
+export const HOST_SUSPEND_IDLE_WINDOW_MS = 2 * 60 * 1000;
+export const HOST_SUSPEND_IDLE_COUNTDOWN_MS = 30 * 1000;
+const DEFAULT_POLL_MS = 1000;
+
+export const HOST_SUSPEND_STATUSES = Object.freeze(['idle', 'queued', 'countdown', 'suspending']);
+
+function clampText(value, max, fallback) {
+  const text = String(value ?? '').trim().slice(0, max);
+  return text || fallback;
+}
+
+/**
+ * Normalise a blocker so the client can render it without guessing. Blockers
+ * with the same `kind` and `detail` are treated as identical when deciding
+ * whether the state changed.
+ */
+export function normalizeHostActivityBlocker(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const kind = String(raw.kind || '').trim();
+  if (!kind) return null;
+  const count = Number(raw.count);
+  return {
+    kind,
+    conversationId: raw.conversationId ? String(raw.conversationId) : null,
+    title: raw.title ? String(raw.title).slice(0, 160) : null,
+    count: Number.isFinite(count) && count > 0 ? Math.trunc(count) : null,
+    detail: String(raw.detail || '').slice(0, 400),
+  };
+}
+
+export function blockersFromActivity(activity) {
+  const list = Array.isArray(activity?.blockers) ? activity.blockers : Array.isArray(activity) ? activity : [];
+  return list.map(normalizeHostActivityBlocker).filter(Boolean);
+}
+
+export function createHostSuspendService({
+  collectActivity,
+  runSuspend,
+  onStateChange = null,
+  onSuspended = null,
+  onDropped = null,
+  logger = console,
+  now = () => Date.now(),
+  setIntervalImpl = setInterval,
+  clearIntervalImpl = clearInterval,
+  pollMs = DEFAULT_POLL_MS,
+  idleWindowMs = HOST_SUSPEND_IDLE_WINDOW_MS,
+  idleCountdownMs = HOST_SUSPEND_IDLE_COUNTDOWN_MS,
+} = {}) {
+  if (typeof collectActivity !== 'function') throw new Error('collectActivity is required');
+  if (typeof runSuspend !== 'function') throw new Error('runSuspend is required');
+
+  let status = 'idle';
+  let request = null;
+  let blockers = [];
+  let idleSince = null;
+  let fireAt = null;
+  let everBlocked = false;
+  let checkedAt = null;
+  let lastError = null;
+  let pollTimer = null;
+  let lastEmittedKey = '';
+  let ticking = false;
+
+  function publicState() {
+    return {
+      status,
+      pending: status === 'queued' || status === 'countdown' || status === 'suspending',
+      reason: request?.reason || null,
+      requestedBy: request?.requestedBy || null,
+      requestedAt: request?.requestedAt || null,
+      idleSince: idleSince ? new Date(idleSince).toISOString() : null,
+      fireAt: fireAt ? new Date(fireAt).toISOString() : null,
+      idleWindowMs: everBlocked ? idleWindowMs : idleCountdownMs,
+      checkedAt: checkedAt ? new Date(checkedAt).toISOString() : null,
+      blockers: blockers.map((b) => ({ ...b })),
+      lastError,
+    };
+  }
+
+  function emit(force = false) {
+    const state = publicState();
+    // Countdowns tick on the client from fireAt; only real transitions go out.
+    const key = JSON.stringify([
+      state.status,
+      state.requestedAt,
+      state.fireAt,
+      state.blockers.map((b) => `${b.kind}|${b.conversationId}|${b.count}|${b.detail}`),
+      state.lastError,
+    ]);
+    if (!force && key === lastEmittedKey) return;
+    lastEmittedKey = key;
+    try { onStateChange?.(state); } catch (error) {
+      try { logger.warn?.(`[host-suspend] state listener failed: ${error?.message || error}`); } catch {}
+    }
+  }
+
+  function stopPolling() {
+    if (!pollTimer) return;
+    try { clearIntervalImpl(pollTimer); } catch {}
+    pollTimer = null;
+  }
+
+  function resetToIdle() {
+    status = 'idle';
+    request = null;
+    blockers = [];
+    idleSince = null;
+    fireAt = null;
+    everBlocked = false;
+    lastError = null;
+    stopPolling();
+  }
+
+  function collect() {
+    try {
+      const activity = collectActivity({ request: request ? { ...request } : null });
+      lastError = null;
+      return blockersFromActivity(activity);
+    } catch (error) {
+      // An unreadable activity picture must not sleep the box under running
+      // agents: report it as a blocker until the collector recovers.
+      lastError = String(error?.message || error || 'activity check failed').slice(0, 300);
+      return [{
+        kind: 'error',
+        conversationId: null,
+        title: null,
+        count: null,
+        detail: `Activity check failed: ${lastError}`,
+      }];
+    }
+  }
+
+  function evaluate() {
+    if (status !== 'queued' && status !== 'countdown') return;
+    const at = now();
+    checkedAt = at;
+    blockers = collect();
+    if (blockers.length) {
+      everBlocked = true;
+      idleSince = null;
+      fireAt = null;
+      status = 'queued';
+      emit();
+      return;
+    }
+    if (!idleSince) idleSince = at;
+    const windowMs = everBlocked ? idleWindowMs : idleCountdownMs;
+    fireAt = idleSince + windowMs;
+    status = 'countdown';
+    if (at >= fireAt) {
+      fire();
+      return;
+    }
+    emit();
+  }
+
+  function fire() {
+    status = 'suspending';
+    stopPolling();
+    const state = publicState();
+    emit(true);
+    try { logger.log?.(`[host-suspend] everything idle for ${Math.round((state.idleWindowMs || 0) / 1000)} s; suspending host (requested by ${state.requestedBy || 'unknown'})`); } catch {}
+    let result = null;
+    try {
+      result = runSuspend({ state });
+    } catch (error) {
+      lastError = String(error?.message || error || 'suspend failed').slice(0, 300);
+      try { logger.warn?.(`[host-suspend] suspend command failed: ${lastError}`); } catch {}
+    }
+    const failed = result && result.ok === false;
+    if (failed && !lastError) lastError = String(result.error || 'suspend failed').slice(0, 300);
+    const finalError = lastError;
+    resetToIdle();
+    lastError = finalError;
+    emit(true);
+    if (!finalError) {
+      try { onSuspended?.(state); } catch {}
+    }
+  }
+
+  function tick() {
+    if (ticking) return;
+    ticking = true;
+    try { evaluate(); } finally { ticking = false; }
+  }
+
+  function requestSuspend({ reason = 'manual-suspend', requestedBy = 'localhost-api' } = {}) {
+    if (status === 'suspending') return { accepted: false, state: publicState() };
+    if (status === 'queued' || status === 'countdown') {
+      return { accepted: false, alreadyPending: true, state: publicState() };
+    }
+    request = {
+      reason: clampText(reason, 140, 'manual-suspend'),
+      requestedBy: clampText(requestedBy, 80, 'localhost-api'),
+      requestedAt: new Date(now()).toISOString(),
+    };
+    everBlocked = false;
+    idleSince = null;
+    fireAt = null;
+    lastError = null;
+    status = 'queued';
+    evaluate();
+    if (status === 'queued' || status === 'countdown') {
+      pollTimer = setIntervalImpl(tick, pollMs);
+      pollTimer?.unref?.();
+    }
+    return { accepted: true, state: publicState() };
+  }
+
+  function cancel({ requestedBy = 'localhost-api' } = {}) {
+    if (status !== 'queued' && status !== 'countdown') {
+      return { cancelled: false, state: publicState() };
+    }
+    try { logger.log?.(`[host-suspend] queued suspend cancelled by ${clampText(requestedBy, 80, 'unknown')}`); } catch {}
+    resetToIdle();
+    emit(true);
+    return { cancelled: true, state: publicState() };
+  }
+
+  function dispose({ reason = 'shutdown' } = {}) {
+    const wasPending = status === 'queued' || status === 'countdown';
+    const state = publicState();
+    resetToIdle();
+    if (wasPending) {
+      try { logger.log?.(`[host-suspend] queued suspend dropped (${reason})`); } catch {}
+      try { onDropped?.(state, reason); } catch {}
+    }
+  }
+
+  return {
+    request: requestSuspend,
+    cancel,
+    getState: publicState,
+    /** Re-run the activity check now (used by the status/GET routes). */
+    refresh() { if (status === 'queued' || status === 'countdown') tick(); return publicState(); },
+    dispose,
+  };
+}

package/server/services/live-turn-picker.mjs

@@ -0,0 +1,47 @@
+// Which of a conversation's processing queue rows is the LIVE turn.
+//
+// Mid-turn steering means a conversation can have more than one row in
+// `processing` at once: the running turn plus a message the user steered in,
+// which the CLI folds into that turn and which produces no stream or activity
+// of its own — or, after a replay handoff, the row that just took the turn
+// over while the handed-off row is still settling. The live turn is the row
+// that produced output MOST RECENTLY; with no output to separate them, the
+// oldest processing row (the turn a steered message joins). Kept pure so the
+// tie-break rules are testable without a DB.
+//
+// Recency, not volume: relay_stream_events.seq is only unique within one
+// queue_message_id, so comparing it across rows picked "the row with the most
+// events" — a long handed-off turn kept the live bubble (and Stop) from the
+// row that had actually taken over.
+
+/**
+ * @param {Array<{id:string, lastOutputAtMs?:number, streamDone?:boolean, processingAtMs?:number}>} rows
+ *   Processing rows for one conversation. `lastOutputAtMs` is when the row
+ *   last wrote a stream snapshot or activity line (0 = never); `streamDone`
+ *   marks a row whose main stream snapshot is final — a handed-off row
+ *   settling, whose closing snapshot re-stamps it as the newest write — and
+ *   ranks it below every row still open; `processingAtMs` is when it entered
+ *   processing (final tie-break; smaller = older = wins).
+ * @returns {string} the live turn's row id, or '' when there are no rows.
+ */
+export function pickLiveTurnRowId(rows = []) {
+  const list = Array.isArray(rows) ? rows.filter((row) => row && row.id) : [];
+  if (!list.length) return '';
+  if (list.length === 1) return String(list[0].id);
+  const finite = (value) => (Number.isFinite(Number(value)) ? Number(value) : 0);
+  let best = null;
+  for (const row of list) {
+    if (!best) { best = row; continue; }
+    if (Boolean(row.streamDone) !== Boolean(best.streamDone)) {
+      if (!row.streamDone) best = row;
+      continue;
+    }
+    const output = finite(row.lastOutputAtMs);
+    const bestOutput = finite(best.lastOutputAtMs);
+    if (output > bestOutput
+      || (output === bestOutput && finite(row.processingAtMs) < finite(best.processingAtMs))) {
+      best = row;
+    }
+  }
+  return String(best.id);
+}

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']);
+export const PUSH_EVENT_TYPES = Object.freeze(['question', 'turnComplete', 'turnFailed', 'board', 'cliOffline', 'hostSuspend']);
 
 export const VAPID_PUBLIC_KEY_SETTING = 'push_vapid_public_key';
 export const VAPID_PRIVATE_KEY_SETTING = 'push_vapid_private_key';
@@ -34,8 +34,13 @@ const EVENT_LABELS = Object.freeze({
   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.' },
 });
 
+// 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']);
+
 function clampInt(value, min, max, fallback) {
   const numeric = Number(value);
   if (!Number.isFinite(numeric)) return fallback;
@@ -90,7 +95,9 @@ export function renderPushNotification(event, preferences) {
   let body = labels.generic;
   const text = String(event?.body || '').trim();
   // cliOffline has no conversation text to preview; the generic body is the message.
-  if (text && type !== 'cliOffline') {
+  if (text && SYSTEM_BODY_TYPES.has(type)) {
+    body = text.slice(0, MAX_FULL_PREVIEW_CHARS);
+  } else if (text && type !== 'cliOffline') {
     if (prefs.content.preview === 'full') {
       body = text.slice(0, MAX_FULL_PREVIEW_CHARS);
     } else if (prefs.content.preview === 'truncated') {
@@ -300,6 +307,23 @@ export function createPushDispatchService({
     } catch {}
   }
 
+  // A turn another relay's agent started (its user message carries `origin`)
+  // pushes no "reply ready" or "failed": that agent is the one waiting for the
+  // reply and reports back to the user itself (decision 22). Question pushes
+  // are unchanged. Prepared lazily: a schema without the column (before
+  // migration 0005) simply means "not an agent's turn".
+  let messageOriginStatement = null;
+  function turnStartedByRemoteAgent(sourceMessageId) {
+    const id = String(sourceMessageId || '').trim();
+    if (!id) return false;
+    try {
+      messageOriginStatement ??= db.prepare(`SELECT origin_json FROM messages WHERE id = ?`);
+      return String(messageOriginStatement.get(id)?.origin_json || '').trim() !== '';
+    } catch {
+      return false;
+    }
+  }
+
   async function sendToSubscription(row, event) {
     const preferences = normalizePushPreferences(parseJsonObject(row.preferences_json));
     const payload = renderPushNotification(event, preferences);
@@ -412,7 +436,10 @@ export function createPushDispatchService({
     });
   }
 
-  function notifyTurnComplete({ conversationId, messageId, text } = {}) {
+  // `messageId` is the reply; `sourceMessageId` the user message that started
+  // the turn.
+  function notifyTurnComplete({ conversationId, messageId, sourceMessageId, text } = {}) {
+    if (turnStartedByRemoteAgent(sourceMessageId)) return Promise.resolve({ outcome: 'remote-agent' });
     return dispatch({
       type: 'turnComplete',
       conversationId: conversationId || null,
@@ -421,7 +448,8 @@ export function createPushDispatchService({
     });
   }
 
-  function notifyTurnFailed({ conversationId, messageId, text } = {}) {
+  function notifyTurnFailed({ conversationId, messageId, sourceMessageId, text } = {}) {
+    if (turnStartedByRemoteAgent(sourceMessageId)) return Promise.resolve({ outcome: 'remote-agent' });
     return dispatch({
       type: 'turnFailed',
       conversationId: conversationId || null,
@@ -443,7 +471,12 @@ export function createPushDispatchService({
     return dispatch({ type: 'cliOffline' });
   }
 
+  function notifyHostSuspend({ body = null } = {}) {
+    return dispatch({ type: 'hostSuspend', body: body || null, data: { hostSuspendAt: Date.now() } });
+  }
+
   return {
+    notifyHostSuspend,
     listDevices,
     getDevice,
     upsertSubscription,

package/server/services/relay-prompt-sanitizer.mjs

@@ -135,6 +135,21 @@ const MEDIA_EMBED_BLOCK_PATTERN = new RegExp(
   'gi',
 );
 
+// A steered message's hidden note (shared/steer-note.mjs) leads the prompt the
+// runtime stored, right after any mode marker. Matched by its stable opening
+// words, because the browser copy of this module cannot import shared/.
+const STEER_NOTE_PATTERN = /^\s*\[Sent while you were still working on my previous message\.[^\]\n]*\]\s*/;
+
+// The Claude worker's slash-command guard (shared/slash-command-guard.mjs): a
+// zero-width space in front of a "/x" it delivers as text. trim() keeps it, so
+// it is matched on its own, and only where it guards a "/".
+const SLASH_COMMAND_GUARD_PATTERN = /^\u200B(?=\s*\/)/;
+
+function stripLeadingRelayNotes(text) {
+  const stripped = String(text || '').replace(STEER_NOTE_PATTERN, '').replace(SLASH_COMMAND_GUARD_PATTERN, '');
+  return stripped.trim() ? stripped.trim() : String(text || '').trim();
+}
+
 export function stripRelayPromptContext(text, relayMode = '', attachments = []) {
   const value = stripAttachmentPromptArtifacts(text)
     .replace(MEDIA_EMBED_BLOCK_PATTERN, '')
@@ -143,7 +158,7 @@ export function stripRelayPromptContext(text, relayMode = '', attachments = [])
   const patterns = buildPromptPrefixPatterns(relayMode);
   for (const pattern of patterns) {
     const stripped = value.replace(pattern, '').trim();
-    if (stripped && stripped !== value) return stripped;
+    if (stripped && stripped !== value) return stripLeadingRelayNotes(stripped);
   }
-  return value;
+  return stripLeadingRelayNotes(value);
 }