@oar-sh/oar 0.9.5 → 0.9.7

package/server/public/app/remote-relay-origin-view.mjs

@@ -3,6 +3,12 @@
 // to the source session) and the "↗ win-test" marker on the sidebar row of a
 // conversation such an agent created. Both read the `origin` the relay stores
 // with the message or conversation (docs/plans/2026-09-27-remote-relays.md §4).
+//
+// An agent on THIS relay can start sessions too. Such an origin carries
+// `local: true` and names the conversation the agent runs in: the marker then
+// reads "via agent · “title”" and opens that conversation inside the app
+// (window.openOriginConversation, journal-view.js) instead of linking to
+// another relay. An origin without `local` renders exactly as before.
 
 import { remoteConversationUrl } from './remote-relay-shared.mjs';
 
@@ -19,6 +25,76 @@ function oneLine(value) {
   return String(value ?? '').replace(/\s+/g, ' ').trim();
 }
 
+// How much of the other conversation's title a marker carries; CSS ellipsis
+// takes over where the row is narrower than that.
+export const ORIGIN_TITLE_MAX_SIDEBAR = 28;
+export const ORIGIN_TITLE_MAX = 60;
+
+/** "a long conversation tit…": at most `max` characters, one line. */
+export function truncateOriginTitle(value, max = ORIGIN_TITLE_MAX) {
+  const text = oneLine(value);
+  const limit = Math.max(2, Math.floor(Number(max)) || ORIGIN_TITLE_MAX);
+  // By code point, so an emoji is never cut in half.
+  const chars = Array.from(text);
+  if (chars.length <= limit) return text;
+  return `${chars.slice(0, limit - 1).join('').trimEnd()}…`;
+}
+
+/** True for the origin of work an agent on this relay started. */
+export function isLocalAgentOrigin(raw) {
+  return !!raw && typeof raw === 'object' && !Array.isArray(raw) && raw.local === true;
+}
+
+function knownConversation(conversations, id) {
+  if (!id || !conversations || typeof conversations !== 'object') return null;
+  const found = Object.prototype.hasOwnProperty.call(conversations, id) ? conversations[id] : null;
+  return found && typeof found === 'object' ? found : null;
+}
+
+/**
+ * What a local origin shows, or null when the origin is not a local one.
+ * `conversations` is the browser's list by id: the marker is a link only while
+ * the orchestrating conversation is in it, and shows that conversation's
+ * current title (the origin stores the one it had at creation). `ownId` is the
+ * conversation the marker sits on, which never links to itself.
+ */
+export function localAgentOriginModel(origin, {
+  conversations = null,
+  ownId = '',
+  linkable = true,
+  maxTitleLength = ORIGIN_TITLE_MAX,
+} = {}) {
+  if (!isLocalAgentOrigin(origin)) return null;
+  const conversationId = oneLine(origin.conversationId);
+  const known = conversationId !== oneLine(ownId) ? knownConversation(conversations, conversationId) : null;
+  const fullTitle = oneLine(known?.title) || oneLine(origin.conversationTitle);
+  const title = truncateOriginTitle(fullTitle, maxTitleLength);
+  return {
+    conversationId,
+    fullTitle,
+    title,
+    model: oneLine(origin.model),
+    text: title ? `via agent · “${title}”` : 'via agent',
+    linkable: linkable !== false && !!known,
+  };
+}
+
+// A button while the orchestrating conversation can be opened, plain text
+// otherwise. `tooltip` is a full sentence.
+function localAgentElementHtml(model, { className, text = model.text, tooltip }) {
+  const label = escapeHtml(text);
+  if (model.linkable) {
+    return `<button type="button" class="${className}" data-origin-conversation-id="${escapeHtml(model.conversationId)}" title="${escapeHtml(`${tooltip} Opens that conversation.`)}" onclick="openOriginConversation(event, this)">${label}</button>`;
+  }
+  return `<span class="${className}" title="${escapeHtml(tooltip)}">${label}</span>`;
+}
+
+function startedByTooltip(model) {
+  return model.fullTitle
+    ? `Started by an agent in “${model.fullTitle}”.`
+    : 'Started by an agent in another conversation on this relay.';
+}
+
 /** The display fields of an `origin`, or null when it names no relay. */
 export function normalizeRemoteOrigin(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
@@ -35,7 +111,9 @@ export function normalizeRemoteOrigin(raw) {
   };
 }
 
