mixdog 0.9.66 → 0.9.68

package/src/tui/app/channel-pickers.mjs

@@ -215,165 +215,8 @@ export function createChannelPickers({
       setChannelPrompt(prompt);
     };
 
-    const channelRemoteEnabled = store.isRemoteEnabled?.() === true;
-
-    if (focus === 'schedules') {
-      const schedules = setup.schedules || [];
-      const items = [
-        ...(schedules.length ? schedules.map((schedule) => {
-        const enabled = schedule.enabled !== false;
-        return {
-          value: `schedule:${schedule.name}`,
-          label: schedule.name,
-          marker: enabled ? '●' : '○',
-          markerColor: channelRemoteEnabled ? (enabled ? theme.success : theme.inactive) : theme.inactive,
-          description: `${schedule.time || '(no cron)'} · ${schedule.route}${schedule.model ? ` · ${schedule.model}` : ''}${channelRemoteEnabled ? '' : ' · channel off'}`,
-          _action: 'schedule-toggle',
-          _name: schedule.name,
-          _enabled: enabled,
-        };
-      }) : [{
-          value: 'empty',
-          label: 'No schedules',
-          description: 'no schedules configured',
-          _action: 'noop',
-        }]),
-      ];
-      const toggleSchedule = async (item) => {
-        if (item._action !== 'schedule-toggle') return;
-        if (!channelRemoteEnabled) {
-          store.pushNotice('enable channel first', 'warn');
-          return;
-        }
-        try {
-          await store.setScheduleEnabled?.(item._name, !item._enabled);
-          void openChannelSetupPicker('schedules', { highlightValue: `schedule:${item._name}` });
-        } catch (e) {
-          store.pushNotice(`schedule toggle failed: ${e?.message || e}`, 'error');
-        }
-      };
-      setPicker({
-        title: 'Schedules',
-        description: channelRemoteEnabled ? 'Enable or disable cron schedules.' : 'Enable channel to toggle schedules.',
-        initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
-        items,
-        onSelect: (_value, item) => toggleSchedule(item),
-        onLeft: (item) => toggleSchedule(item),
-        onRight: (item) => toggleSchedule(item),
-        onCancel: () => {
-          setPicker(null);
-        },
-      });
-      return;
-    }
-
-    if (focus === 'webhook-endpoint') {
-      const returnTo = typeof options.returnTo === 'function'
-        ? options.returnTo
-        : () => setPicker(null);
-      const domain = setup.webhook?.ngrokDomain || setup.webhook?.domain || '';
-      const items = [
-        {
-          value: 'endpoint-domain',
-          label: 'ngrok domain',
-          description: domain ? domain : 'Not set · Enter ngrok domain',
-          _action: 'endpoint-domain',
-        },
-        {
-          value: 'endpoint-authtoken',
-          label: 'authtoken',
-          description: setup.webhook?.authenticated === true ? 'Set' : 'Not set · Enter authtoken',
-          _action: 'endpoint-authtoken',
-        },
-      ];
-      setPicker({
-        title: 'Webhook endpoint',
-        description: 'ngrok domain and authtoken. Toggle individual webhooks in /webhooks.',
-        help: '↑/↓ Select · Enter Edit · Esc Back',
-        indexMode: 'always',
-        labelWidth: 18,
-        items,
-        onSelect: (_value, item) => {
-          try {
-            if (item._action === 'endpoint-domain') {
-              openChannelPrompt({
-                kind: 'webhook-domain',
-                label: 'ngrok domain',
-                hint: 'Paste the reserved ngrok domain (e.g. my-app.ngrok-free.app).',
-                afterSave: () => void openChannelSetupPicker('webhook-endpoint', options),
-              });
-              return;
-            }
-            if (item._action === 'endpoint-authtoken') {
-              openChannelPrompt({
-                kind: 'webhook-token',
-                label: 'Webhook/ngrok authtoken',
-                hint: 'Paste the webhook/ngrok authtoken. It is stored in the OS keychain.',
-                afterSave: () => void openChannelSetupPicker('webhook-endpoint', options),
-              });
-            }
-          } catch (e) {
-            store.pushNotice(`webhook endpoint failed: ${e?.message || e}`, 'error');
-          }
-        },
-        onCancel: () => {
-          setPicker(null);
-          returnTo();
-        },
-      });
-      return;
-    }
-
-    if (focus === 'webhooks') {
-      const hooks = setup.webhooks || [];
-      const items = [
-        ...(hooks.length ? hooks.map((hook) => {
-          const enabled = hook.enabled !== false;
-          return {
-            value: `webhook:${hook.name}`,
-            label: hook.name,
-            marker: enabled ? '●' : '○',
-            markerColor: channelRemoteEnabled ? (enabled ? theme.success : theme.inactive) : theme.inactive,
-            description: `${hook.parser || 'github'} · ${hook.route} · secret:${hook.secretSet ? 'set' : 'missing'}${channelRemoteEnabled ? '' : ' · channel off'}`,
-            _action: 'webhook-toggle',
-            _name: hook.name,
-            _enabled: enabled,
-          };
-        }) : [{
-          value: 'empty',
-          label: 'No webhooks',
-          description: 'no webhook endpoints configured',
-          _action: 'noop',
-        }]),
-      ];
-      const toggleWebhook = async (item) => {
-        if (item._action !== 'webhook-toggle') return;
-        if (!channelRemoteEnabled) {
-          store.pushNotice('enable channel first', 'warn');
-          return;
-        }
-        try {
-          await store.setWebhookEnabled?.(item._name, !item._enabled);
-          void openChannelSetupPicker('webhooks', { highlightValue: `webhook:${item._name}` });
-        } catch (e) {
-          store.pushNotice(`webhook toggle failed: ${e?.message || e}`, 'error');
-        }
-      };
-      setPicker({
-        title: 'Webhooks',
-        description: channelRemoteEnabled ? 'Enable or disable inbound webhook endpoints.' : 'Enable channel to toggle webhooks.',
-        initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
-        items,
-        onSelect: (_value, item) => toggleWebhook(item),
-        onLeft: (item) => toggleWebhook(item),
-        onRight: (item) => toggleWebhook(item),
-        onCancel: () => {
-          setPicker(null);
-        },
-      });
-      return;
-    }
-
+    // Schedules/webhooks management is desktop-only (user decision): the TUI
+    // no longer carries their pickers or the webhook-endpoint info page.
     const worker = store.getChannelWorkerStatus?.();
     const activeBackend = setup.backend === 'telegram' ? 'telegram' : 'discord';
     const backendLabel = activeBackend === 'telegram' ? 'Telegram' : 'Discord';
@@ -465,20 +308,12 @@ export function createChannelPickers({
       {
         value: 'webhook-endpoint',
         label: 'Webhook endpoint',
-        meta: (() => {
-          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
-          const hasAuth = setup.webhook?.authenticated === true;
-          return (hasDomain && hasAuth) ? 'On' : 'Off';
-        })(),
-        description: (() => {
-          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
-          const hasAuth = setup.webhook?.authenticated === true;
-          const needs = [
-            ...(hasDomain ? [] : ['domain']),
-            ...(hasAuth ? [] : ['authtoken']),
-          ];
-          return needs.length ? `Needs ${needs.join(' + ')}` : 'ngrok domain and authtoken set';
-        })(),
+        // Relay tunnel: public exposure is automatic, so the endpoint is
+        // "On" whenever the webhook server itself is enabled.
+        meta: setup.webhook?.enabled === false ? 'Off' : 'On',
+        description: setup.webhook?.publicUrl
+          ? setup.webhook.publicUrl
+          : 'Mixdog relay tunnel — URL assigned on first run',
         _action: 'webhook-endpoint',
       },
     ];

package/src/tui/app/doctor.mjs

@@ -165,7 +165,6 @@ export async function buildDoctorReport(runtime = {}, getState = () => ({})) {
     const tokens = [];
     if (setup.discord?.authenticated) tokens.push('discord');
     if (setup.telegram?.authenticated) tokens.push('telegram');
-    if (setup.webhook?.authenticated) tokens.push('webhook');
     const running = worker.running === true;
     const detail = `enabled · worker ${running ? 'running' : 'stopped'} · tokens: ${tokens.length ? tokens.join(', ') : 'none'}`;
     row(running ? 'ok' : 'warn', detail);

package/src/tui/app/slash-commands.mjs

@@ -25,10 +25,8 @@ export const SLASH_COMMANDS = [
   { name: 'plugins', usage: '/plugins', description: 'Manage local plugin integrations' },
   { name: 'hooks', usage: '/hooks', description: 'Manage before-tool hook rules and events' },
   { name: 'providers', usage: '/providers', description: 'Manage auth, API keys, OAuth, and local endpoints' },
-  { name: 'channels', usage: '/channels', description: 'Manage Discord, channels, schedules, webhooks' },
+  { name: 'channels', usage: '/channels', description: 'Manage Discord, Telegram, and voice' },
   { name: 'remote', usage: '/remote', description: 'Claim remote for this session (takes over from any other session)' },
-  { name: 'schedules', usage: '/schedules', description: 'Manage schedules' },
-  { name: 'webhooks', usage: '/webhooks', description: 'Manage inbound webhooks' },
   { name: 'settings', usage: '/setting', aliases: ['setting', 'config'], aliasUsage: ['settings', 'config'], showAliasUsage: false, description: 'Open runtime settings' },
   { name: 'profile', usage: '/profile', description: 'Set your title and response language' },
   { name: 'update', usage: '/update', description: 'Check version and update mixdog' },

package/src/tui/app/slash-dispatch.mjs

@@ -265,10 +265,10 @@ export function createSlashDispatch({
         void openChannelSetupPicker('all');
         return true;
       case 'schedules':
-        void openChannelSetupPicker('schedules');
-        return true;
       case 'webhooks':
-        void openChannelSetupPicker('webhooks');
+        // Management surface is desktop-only (user decision): hidden from the
+        // palette, and a typed command answers instead of opening a picker.
+        store.pushNotice('Schedules and webhooks are managed in the Mixdog desktop app', 'info');
         return true;
       case 'auth':
         store.pushNotice('/auth moved to /providers', 'info');

package/src/tui/components/ToolExecution.jsx

@@ -18,13 +18,9 @@ import { BULLET_OPERATOR } from '../figures.mjs';
 import {
   displayToolName as surfaceDisplayToolName,
   formatToolSurface,
-  summarizeToolResult as surfaceSummarizeToolResult,
   formatAggregateHeader,
-  formatToolActionHeader,
-  summarizeAgentSurfaceBrief,
-  AGENT_SURFACE_BRIEF_MAX,
 } from '../../runtime/shared/tool-surface.mjs';
-import { isBackgroundErrorOnlyBody, backgroundTaskFailureStatusLabel } from '../../runtime/shared/err-text.mjs';
+import { deriveToolCardModel } from '../../runtime/shared/tool-card-model.mjs';
 import {
   MIN_RESULT_LINE_CHARS,
   RESULT_LINE_HARD_MAX,
@@ -33,36 +29,13 @@ import {
   safeInlineText,
   normalizeCountMap,
   truncateToWidth,
-  shellResultElapsed,
-  normalizeTerminalStatus,
   resultTerminalStatus,
   stripLeadingStatusMarkerLines,
   stripLeadingStatusMarkerFromText,
 } from './tool-execution/text-format.mjs';
 import {
   SKILL_SURFACE_NAMES,
-  isShellTool,
-  shellDisplayStatus,
-  shellHeader,
   isAgentTool,
-  isBackgroundTaskTool,
-  agentResponseTitle,
-  agentActionTitle,
-  agentActionSummary,
-  hasAgentResponseResult,
-  resolveBackgroundTaskMeta,
-  backgroundTaskElapsed,
-  prefixElapsed,
-  mergeTerminalDetail,
-  shouldPrefixSyncElapsed,
-  backgroundTaskResultTitle,
-  backgroundTaskActionTitle,
-  backgroundTaskFailureDetail,
-  backgroundTaskDetail,
-  isBackgroundTaskResponseArgs,
-  genericCompletedDetail,
-  toolSearchLoadedSummary,
-  agentTerminalDetail,
   clampFailureCount,
   toolStatusColor,
 } from './tool-execution/surface-detail.mjs';
@@ -77,15 +50,6 @@ const TOOL_PENDING_SHOW_DELAY_MS = 1000;
 // One shared-tick cadence covers both the 500ms blink and per-second elapsed;
 // finer than either boundary so both stay crisp off a single timer.
 const TOOL_ANIM_TICK_MS = TOOL_BLINK_MS;
-function statusCopy(name, label, count, doneCount, pending, isError, args = {}) {
-  // No stableVerbWidth padding: it padded the done verb to the active ("-ing")
-  // width, which Ink trims at the line END (vendor output trimEnd) so it never
-  // stabilized the pending→done flip — it only left an UGLY mid-header gap
-  // ("Searched  1 pattern", "Read    1 file"). The header is wrap="truncate"
-  // behind a fixed gutter and the fullscreen full-clear repaints the row, so
-  // dropping the pad just normalizes the spacing.
-  return formatToolActionHeader(name, args, { pending, count });
-}
 export function ToolExecution({ name, args, result, rawResult, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
   const rowWidth = Math.max(1, Number(columns || 80));
   const groupCount = Math.max(1, Number(count || 1));
@@ -284,104 +248,52 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   }
 
   // ── Normal (non-aggregate) tool card ────────────────────────────
-  const { label, summary, normalizedName, args: parsedArgs } = formatToolSurface(name, args);
-  const isShellSurface = isShellTool(normalizedName, label);
-  const isSkillSurface = SKILL_SURFACE_NAMES.has(String(normalizedName || '').toLowerCase());
-  const backgroundMeta = !pending && isBackgroundTaskTool(normalizedName)
-    ? resolveBackgroundTaskMeta(parsedArgs, rt || '')
-    : null;
-  const backgroundError = backgroundMeta?.error || parsedArgs?.error || '';
-  const errorOnlyResult = Boolean(rt) && isBackgroundErrorOnlyBody(rt, backgroundError);
-  const backgroundResultText = backgroundMeta?.hasResponse ? backgroundMeta.body : '';
-  const displayedResultText = backgroundResultText || (errorOnlyResult ? '' : (rt || ''));
-  const hasDisplayResult = Boolean(String(displayedResultText || '').trim());
-  const displayedResultBodyText = stripLeadingStatusMarkerFromText(displayedResultText);
-  const hasDisplayBody = Boolean(String(displayedResultBodyText || '').trim());
-  const lines = displayedResultBodyText ? displayedResultBodyText.split('\n') : [];
-  const totalLines = lines.length;
-  // Semantic one-line summary derived purely from name/args/result text.
-  // Shown in the collapsed, non-error view in place of the raw result block.
-  // Grouped cards ("Searched N files" / "Read N files") get the same treatment
-  // as single calls: a one-line semantic summary stands in for the raw block.
-  const resultSummary = !pending && hasDisplayBody
-    ? surfaceSummarizeToolResult(name, args, displayedResultBodyText, isError)
-    : null;
-  // Same fit budget fitResultLine() uses, to detect a line that will be clipped.
+  // Single source: the shared collapsed-card derivation (labels, casing,
+  // status merging, detail row) consumed by BOTH the TUI and the desktop
+  // renderer (apps/desktop TranscriptView ToolCard). Width fitting, theme
+  // colors, blink, and expansion handling stay TUI-side below.
   const maxResultChars = Math.min(RESULT_LINE_HARD_MAX, Math.max(MIN_RESULT_LINE_CHARS, Number(columns || 80) - 7));
+  const model = deriveToolCardModel({
+    name,
+    args,
+    result,
+    rawResult,
+    isError,
+    errorCount,
+    callErrorCount,
+    exitErrorCount,
+    count: displayGroupCount,
+    completedCount: doneCount,
+    startedAt,
+    completedAt,
+    headerFinalized,
+    nowMs,
+  }, { truncate: truncateToWidth, maxResultChars });
+  const {
+    labelText,
+    summaryText,
+    headerFailureText: headerFailureStatus,
+    detailLine: collapsedDetailLine,
+    detailIsPlaceholder,
+    terminalStatus,
+    normalizedName,
+    isShellSurface,
+    isAgentSurfaceCard,
+    isAgentResponse,
+    isBackgroundMetadataResult,
+    hasDisplayResult,
+    hasDisplayBody,
+    displayedResultBodyText,
+    firstResultLine,
+    totalLines,
+    resultSummary,
+    shellCollapsedSummary,
+    toolArgPath,
+  } = model;
+  const lines = displayedResultBodyText ? displayedResultBodyText.split('\n') : [];
   const resultColor = theme.text;
-  const firstResultLine = hasDisplayResult ? String(lines[0] ?? '') : '';
   const firstResultLineClipped = hasDisplayBody && stringWidth(firstResultLine) > maxResultChars;
   const hasHiddenDetail = !pending && hasDisplayBody && (totalLines > 1 || firstResultLineClipped || Boolean(resultSummary));
-  const shellStatus = isShellSurface ? shellDisplayStatus({ pending, failedCount, exitFailedCount, isError, result: displayedResultText }) : '';
-  const shellElapsed = isShellSurface ? (shellResultElapsed(displayedResultText) || elapsed) : '';
-  const backgroundElapsed = backgroundMeta
-    ? backgroundTaskElapsed(backgroundMeta, elapsed)
-    : (isBackgroundTaskTool(normalizedName) ? backgroundTaskElapsed(parsedArgs, elapsed) : '');
-
-  const toolArgPath = parsedArgs?.path ?? parsedArgs?.file_path ?? parsedArgs?.file ?? '';
-  // Audit HIGH: on a FAILED view_image the path detail used to win over the
-  // error cause (nonShellDetail order puts imageDetail before genericDetail),
-  // so the card showed the filename instead of why it failed. Suppress the
-  // path detail on error; the error-cause summary/first line takes the row.
-  const imageDetail = normalizedName === 'view_image' && toolArgPath && !isError ? String(toolArgPath) : '';
-  const isBackgroundResult = !pending && isBackgroundTaskTool(normalizedName) && Boolean(backgroundMeta);
-  const isBackgroundResponse = isBackgroundResult && (backgroundMeta?.hasResponse || isBackgroundTaskResponseArgs(normalizedName, parsedArgs));
-  const isBackgroundMetadataResult = isBackgroundResult && !isBackgroundResponse && Boolean(backgroundMeta);
-  const backgroundMetadataFailureLabel = isBackgroundMetadataResult
-    ? backgroundTaskFailureDetail(backgroundMeta, parsedArgs)
-    : '';
-  const backgroundMetadataHeaderFailure = Boolean(backgroundMetadataFailureLabel) && !hasDisplayResult
-    ? backgroundMetadataFailureLabel
-    : '';
-  const agentHeaderFailure = !pending && isAgentTool(normalizedName) && isError && parsedArgs?.error && !hasDisplayResult
-    ? backgroundTaskFailureStatusLabel(parsedArgs?.status, parsedArgs?.error, { surface: 'agent' })
-    : '';
-  const headerFailureStatus = backgroundMetadataHeaderFailure || agentHeaderFailure || '';
-  const agentCompletionDetail = !pending && isAgentTool(normalizedName) && !agentHeaderFailure
-    ? agentTerminalDetail(parsedArgs?.status, isError, elapsed, parsedArgs?.error)
-    : '';
-  const agentDetail = !pending && isAgentTool(normalizedName) && !hasDisplayResult
-    ? agentCompletionDetail
-    : '';
-  const genericDetail = !pending && !isShellSurface && !agentDetail && !imageDetail && !resultSummary
-    ? genericCompletedDetail({ normalizedName, label, hasResult, firstResultLine, isError })
-    : '';
-  const terminalStatus = pending
-    ? 'running'
-    : (shellStatus || normalizeTerminalStatus(backgroundMeta?.status) || normalizeTerminalStatus(parsedArgs?.status) || resultTerminalStatus(displayedResultText) || (isError || failedCount > 0 ? 'failed' : 'completed'));
-  const backgroundMetadataDetail = isBackgroundMetadataResult && !backgroundMetadataHeaderFailure
-    ? backgroundTaskDetail(backgroundMeta, backgroundElapsed, parsedArgs)
-    : '';
-  const backgroundResponseDetail = isBackgroundResponse && resultSummary
-    ? prefixElapsed(resultSummary, backgroundElapsed)
-    : resultSummary;
-  const syncElapsedDetail = !isBackgroundResponse && shouldPrefixSyncElapsed(normalizedName, label)
-    ? prefixElapsed(backgroundResponseDetail, elapsed)
-    : backgroundResponseDetail;
-  const nonShellDetail = backgroundMetadataDetail || (/^(Cancelled|Failed|Finished)$/i.test(resultSummary || '') && agentCompletionDetail
-    ? agentCompletionDetail
-    : syncElapsedDetail) || agentDetail || imageDetail || genericDetail;
-  // A pending non-aggregate tool used to drop its detail row entirely
-  // (collapsedDetail = ''), so the card rendered as a single header row. But
-  // estimateTranscriptItemRows() in App.jsx reserves 2 rows for a collapsed
-  // non-aggregate tool (1 only for skill surfaces). That left a 1-row gap that
-    // closed the instant the result landed — the surviving "line-jump". Reserve the same
-  // dim placeholder detail row the aggregate card uses (`Running`) for the whole
-  // pending lifecycle so the height stays fixed at header + one detail row and
-  // the final summary just fills in place. Skill surfaces collapse to a single
-  // row in BOTH the estimate and the render (visibleDetailLines drops the row
-  // for isSkillSurface below), so they get no placeholder.
-  const pendingDetailPlaceholder = pending && !isSkillSurface
-    ? (elapsed ? `Running · ${elapsed}` : 'Running')
-    : '';
-  const shellCollapsedSummary = isShellSurface && !pending && hasDisplayResult
-    ? (resultSummary || truncateToWidth(firstResultLine, Math.min(120, maxResultChars)))
-    : resultSummary;
-  const collapsedDetail = pending
-    ? pendingDetailPlaceholder
-    : isShellSurface
-      ? prefixElapsed(mergeTerminalDetail(shellStatus, shellCollapsedSummary), shellElapsed)
-      : mergeTerminalDetail(terminalStatus, nonShellDetail);
   const backgroundMetadataExpandable = isBackgroundMetadataResult && hasRawResult && !pending;
   const showRawResult = expanded && (hasDisplayBody || hasRawResult)
     && (!isBackgroundMetadataResult || hasRawResult);
@@ -389,47 +301,11 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     ? (agentResponseAggregate && hasRawResult
       ? stripLeadingStatusMarkerLines(rawRt.split('\n'))
       : (hasDisplayBody ? lines : (rawRt ? stripLeadingStatusMarkerLines(rawRt.split('\n')) : [])))
-    : (collapsedDetail ? [collapsedDetail] : []);
-  const isPendingPlaceholderDetail = !showRawResult && Boolean(pendingDetailPlaceholder);
+    : (collapsedDetailLine ? [collapsedDetailLine] : []);
+  const isPendingPlaceholderDetail = !showRawResult && detailIsPlaceholder;
   const detailColor = isPendingPlaceholderDetail ? theme.subtle : theme.text;
-
-  const isAgentResult = !isBackgroundResult && !pending && isAgentTool(normalizedName) && hasDisplayResult;
-  const isAgentResponse = isAgentResult && hasAgentResponseResult(rt);
-  const isAgentSurfaceCard = isAgentTool(normalizedName);
-  const agentSurfaceBriefRaw = isAgentSurfaceCard && !showRawResult
-    ? summarizeAgentSurfaceBrief(name, parsedArgs, displayedResultText || '', { isError, isResponse: isAgentResponse })
-    : '';
-  const agentSurfaceBrief = agentSurfaceBriefRaw
-    ? truncateToWidth(agentSurfaceBriefRaw, Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars))
-    : '';
-  // Skill loads carry the skill name in the header already
-  // ("Loaded 1 skill (name)"); the collapsed detail row just repeats it, so
-  // drop it and keep the card a single line. Expanding (ctrl+o) still shows the
-  // full skill body via the raw-result path.
-  // Agent spawn/send/response cards show a tight brief under the ⎿ gutter when
-  // collapsed; ctrl+o expand still surfaces the full body.
-  let visibleDetailLines = detailLines;
-  if (isSkillSurface && !showRawResult) {
-    // Audit HIGH: a FAILED skill load used to drop its detail row with the
-    // success path, hiding the one-line cause entirely. Keep the detail row
-    // when the call errored; only the redundant success repeat is dropped.
-    visibleDetailLines = isError && collapsedDetail ? [collapsedDetail] : [];
-  } else if (isBackgroundMetadataResult && backgroundMetadataHeaderFailure && !showRawResult) {
-    visibleDetailLines = [];
-  } else if (isAgentSurfaceCard && !showRawResult) {
-    // Agent cards collapse to a SINGLE header row like skill surfaces. Keep the
-    // ⎿ detail row ONLY when it carries failure info: the call errored, or the
-    // brief/summary reads as a failure/cancel. A header-failure-only card (no
-    // brief) shows the cause in the header, so it stays a single row too.
-    // Expanded (ctrl+o raw) still flows through the showRawResult path above.
-    const agentDetailFallback = collapsedDetail
-      || (pending ? (pendingDetailPlaceholder || 'Running') : 'Finished');
-    const agentDetailLine = agentSurfaceBrief
-      || truncateToWidth(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
-    const agentFailureText = /\b(Cancelled|Canceled|Failed)\b/i.test(agentSurfaceBrief || collapsedDetail || '');
-    const keepAgentDetail = (isError || agentFailureText) && !(agentHeaderFailure && !agentSurfaceBrief);
-    visibleDetailLines = keepAgentDetail ? [agentDetailLine] : [];
-  }
+  // Skill/agent collapsed gating lives in the shared model (detailLine).
+  const visibleDetailLines = detailLines;
   const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus });
   const dotColor = finalStatusColor;
   // Agent surface cards use directional markers: `←` for requests going OUT
@@ -449,31 +325,6 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const isDirectionalMarker = isAgentResponse || isAgentSurfaceCard;
   const markerText = isDirectionalMarker ? `${markerGlyph} ` : markerGlyph;
   const dotText = pending && !blinkOn ? ' ' : markerText;
-  let labelText;
-  if (isAgentResponse) labelText = agentResponseTitle(parsedArgs, displayGroupCount);
-  else if (isBackgroundResponse) labelText = backgroundTaskResultTitle(normalizedName, backgroundMeta || parsedArgs);
-  else if (isBackgroundMetadataResult) labelText = backgroundTaskActionTitle(normalizedName, backgroundMeta);
-  else if (isShellSurface) labelText = shellHeader(shellStatus, displayGroupCount);
-  else labelText = (isAgentTool(normalizedName) ? agentActionTitle(parsedArgs) : '') || statusCopy(name, label, displayGroupCount, doneCount, headerPending, isError, parsedArgs);
-  labelText = safeInlineText(labelText);
-  // Show the parenthesized arg summary for grouped cards too, matching single
-  // calls so the header carries the same context.
-  const toolSearchSummary = !pending && normalizedName === 'load_tool' && hasResult
-    ? toolSearchLoadedSummary(displayedResultText)
-    : '';
-  const rawSummaryText = safeInlineText(isAgentResponse || isBackgroundResponse
-    ? ''
-    : toolSearchSummary || (isAgentTool(normalizedName) ? agentActionSummary(parsedArgs, summary) : summary));
-  // Drop the parenthesized arg summary when it is a bare "<n> <unit>" count
-  // that the header verb already spells out (e.g. header "Searching 6 patterns"
-  // + summary "6 patterns"). Multi-arg array calls hit this; single calls keep
-  // their descriptive summary ("pattern: \"foo\"") since it never matches the
-  // header tail. Channel surfaces are unaffected — they build the summary from
-  // summarizeToolArgs directly and never render this header verb.
-  const summaryIsHeaderCount = rawSummaryText
-    && /^\d+\s+\S+$/.test(rawSummaryText)
-    && labelText.endsWith(rawSummaryText);
-  const summaryText = summaryIsHeaderCount ? '' : rawSummaryText;
   // Agent cards hide their collapsed body but still expose ctrl+o expand only
   // when expanding would actually reveal something: an agent response body, or a
   // multiline / clipped raw result (e.g. the "agents: N …" worker list). A