-export function remoteOriginBadgeText(origin) {
+export function remoteOriginBadgeText(origin, options = {}) {
+  const local = localAgentOriginModel(origin, options);
+  if (local) return local.model ? `${local.text} · ${local.model}` : local.text;
   const normalized = normalizeRemoteOrigin(origin);
   if (!normalized) return '';
   const parts = [`↗ from ${normalized.relayName}`];
@@ -54,8 +132,21 @@ export function remoteOriginLink(origin) {
 /**
  * The badge row that sits above a user bubble's text. `linkable: false` (the
  * shared read-only view) renders it without the link to the other relay.
+ * `conversations` (the browser's list by id) lets a local agent's badge open
+ * the conversation that agent runs in.
  */
-export function renderRemoteOriginBadgeHtml(origin, { linkable = true } = {}) {
+export function renderRemoteOriginBadgeHtml(origin, { linkable = true, conversations = null } = {}) {
+  const local = localAgentOriginModel(origin, { conversations, linkable });
+  if (local) {
+    const badge = localAgentElementHtml(local, {
+      className: 'msg-origin-badge msg-origin-agent',
+      text: remoteOriginBadgeText(origin, { conversations }),
+      tooltip: local.fullTitle
+        ? `Sent by an agent in “${local.fullTitle}”.`
+        : 'Sent by an agent in another conversation on this relay.',
+    });
+    return `<div class="msg-origin">${badge}</div>`;
+  }
   const normalized = normalizeRemoteOrigin(origin);
   if (!normalized) return '';
   const label = escapeHtml(remoteOriginBadgeText(normalized));
@@ -67,10 +158,35 @@ export function renderRemoteOriginBadgeHtml(origin, { linkable = true } = {}) {
   return `<div class="msg-origin"><span class="msg-origin-badge" title="Sent by an agent on relay ${name}.">${label}</span></div>`;
 }
 
-/** The sidebar marker for a conversation another relay's agent created. */
-export function renderConversationOriginMarkerHtml(conversation) {
+/**
+ * The sidebar marker for a conversation an agent created: "↗ win-test" for
+ * another relay's agent, "via agent · “title”" for one on this relay.
+ */
+export function renderConversationOriginMarkerHtml(conversation, { conversations = null, linkable = true } = {}) {
+  const local = localAgentOriginModel(conversation?.origin, {
+    conversations,
+    linkable,
+    ownId: conversation?.id,
+    maxTitleLength: ORIGIN_TITLE_MAX_SIDEBAR,
+  });
+  if (local) {
+    return localAgentElementHtml(local, {
+      className: 'conv-origin-marker conv-origin-agent',
+      tooltip: startedByTooltip(local),
+    });
+  }
   const normalized = normalizeRemoteOrigin(conversation?.origin);
   if (!normalized) return '';
   const name = escapeHtml(normalized.relayName);
   return `<span class="conv-origin-marker" title="Started by an agent on relay ${name}">↗ ${name}</span>`;
 }
+
+/**
+ * The same marker for the conversation header, with room for more of the
+ * title. Only a local origin has one; '' for everything else.
+ */
+export function renderConversationHeaderOriginHtml(conversation, { conversations = null, linkable = true } = {}) {
+  const local = localAgentOriginModel(conversation?.origin, { conversations, linkable, ownId: conversation?.id });
+  if (!local) return '';
+  return localAgentElementHtml(local, { className: 'conv-origin-agent', tooltip: startedByTooltip(local) });
+}

package/server/public/app/router.js

@@ -6,6 +6,7 @@ import {
   WORKSPACE_FILE_EXTENSIONS,
   serverPlatform,
 } from './store.js';
+import { scanInlineDollars, splitAtLiteralDollars } from './math-dollars.mjs';
 
 export function workspaceMentionRegex() {
   return /(?:[A-Za-z]:[\\/])?(?:\.{1,2}[\\/])?(?:[A-Za-z0-9._-]+[\\/])*[A-Za-z0-9._-]+\.[A-Za-z0-9]{1,16}/g;
@@ -397,7 +398,8 @@ function normalizeInlineMathDelimiters(line) {
   let output = '';
   let index = 0;
   let inCode = false;
-  let inDollarMath = false;
+  // Only real dollar maths is skipped over; a price's `$` opens nothing.
+  const dollarMathEnds = new Map(scanInlineDollars(line).spans);
 
   while (index < line.length) {
     const char = line[index];
@@ -412,15 +414,10 @@ function normalizeInlineMathDelimiters(line) {
       index += 1;
       continue;
     }
-    if (char === '$' && line[index - 1] !== '\\') {
-      inDollarMath = !inDollarMath;
-      output += char;
-      index += 1;
-      continue;
-    }
-    if (inDollarMath) {
-      output += char;
-      index += 1;
+    if (char === '$' && dollarMathEnds.has(index)) {
+      const closeIndex = dollarMathEnds.get(index);
+      output += line.slice(index, closeIndex + 1);
+      index = closeIndex + 1;
       continue;
     }
     if (char === '\\' && line[index + 1] === '(') {
@@ -469,6 +466,7 @@ function protectMarkdownEscapesInMath(source) {
     let output = '';
     let index = 0;
     let inCode = false;
+    const dollarMathEnds = new Map(scanInlineDollars(line).spans);
     while (index < line.length) {
       if (line[index] === '`') {
         inCode = !inCode;
@@ -482,7 +480,10 @@ function protectMarkdownEscapesInMath(source) {
         continue;
       }
       const delimiter = line[index + 1] === '$' ? '$$' : '$';
-      const closeIndex = line.indexOf(delimiter, index + delimiter.length);
+      // A single `$` that is a plain dollar sign (a price) opens no formula.
+      const closeIndex = delimiter === '$'
+        ? (dollarMathEnds.has(index) ? dollarMathEnds.get(index) : -1)
+        : line.indexOf(delimiter, index + delimiter.length);
       if (closeIndex < 0) {
         output += line[index];
         index += 1;
@@ -550,6 +551,40 @@ export function normalizeMathDelimiters(source) {
   return protectMarkdownEscapesInMath(normalized.join('\n'));
 }
 
+const MATH_IGNORED_TAGS = ['pre', 'code', 'script', 'style', 'textarea', 'option', 'a'];
+const LITERAL_DOLLAR_CLASS = 'literal-dollar';
+
+/**
+ * KaTeX's auto-render pairs any two `$` in a block, so "$5 … $9" would become
+ * one formula. Each plain dollar sign (see math-dollars.mjs) is moved into a
+ * span of its own that auto-render skips; with no partner in its text node,
+ * it stays a dollar sign.
+ */
+function isolateLiteralDollars(container) {
+  const ignored = MATH_IGNORED_TAGS.join(',');
+  const walker = document.createTreeWalker(container, 4 /* NodeFilter.SHOW_TEXT */);
+  const textNodes = [];
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    if (node.nodeValue.includes('$') && !node.parentElement?.closest(ignored)) textNodes.push(node);
+  }
+  for (const node of textNodes) {
+    const parts = splitAtLiteralDollars(node.nodeValue);
+    if (!parts.some((part) => part.literal)) continue;
+    const fragment = document.createDocumentFragment();
+    for (const part of parts) {
+      if (!part.literal) {
+        fragment.appendChild(document.createTextNode(part.text));
+        continue;
+      }
+      const span = document.createElement('span');
+      span.className = LITERAL_DOLLAR_CLASS;
+      span.textContent = part.text;
+      fragment.appendChild(span);
+    }
+    node.parentNode.replaceChild(fragment, node);
+  }
+}
+
 function renderMathInHtml(html) {
   const renderMathInElement = globalThis.renderMathInElement;
   if (typeof renderMathInElement !== 'function' || !globalThis.document?.createElement) return html;
@@ -557,6 +592,7 @@ function renderMathInHtml(html) {
   const container = document.createElement('div');
   container.innerHTML = html;
   try {
+    isolateLiteralDollars(container);
     renderMathInElement(container, {
       delimiters: [
         { left: '$$', right: '$$', display: true },
@@ -564,7 +600,8 @@ function renderMathInHtml(html) {
         { left: '\\(', right: '\\)', display: false },
         { left: '$', right: '$', display: false },
       ],
-      ignoredTags: ['pre', 'code', 'script', 'style', 'textarea', 'option', 'a'],
+      ignoredTags: MATH_IGNORED_TAGS,
+      ignoredClasses: [LITERAL_DOLLAR_CLASS],
       throwOnError: false,
       strict: 'ignore',
       trust: false,

package/server/public/app/settings-modal.js

@@ -41,9 +41,11 @@ import { refreshPushSettingsSection } from './push-settings.js';
 import { selectSettingsTab } from './settings-tabs.js';
 import { refreshClaudeAuthSection } from './claude-auth-ui.js';
 import { refreshGrokAuthSection } from './grok-auth-ui.js';
+import { openClaudeCloudSettingsSection } from './claude-cloud-settings-ui.js';
 import { refreshCliInstallSections } from './cli-install-ui.js';
 import { refreshUpdateSection } from './update-ui.js';
 import { refreshRemoteRelaysSection } from './remote-relays-settings.js';
+import { refreshAgentSessionsSection } from './agent-sessions-settings-ui.js';
 import {
   getPreviews,
   renderPreviewRowsInto,
@@ -437,7 +439,7 @@ function ensureClaudeSettingsInputTracking() {
 }
 
 function setClaudeSettingsControlsDisabled(disabled) {
-  for (const id of ['claude-model-input', 'claude-enabled-toggle', 'claude-save-btn']) {
+  for (const id of ['claude-model-input', 'claude-enabled-toggle', 'claude-attribution-select', 'claude-save-btn']) {
     const element = document.getElementById(id);
     if (element) element.disabled = disabled;
   }
@@ -450,10 +452,15 @@ export function applyClaudeSettingsState(settings = {}, { resetInputs = false }
     enabled: settings?.enabled === true,
     model: String(settings?.model || claudeSettingsState.model || 'claude-sonnet-5').trim() || 'claude-sonnet-5',
     models: Array.isArray(settings?.models) ? settings.models : claudeSettingsState.models,
+    attributionMode: ['oar', 'vanilla', 'off'].includes(settings?.attributionMode) ? settings.attributionMode : (claudeSettingsState.attributionMode || 'oar'),
+    attributionExample: String(settings?.attributionExample || claudeSettingsState.attributionExample || '').trim(),
   };
   const modelInput = document.getElementById('claude-model-input');
   const toggle = document.getElementById('claude-enabled-toggle');
   const status = document.getElementById('claude-settings-status');
+  const attributionSelect = document.getElementById('claude-attribution-select');
+  if (attributionSelect && (!claudeSettingsInputsDirty || resetInputs)) attributionSelect.value = claudeSettingsState.attributionMode;
+  renderClaudeAttributionExample(attributionSelect?.value || claudeSettingsState.attributionMode);
   if (modelInput && (!claudeSettingsInputsDirty || resetInputs)) modelInput.value = claudeSettingsState.model;
   if (resetInputs) claudeSettingsInputsDirty = false;
   if (toggle) {
@@ -486,14 +493,36 @@ async function syncClaudeSettingsInputs() {
   }
 }
 
+// What commits will carry for the chosen mode: the example trailer the relay
+// rendered for the default model, Claude Code's own line, or nothing.
+export function claudeAttributionExampleText(mode, example = '') {
+  if (mode === 'vanilla') return 'Commits keep Claude Code\'s own attribution (Co-Authored-By: Claude … <noreply@anthropic.com>).';
+  if (mode === 'off') return 'Commits and pull requests carry no attribution line.';
+  const trailer = String(example || '').trim();
+  return trailer ? `Commits end with: ${trailer}` : 'Commits end with: Co-authored-by: Open Agent Relay (<model>) <no-reply@oar.sh>';
+}
+
+function renderClaudeAttributionExample(mode) {
+  const example = document.getElementById('claude-attribution-example');
+  if (!example) return;
+  example.textContent = claudeAttributionExampleText(mode, claudeSettingsState.attributionExample);
+}
+
+window.previewClaudeAttribution = (mode) => {
+  claudeSettingsInputsDirty = true;
+  renderClaudeAttributionExample(mode);
+};
+
 export async function saveClaudeSettings() {
   if (claudeSettingsUpdateInFlight) return;
   const modelInput = document.getElementById('claude-model-input');
   const model = String(modelInput?.value || '').trim() || 'claude-sonnet-5';
+  const attributionSelect = document.getElementById('claude-attribution-select');
+  const attributionMode = ['oar', 'vanilla', 'off'].includes(attributionSelect?.value) ? attributionSelect.value : undefined;
   claudeSettingsUpdateInFlight = true;
   setClaudeSettingsControlsDisabled(true);
   try {
-    const result = await updateClaudeSettings({ model });
+    const result = await updateClaudeSettings({ model, attributionMode });
     if (!result) throw new Error('Failed to save Claude settings.');
     applyClaudeSettingsState(result, { resetInputs: true });
     showTransientRelayNotice(
@@ -1655,6 +1684,7 @@ export function openSettingsModal(tab, providerTab) {
   ensureClaudeSettingsInputTracking();
   void syncClaudeSettingsInputs();
   void refreshClaudeAuthSection();
+  void openClaudeCloudSettingsSection();
   void refreshGrokAuthSection();
   // Forced: the cached rows can be 30s stale, and a CLI installed from a shell
   // in the meantime should show up the moment the panel opens. Sockets keep it
@@ -1678,6 +1708,7 @@ export function openSettingsModal(tab, providerTab) {
   void refreshPushSettingsSection();
   void refreshPreviewsSection();
   void refreshRemoteRelaysSection();
+  void refreshAgentSessionsSection();
   void refreshFeatureFlagsSection();
   void refreshUpdateSection();
   modal?.classList.add('visible');

package/server/public/app/settings-tabs.js

@@ -4,7 +4,7 @@ const SETTINGS_PROVIDER_TAB_STORAGE_KEY = 'copilot_settings_provider_tab';
 const SETTINGS_TABS = ['general', 'providers', 'relays', 'previews', 'notifications', 'features'];
 // Copilot leads: it is the default provider, and `SETTINGS_PROVIDER_TABS[0]`
 // is also the sub-tab a first-time visitor lands on.
-const SETTINGS_PROVIDER_TABS = ['copilot', 'openai', 'claude', 'grok', 'cursor'];
+const SETTINGS_PROVIDER_TABS = ['copilot', 'openai', 'claude', 'claude-cloud', 'grok', 'cursor'];
 
 let settingsTabsBound = false;
 

package/server/public/app/socket-handlers.js

@@ -30,6 +30,8 @@ import {
   setConversationWatcherCount,
   setUpdateState,
   applySessionWorkerSteering,
+  refreshSummaryModal,
+  summaryModalState,
 } from './store.js';
 import { scheduleContextUsageRefresh } from './api-client.js';
 import { publishStatusEvent, recordStatusEvent } from './status-store.mjs';
@@ -44,11 +46,16 @@ import { setConversationBackgroundTasks } from './background-tasks-view.mjs';
 import { setPreviews } from './preview-cards.mjs';
 import { setRemoteRelaysSnapshot } from './remote-relays-store.mjs';
 import { REMOTE_RELAY_SOCKET_EVENT } from './remote-relay-shared.mjs';
+import { AGENT_SESSIONS_SOCKET_EVENT } from './agent-sessions-settings.mjs';
+import { applyAgentSessionsSettingsState, refreshAgentSessionsSection } from './agent-sessions-settings-ui.js';
 import { applyClaudeAuthState } from './claude-auth-ui.js';
 import { applyGrokAuthState } from './grok-auth-ui.js';
+import { applyClaudeCloudSettingsState, refreshClaudeCloudSettingsState } from './claude-cloud-settings-ui.js';
+import { applyClaudeCloudSessionEvent } from './claude-cloud-conversation-ui.js';
 import { applyCliInstallState } from './cli-install-ui.js';
 import { renderUpdateSection } from './update-ui.js';
 import { applyHostSuspendState, applyRelayShutdownState } from './host-suspend-ui.js';
+import { applyClaudeUsageLimit, applyUsageLimitPause } from './usage-limit-ui.js';
 import {
   showThinking,
   removeThinking,
@@ -64,6 +71,7 @@ import {
   applyConversationTurnStatus,
   renderMessages,
   appendMessage,
+  replaceRenderedMessage,
   applyIncomingConversationDraftUpdate,
   getRenderedConversationMessageFingerprints,
   clearBubbleCancelState,
@@ -399,6 +407,26 @@ export async function connectSocket(overrideDeps) {
   socket.on('relay_shutdown_state', (payload) => {
     applyRelayShutdownState(payload || null);
   });
+  // The Claude usage limit: a conversation's paused turn, and the account's
+  // latest report (also sent on connect).
+  socket.on('usage_limit_pause', (payload) => {
+    applyUsageLimitPause(payload || null);
+  });
+  socket.on('claude_usage_limit', (payload) => {
+    applyClaudeUsageLimit(payload || null);
+  });
+  // Claude Cloud settings (enable, default model, environment). The event
+  // carries the same shape as GET /api/settings/claude-cloud; one without a
+  // body is read as "something changed" and answered with a fresh read.
+  socket.on('claude_cloud_settings_updated', (payload) => {
+    if (payload && typeof payload === 'object') applyClaudeCloudSettingsState(payload);
+    else void refreshClaudeCloudSettingsState();
+  });
+  // A cloud session got its id, pushed a branch or reported a new cost: the
+  // conversation's `cloud` field changed, and with it the cloud line.
+  socket.on('claude_cloud_session', (payload) => {
+    if (applyClaudeCloudSessionEvent(payload || null)) deps?.syncChatTitleControls?.();
+  });
   socket.on('grok_settings_updated', (payload) => {
     deps?.applyGrokSettingsState?.(payload || {});
     if (Number(payload?.reconciliation?.updatedUnstartedConversations || 0) > 0) {
@@ -489,6 +517,20 @@ export async function connectSocket(overrideDeps) {
     if (sourceMessageId) clearRelayStreamStateForMessage(sourceMessageId);
     refreshSessionWorkerStatus().catch(() => {});
   });
+  // A folder's commit attribution changed (any client): an open context modal
+  // re-reads it so its row and effect text match.
+  socket.on('workspace_root_attribution_updated', () => {
+    if (summaryModalState.kind === 'context') refreshSummaryModal().catch(() => {});
+  });
+  // A message the relay rewrote in place (the note while a session's worker
+  // cannot be started): same id, new text or kind. Not on the page yet (the
+  // conversation was opened after it was written): appended like any other.
+  socket.on('message_updated', ({ conversationId, messageId, message }) => {
+    if (!messageId || conversationId !== currentConvId || !message) return;
+    if (!replaceRenderedMessage(message, messageId)) {
+      appendMessage(message, isMessagesAtBottom(), messageId, false);
+    }
+  });
   socket.on('relay_question', ({ question }) => upsertRelayQuestion(question));
   socket.on('relay_question_updated', ({ question }) => upsertRelayQuestion(question));
   socket.on('relay_question_changed', () => {
@@ -512,6 +554,13 @@ export async function connectSocket(overrideDeps) {
   socket.on(REMOTE_RELAY_SOCKET_EVENT, (payload) => {
     setRemoteRelaysSnapshot(payload || null);
   });
+  // Agent sessions (Settings → Relays): the event carries the same shape as
+  // GET /api/settings/agent-sessions; one without a body is answered with a
+  // fresh read.
+  socket.on(AGENT_SESSIONS_SOCKET_EVENT, (payload) => {
+    if (payload && typeof payload === 'object') applyAgentSessionsSettingsState(payload);
+    else void refreshAgentSessionsSection();
+  });
   socket.on('relay_activity', ({ conversationId, messageId, text, subagentRunId, metadata }) => {
     if (!messageId || !text) return;
     const entry = {
@@ -728,6 +777,17 @@ export async function connectSocket(overrideDeps) {
     }
     renderConvList();
   });
+  socket.on('conversation_archived', ({ conversationId, archived }) => {
+    const id = String(conversationId || '').trim();
+    if (!id) return;
+    const conversation = conversations[id];
+    if (conversation) conversation.archived = archived !== false;
+    renderConvList();
+    if (currentConvId === id) {
+      syncChatTitleControls();
+      syncComposerButtonState();
+    }
+  });
   socket.on('conversation_deleted', ({ conversationId }) => {
     delete conversations[conversationId];
     for (const [id, question] of relayQuestions.entries()) {

package/server/public/app/store.js

@@ -3,6 +3,8 @@ import { recordCliLifecycleEvent, recordRelayLifecycleEvent } from './status-sto
 import { resolveRelayDotState } from './relay-dot-state.mjs';
 import { readRepoBrowserPreferences } from './repo-browser-preferences.mjs';
 import { isChatInteractionHeld } from './selection-guard.mjs';
+import { nextSubagentStatus } from './subagent-fold.mjs';
+import { useStrictStrikethrough } from './markdown-strikethrough.mjs';
 
 function resolveAppBase() {
   const configuredBase = typeof window.__COPILOT_APP_CONFIG?.basePath === 'string'
@@ -173,6 +175,7 @@ const CONVERSATION_SCROLL_STORAGE_PREFIX = 'copilot_message_scroll_';
 
 if (globalThis.marked && typeof globalThis.marked.setOptions === 'function') {
   globalThis.marked.setOptions({ breaks: true });
+  useStrictStrikethrough(globalThis.marked);
 } else {
   console.warn('[store] marked unavailable; markdown rendering will use plain-text fallback.');
 }
@@ -1475,7 +1478,7 @@ export function upsertSubagentRun(payload) {
     conversationId: String(payload?.conversationId || existing?.conversationId || '').trim() || null,
     parentSubagentId: normalizeSubagentRunId(payload?.parentSubagentId) || existing?.parentSubagentId || null,
     displayName: String(payload?.displayName || existing?.displayName || '').trim() || null,
-    status: normalizeSubagentStatus(payload?.status) || existing?.status || 'running',
+    status: nextSubagentStatus({ reported: payload?.status, known: existing?.status, normalize: normalizeSubagentStatus }),
     startedAt: existing?.startedAt || payload?.timestamp || now,
     updatedAt: payload?.timestamp || now,
     activities: existing?.activities || [],

package/server/public/app/subagent-fold.mjs

@@ -0,0 +1,61 @@
+// Whether a live subagent bubble is shown folded (header only), and what the
+// header says while it is.
+//
+// A running turn can hold many subagents, and each keeps its whole transcript
+// in its bubble: on a phone that is screens of text to scroll past to reach
+// the turn's own output. So a bubble is folded from the start and stays folded
+// until the user opens it; what they chose by hand holds, in either direction,
+// for as long as the bubble lives. The folded header makes up for it with one
+// line: how many steps the run has taken and the latest one.
+
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'dropped', 'done']);
+
+export function isTerminalSubagentStatus(status) {
+  return TERMINAL_STATUSES.has(String(status || '').trim().toLowerCase());
+}
+
+/**
+ * `choice` is the user's own: 'open', 'folded', or nothing.
+ */
+export function resolveSubagentFold({ choice = null } = {}) {
+  return choice !== 'open';
+}
+
+/** The choice a tap on the header records, given what the bubble shows now. */
+export function toggledSubagentFoldChoice(folded) {
+  return folded ? 'open' : 'folded';
+}
+
+const SUMMARY_MAX_CHARS = 160;
+
+function oneLine(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * The line a folded header shows: the number of steps (activity lines) and
+ * the latest one, or the end of what the run has written when it has taken
+ * no step yet. Empty when there is nothing to say.
+ */
+export function subagentFoldSummary({ activities = [], streamText = '' } = {}) {
+  const steps = (Array.isArray(activities) ? activities : []).map(oneLine).filter(Boolean);
+  if (steps.length) {
+    const latest = steps[steps.length - 1];
+    const count = steps.length === 1 ? '1 step' : `${steps.length} steps`;
+    return `${count} · ${latest}`.slice(0, SUMMARY_MAX_CHARS);
+  }
+  const lines = String(streamText || '').split(/\r?\n/).map(oneLine).filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, SUMMARY_MAX_CHARS) : '';
+}
+
+/**
+ * The status a run has after an update. Most updates report none (an
+ * activity line, a stream frame, a restored snapshot's activity list), and
+ * those must leave the status alone: reading "no status" as "running" turned
+ * every finished run back into a running one on the next line of any kind.
+ */
+export function nextSubagentStatus({ reported, known, normalize = (value) => value } = {}) {
+  const text = String(reported || '').trim();
+  if (text) return normalize(text);
+  return String(known || '').trim() || 'running';
+}