codemini-cli 0.2.7 → 0.2.9

package/src/tui/chat-app.js

@@ -2,6 +2,20 @@ import React, { useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { shouldCaptureEscapeSequence } from './input-escape.js';
 import { classifyCommandIntent } from '../core/shell.js';
+import {
+  buildInterToolNotice as buildRegisteredInterToolNotice,
+  buildPreToolNotice as buildRegisteredPreToolNotice,
+  buildSyntheticCompletionText as buildRegisteredSyntheticCompletionText
+} from './tool-narration.js';
+import {
+  describeToolActivity as describeRegisteredToolActivity,
+  isCodeGenerationActivityName
+} from './tool-activity/index.js';
+import {
+  describeAutoSkillActivity as describeRegisteredAutoSkillActivity,
+  describeSkillActivity as describeRegisteredSkillActivity,
+  formatAutoSkillBadge as formatRegisteredAutoSkillBadge
+} from './skill-activity/index.js';
 
 const h = React.createElement;
 const SUGGESTION_PAGE_SIZE = 8;
@@ -88,6 +102,7 @@ const TUI_COPY = {
       startupHint: '使用 /help、/commands、/compact、/exit、!<shell>。Tab 可自动补全 slash 命令。',
       toolSummaryExpanded: '工具摘要：已展开',
       toolSummaryCollapsed: '工具摘要：已收起',
+      toolChainCollapsed: (count) => `已折叠更早的 ${count} 个工具调用，按 Ctrl+T 展开全部`,
       toggleToolSummary: 'Ctrl+T 切换',
       scrollHint: '使用终端自己的滚动条或 scrollback',
       keyboardDebugEnabled: '键盘调试已开启',
@@ -219,6 +234,7 @@ const TUI_COPY = {
       startupHint: 'Use /help, /commands, /compact, /exit, !<shell>. Tab for slash autocomplete.',
       toolSummaryExpanded: 'Tool summary: expanded',
       toolSummaryCollapsed: 'Tool summary: collapsed',
+      toolChainCollapsed: (count) => `${count} earlier tool calls hidden, press Ctrl+T to expand`,
       toggleToolSummary: 'Ctrl+T to toggle',
       scrollHint: 'Scroll with your terminal scrollbar or scrollback',
       keyboardDebugEnabled: 'Keyboard debug enabled',
@@ -353,6 +369,308 @@ function trimText(value, maxLen = 88) {
   return `${text.slice(0, maxLen - 3)}...`;
 }
 
+export function splitMarkdownTableCells(line) {
+  const text = String(line || '').trim();
+  if (!text.includes('|')) return [];
+  return text
+    .replace(/^\|/, '')
+    .replace(/\|$/, '')
+    .split('|')
+    .map((cell) => String(cell || '').trim());
+}
+
+export function isMarkdownTableSeparator(line) {
+  const cells = splitMarkdownTableCells(line);
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+
+export function isMarkdownTableHeader(line, nextLine) {
+  const cells = splitMarkdownTableCells(line);
+  return cells.length > 1 && isMarkdownTableSeparator(nextLine);
+}
+
+function getMarkdownTableAlignments(separatorLine, columnCount) {
+  const cells = splitMarkdownTableCells(separatorLine);
+  return Array.from({ length: columnCount }, (_, index) => {
+    const cell = String(cells[index] || '').trim();
+    if (/^:-{3,}:$/.test(cell)) return 'center';
+    if (/^-{3,}:$/.test(cell)) return 'right';
+    return 'left';
+  });
+}
+
+function stringWidthLite(value) {
+  return Array.from(String(value || '')).reduce((sum, ch) => sum + charDisplayWidth(ch), 0);
+}
+
+function splitTableWrapUnits(text) {
+  return String(text || '')
+    .split(/([\s,.;:!?/\\|()[\]{}<>，。；：！？、（）【】《》]+)/)
+    .filter(Boolean);
+}
+
+function wrapPlainText(text, width, hard = false) {
+  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!normalized) return [''];
+  if (width <= 1) return [normalized];
+
+  const words = splitTableWrapUnits(normalized);
+  const lines = [];
+  let current = '';
+
+  const pushWord = (word) => {
+    if (stringWidthLite(word) <= width) {
+      if (!current) {
+        current = word;
+        return;
+      }
+      const needsSpacer =
+        !/\s$/.test(current) &&
+        !/^\s/.test(word) &&
+        !/^[,.;:!?/\\|)\]}，。；：！？、】【》]/.test(word);
+      const next = needsSpacer ? `${current} ${word}` : `${current}${word}`;
+      if (stringWidthLite(next) <= width) {
+        current = next;
+      } else {
+        lines.push(current);
+        current = word;
+      }
+      return;
+    }
+
+    if (!hard) {
+      if (current) {
+        lines.push(current);
+        current = '';
+      }
+      lines.push(word);
+      return;
+    }
+
+    if (current) {
+      lines.push(current);
+      current = '';
+    }
+    let rest = word;
+    while (stringWidthLite(rest) > width) {
+      lines.push(Array.from(rest).slice(0, width).join(''));
+      rest = Array.from(rest).slice(width).join('');
+    }
+    current = rest;
+  };
+
+  for (const word of words) pushWord(word);
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [''];
+}
+
+function padAlignedText(text, width, align = 'left') {
+  const value = String(text || '');
+  const visible = stringWidthLite(value);
+  if (visible >= width) return value;
+  const gap = width - visible;
+  if (align === 'right') return `${' '.repeat(gap)}${value}`;
+  if (align === 'center') {
+    const left = Math.floor(gap / 2);
+    const right = gap - left;
+    return `${' '.repeat(left)}${value}${' '.repeat(right)}`;
+  }
+  return `${value}${' '.repeat(gap)}`;
+}
+
+function normalizeTableCellText(value) {
+  return String(value || '')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/\*([^*]+)\*/g, '$1')
+    .trim();
+}
+
+export function formatMarkdownTableBlock(lines, contentWidth = 72) {
+  const sourceLines = Array.isArray(lines) ? lines : [];
+  if (sourceLines.length < 2) return [];
+
+  const headerCells = splitMarkdownTableCells(sourceLines[0]);
+  const separatorLine = sourceLines[1];
+  const bodyRows = sourceLines.slice(2).map(splitMarkdownTableCells).filter((cells) => cells.length > 0);
+  if (headerCells.length === 0) return [];
+
+  const columnCount = Math.max(headerCells.length, ...bodyRows.map((cells) => cells.length));
+  const headers = Array.from({ length: columnCount }, (_, index) => normalizeTableCellText(headerCells[index] || ''));
+  const rows = bodyRows.map((cells) =>
+    Array.from({ length: columnCount }, (_, index) => normalizeTableCellText(cells[index] || ''))
+  );
+  const alignments = getMarkdownTableAlignments(separatorLine, columnCount);
+
+  const minColumnWidth = 3;
+  const maxRowLines = 6;
+  const safetyMargin = 4;
+  const borderOverhead = 1 + columnCount * 3;
+  const availableWidth = Math.max(contentWidth - borderOverhead - safetyMargin, columnCount * minColumnWidth);
+
+  const getMinWidth = (text) => {
+    const words = splitTableWrapUnits(String(text || '')).filter((word) => !/^\s+$/.test(word));
+    if (words.length === 0) return minColumnWidth;
+    return Math.max(...words.map((word) => stringWidthLite(word)), minColumnWidth);
+  };
+
+  const getIdealWidth = (text) => Math.max(stringWidthLite(String(text || '').trim()), minColumnWidth);
+
+  const minWidths = headers.map((header, index) =>
+    Math.max(getMinWidth(header), ...rows.map((row) => getMinWidth(row[index])))
+  );
+  const idealWidths = headers.map((header, index) =>
+    Math.max(getIdealWidth(header), ...rows.map((row) => getIdealWidth(row[index])))
+  );
+
+  const totalMin = minWidths.reduce((sum, width) => sum + width, 0);
+  const totalIdeal = idealWidths.reduce((sum, width) => sum + width, 0);
+  let needsHardWrap = false;
+  let columnWidths;
+
+  if (totalIdeal <= availableWidth) {
+    columnWidths = idealWidths.slice();
+  } else if (totalMin <= availableWidth) {
+    const extraSpace = availableWidth - totalMin;
+    const overflows = idealWidths.map((ideal, index) => ideal - minWidths[index]);
+    const totalOverflow = overflows.reduce((sum, width) => sum + width, 0);
+    columnWidths = minWidths.map((min, index) => {
+      if (totalOverflow === 0) return min;
+      return min + Math.floor((overflows[index] / totalOverflow) * extraSpace);
+    });
+  } else {
+    needsHardWrap = true;
+    const scale = availableWidth / Math.max(totalMin, 1);
+    columnWidths = minWidths.map((width) => Math.max(Math.floor(width * scale), minColumnWidth));
+  }
+
+  const wrapCell = (text, width) => wrapPlainText(text, width, needsHardWrap);
+
+  const computeMaxWrappedLines = () => {
+    let maxLines = 1;
+    for (let index = 0; index < headers.length; index += 1) {
+      maxLines = Math.max(maxLines, wrapCell(headers[index], columnWidths[index]).length);
+    }
+    for (const row of rows) {
+      for (let index = 0; index < columnCount; index += 1) {
+        maxLines = Math.max(maxLines, wrapCell(row[index], columnWidths[index]).length);
+      }
+    }
+    return maxLines;
+  };
+
+  const renderVerticalRows = () => {
+    const rendered = [];
+    const separatorWidth = Math.min(Math.max(contentWidth - 2, 12), 40);
+    const separator = '─'.repeat(separatorWidth);
+    rows.forEach((row, rowIndex) => {
+      if (rowIndex > 0) rendered.push({ kind: 'table-vertical-separator', text: separator });
+      row.forEach((cell, cellIndex) => {
+        const label = headers[cellIndex] || `Column ${cellIndex + 1}`;
+        const firstWidth = Math.max(contentWidth - stringWidthLite(label) - 3, 10);
+        const nextWidth = Math.max(contentWidth - 3, 10);
+        const firstPass = wrapPlainText(cell, firstWidth, true);
+        const firstLine = firstPass[0] || '';
+        const remaining = firstPass.slice(1).join(' ');
+        const rest = remaining ? wrapPlainText(remaining, nextWidth, true) : [];
+        const wrapped = [firstLine, ...rest].filter((line, idx) => idx === 0 || line.trim());
+        rendered.push({
+          kind: 'table-vertical',
+          label,
+          text: wrapped[0] || ''
+        });
+        for (const line of wrapped.slice(1)) {
+          rendered.push({
+            kind: 'table-vertical-continuation',
+            text: line
+          });
+        }
+      });
+    });
+    return rendered;
+  };
+
+  if (computeMaxWrappedLines() > maxRowLines && contentWidth < 80) {
+    return renderVerticalRows();
+  }
+
+  const renderBorder = (type) => {
+    const chars = {
+      top: ['┌', '─', '┬', '┐'],
+      middle: ['├', '─', '┼', '┤'],
+      bottom: ['└', '─', '┴', '┘']
+    }[type];
+    let line = chars[0];
+    columnWidths.forEach((width, index) => {
+      line += chars[1].repeat(width + 2);
+      line += index < columnWidths.length - 1 ? chars[2] : chars[3];
+    });
+    return line;
+  };
+
+  const renderRowLines = (cells, isHeader = false) => {
+    const wrappedColumns = cells.map((cell, index) => wrapCell(cell, columnWidths[index]));
+    const maxLines = Math.max(...wrappedColumns.map((entry) => entry.length), 1);
+    const verticalOffsets = wrappedColumns.map((entry) => Math.floor((maxLines - entry.length) / 2));
+    const rendered = [];
+    for (let lineIndex = 0; lineIndex < maxLines; lineIndex += 1) {
+      let line = '│';
+      for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+        const wrapped = wrappedColumns[columnIndex];
+        const offset = verticalOffsets[columnIndex];
+        const contentIndex = lineIndex - offset;
+        const text = contentIndex >= 0 && contentIndex < wrapped.length ? wrapped[contentIndex] : '';
+        const align = isHeader ? 'center' : alignments[columnIndex];
+        line += ` ${padAlignedText(text, columnWidths[columnIndex], align)} │`;
+      }
+      rendered.push({
+        kind: 'table',
+        text: line,
+        isHeader
+      });
+    }
+    return rendered;
+  };
+
+  const tableLines = [
+    { kind: 'table-separator', text: renderBorder('top') },
+    ...renderRowLines(headers, true),
+    { kind: 'table-separator', text: renderBorder('middle') }
+  ];
+
+  rows.forEach((row, index) => {
+    tableLines.push(...renderRowLines(row, false));
+    if (index < rows.length - 1) {
+      tableLines.push({ kind: 'table-separator', text: renderBorder('middle') });
+    }
+  });
+  tableLines.push({ kind: 'table-separator', text: renderBorder('bottom') });
+
+  const maxLineWidth = Math.max(...tableLines.map((entry) => stringWidthLite(entry.text)));
+  if (maxLineWidth > contentWidth - safetyMargin) {
+    return renderVerticalRows();
+  }
+
+  return tableLines;
+}
+
+function parseRichTextSegments(line, baseColor) {
+  const parts = String(line || '').split(/(`[^`]+`|\*\*[^*]+\*\*)/g);
+  return parts.map((part, idx) => {
+    if (part.startsWith('`') && part.endsWith('`') && part.length >= 2) {
+      return h(
+        Text,
+        { key: `ic-${idx}`, color: 'black', backgroundColor: 'yellow' },
+        part.slice(1, -1)
+      );
+    }
+    if (part.startsWith('**') && part.endsWith('**') && part.length >= 4) {
+      return h(Text, { key: `bd-${idx}`, color: 'cyanBright', bold: true }, part.slice(2, -2));
+    }
+    return h(Text, { key: `tx-${idx}`, color: baseColor }, part);
+  });
+}
+
 function safeJsonParse(raw) {
   try {
     return JSON.parse(String(raw || '{}'));
@@ -371,33 +689,8 @@ function parseToolDisplayName(name) {
   };
 }
 
-function isCodeGenerationActivityName(name) {
-  return String(name || '').trim() === 'Code generation';
-}
-
 export function buildPreToolNotice(name, copy) {
-  const parsed = parseToolDisplayName(name);
-  const base = parsed.base;
-  const target = parsed.target ? trimText(parsed.target, 48) : '';
-  const isEnglish = String(copy?.roleLabels?.coder || '').trim() === 'CODER' && String(copy?.roleLabels?.you || '').trim() === 'YOU';
-
-  if (isEnglish) {
-    if (base === 'read') return target ? `I'll inspect ${target} first.` : `I'll inspect the relevant file first.`;
-    if (base === 'list' || base === 'glob') return target ? `I'll inspect the ${target} directory first.` : `I'll inspect the relevant directory first.`;
-    if (base === 'grep') return `I'll search the relevant code first.`;
-    if (base === 'edit' || base === 'write' || base === 'patch' || base === 'generate_diff') {
-      return `I'll inspect the current code first, then make the change.`;
-    }
-    if (base === 'run') return `I'll verify the current project state first.`;
-    return `I'll check the relevant project context first.`;
-  }
-
-  if (base === 'read') return target ? `我先查看 ${target} 的内容。` : '我先查看相关文件内容。';
-  if (base === 'list' || base === 'glob') return target ? `我先查看 ${target} 目录里的内容。` : '我先查看相关目录内容。';
-  if (base === 'grep') return '我先搜索相关代码位置。';
-  if (base === 'edit' || base === 'write' || base === 'patch' || base === 'generate_diff') return '我先确认当前代码上下文，再动手修改。';
-  if (base === 'run') return '我先检查当前项目状态。';
-  return '我先查看相关上下文。';
+  return buildRegisteredPreToolNotice(name, copy);
 }
 
 export function shouldInjectPreToolNotice(msg) {
@@ -408,6 +701,33 @@ export function shouldInjectPreToolNotice(msg) {
   return !text && !hasTextSegment;
 }
 
+function getLastToolActivity(msg, statuses = []) {
+  const allowed = new Set((Array.isArray(statuses) ? statuses : []).map((status) => String(status)));
+  const segments = Array.isArray(msg?.segments) ? msg.segments : [];
+  for (let idx = segments.length - 1; idx >= 0; idx -= 1) {
+    const segment = segments[idx];
+    if (segment?.type !== 'tool' && segment?.type !== 'system_tool') continue;
+    if (allowed.size === 0 || allowed.has(String(segment.status || ''))) return segment;
+  }
+  return null;
+}
+
+function hasOnlySyntheticNarration(msg) {
+  if (!msg?.syntheticPrelude) return false;
+  const segments = Array.isArray(msg?.segments) ? msg.segments : [];
+  const hasToolRows = segments.some((segment) => segment?.type === 'tool' || segment?.type === 'system_tool');
+  const textSegments = segments.filter((segment) => segment?.type === 'text' && String(segment.text || '').trim());
+  return hasToolRows && textSegments.length <= 1;
+}
+
+export function buildInterToolNotice(previousActivity, nextToolName, copy) {
+  return buildRegisteredInterToolNotice(previousActivity, nextToolName, copy);
+}
+
+export function buildSyntheticCompletionText(msg, copy) {
+  return buildRegisteredSyntheticCompletionText(msg, copy);
+}
+
 function formatDurationMs(ms) {
   const safeMs = Math.max(0, Number(ms) || 0);
   return `${(safeMs / 1000).toFixed(1)}s`;
@@ -514,168 +834,19 @@ export function shouldShowCompletionFooter(msg) {
 }
 
 function describeToolActivity(name, copy, { done = false, blocked = false } = {}) {
-  const parsed = parseToolDisplayName(name);
-  if (parsed.base === 'project_index') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: project index`
-      : done
-        ? copy.toolActivity.doneProjectIndex
-        : copy.toolActivity.doingProjectIndex;
-  }
-  if (parsed.base === 'file_index') {
-    const safeTarget = trimText(parsed.target || '.codemini-project/file-index.json', 72);
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${safeTarget}`
-      : done
-        ? `${copy.toolActivity.doneFileIndex}: ${safeTarget}`
-        : `${copy.toolActivity.doingFileIndex}: ${safeTarget}`;
-  }
-  if (parsed.base === 'run' || parsed.base === 'start_service') {
-    const intent = classifyCommandIntent(parsed.target);
-    const target = parsed.target || intent.kind || 'command';
-    if (intent.kind === 'install') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneInstall}: ${target}`
-          : `${copy.toolActivity.doingInstall}: ${target}`;
-    }
-    if (intent.kind === 'build') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneBuild}: ${target}`
-          : `${copy.toolActivity.doingBuild}: ${target}`;
-    }
-    if (intent.kind === 'test') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneTest}: ${target}`
-          : `${copy.toolActivity.doingTest}: ${target}`;
-    }
-    if (intent.kind === 'frontend-service') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneFrontend}: ${target}`
-          : `${copy.toolActivity.doingFrontend}: ${target}`;
-    }
-    if (intent.kind === 'backend-service') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneBackend}: ${target}`
-          : `${copy.toolActivity.doingBackend}: ${target}`;
-    }
-    if (intent.kind === 'database-service') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneDatabase}: ${target}`
-          : `${copy.toolActivity.doingDatabase}: ${target}`;
-    }
-    if (intent.kind === 'docker-service') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneDocker}: ${target}`
-          : `${copy.toolActivity.doingDocker}: ${target}`;
-    }
-    if (intent.kind === 'service') {
-      return blocked
-        ? `${copy.toolActivity.blocked}: ${target}`
-        : done
-          ? `${copy.toolActivity.doneGeneric}: ${target}`
-          : `${copy.toolActivity.doingGeneric}: ${target}`;
-    }
-  }
-  if (isCodeGenerationActivityName(name)) {
-    return blocked
-      ? `${copy.toolActivity.blocked}: code generation`
-      : done
-        ? copy.toolActivity.doneCodeGeneration
-        : copy.toolActivity.doingCodeGeneration;
-  }
-  const { raw, base, target } = parseToolDisplayName(name);
-  const safeTarget = trimText(target, 72);
-  if (base === 'read') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${base}(${safeTarget || '.'})`
-      : done
-        ? `${copy.toolActivity.doneRead}: ${safeTarget || '.'}`
-        : `${copy.toolActivity.doingRead}: ${safeTarget || '.'}`;
-  }
-  if (base === 'edit') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${base}(${safeTarget || '.'})`
-      : done
-        ? `${copy.toolActivity.doneEdit}: ${safeTarget || '.'}`
-        : `${copy.toolActivity.doingEdit}: ${safeTarget || '.'}`;
-  }
-  if (base === 'write') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${base}(${safeTarget || '.'})`
-      : done
-        ? `${copy.toolActivity.doneWrite}: ${safeTarget || '.'}`
-        : `${copy.toolActivity.doingWrite}: ${safeTarget || '.'}`;
-  }
-  if (base === 'patch') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${base}(${safeTarget || '.'})`
-      : done
-        ? `${copy.toolActivity.donePatch}: ${safeTarget || '.'}`
-        : `${copy.toolActivity.doingPatch}: ${safeTarget || '.'}`;
-  }
-  if (base === 'list' || base === 'glob' || base === 'grep') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${base}(${safeTarget || '.'})`
-      : done
-        ? `${copy.toolActivity.doneList}: ${safeTarget || '.'}`
-        : `${copy.toolActivity.doingList}: ${safeTarget || '.'}`;
-  }
-  if (base === 'run') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${safeTarget || base}`
-      : done
-        ? `${copy.toolActivity.doneCommand}: ${safeTarget || base}`
-        : `${copy.toolActivity.doingCommand}: ${safeTarget || base}`;
-  }
-  if (base === 'start_service' || base === 'list_services' || base === 'get_service_status' || base === 'get_service_logs' || base === 'stop_service') {
-    return blocked
-      ? `${copy.toolActivity.blocked}: ${safeTarget || base}`
-      : done
-        ? `${copy.toolActivity.doneGeneric}: ${safeTarget || base}`
-        : `${copy.toolActivity.doingGeneric}: ${safeTarget || base}`;
-  }
-  if (base === 'create_task') {
-    return blocked ? `${copy.toolActivity.blocked}: create_task` : done ? copy.toolActivity.doneCreateTask : copy.toolActivity.doingCreateTask;
-  }
-  if (base === 'update_task') {
-    return blocked ? `${copy.toolActivity.blocked}: update_task` : done ? copy.toolActivity.doneUpdateTask : copy.toolActivity.doingUpdateTask;
-  }
-  return blocked ? `${copy.toolActivity.blocked}: ${raw}` : done ? `${copy.toolActivity.doneGeneric}: ${raw}` : `${copy.toolActivity.doingGeneric}: ${raw}`;
+  return describeRegisteredToolActivity(copy, name, { done, blocked });
 }
 
 function describeSkillActivity(name, copy, { done = false, failed = false } = {}) {
-  if (failed) return `${copy.runtime.skillFailed}: /${name}`;
-  if (done) return `${copy.toolActivity.doneSkill}: /${name}`;
-  return `${copy.toolActivity.doingSkill}: /${name}`;
+  return describeRegisteredSkillActivity(copy, name, { done, failed });
 }
 
 function describeAutoSkillActivity(names, copy) {
-  const safeNames = Array.isArray(names) ? names.filter(Boolean) : [];
-  if (safeNames.length === 0) return '';
-  return copy.runtime.autoSkillInjected(safeNames);
+  return describeRegisteredAutoSkillActivity(copy, names);
 }
 
 function formatAutoSkillBadge(names, copy) {
-  const safeNames = Array.isArray(names) ? names.filter(Boolean) : [];
-  if (safeNames.length === 0) return '';
-  const [first, ...rest] = safeNames;
-  const suffix = rest.length > 0 ? ` +${rest.length}` : '';
-  const prefix = copy?.roleLabels?.system === 'SYSTEM' ? 'AUTO' : '自动';
-  return `${prefix} /${first}${suffix}`;
+  return formatRegisteredAutoSkillBadge(copy, names);
 }
 
 function normalizeRuntimeStatus(status, copy) {
@@ -880,20 +1051,31 @@ function Header({ sessionId, model, shellName, safeMode = true }) {
 }
 
 function renderInlineCode(line, baseColor) {
-  const parts = line.split(/(`[^`]+`)/g);
-  return parts.map((part, idx) => {
-    if (part.startsWith('`') && part.endsWith('`') && part.length >= 2) {
-      return h(
-        Text,
-        { key: `ic-${idx}`, color: 'black', backgroundColor: 'yellow' },
-        part.slice(1, -1)
-      );
-    }
-    return h(Text, { key: `tx-${idx}`, color: baseColor }, part);
-  });
+  return parseRichTextSegments(line, baseColor);
 }
 
 function renderTextLine(msg, line, idx, color) {
+  const headingMatch = String(line || '').match(/^\s{0,3}(#{1,3})\s+(.*)$/);
+  if (headingMatch) {
+    const level = headingMatch[1].length;
+    const title = headingMatch[2].trim();
+    const accent = level === 1 ? 'cyanBright' : level === 2 ? 'greenBright' : 'yellowBright';
+    return h(
+      Box,
+      { key: `ln-wrap-${msg.id}-${idx}` },
+      h(Text, { color: accent, bold: true }, title)
+    );
+  }
+
+  const boldTitleMatch = String(line || '').match(/^\s*\*\*(.+)\*\*\s*$/);
+  if (boldTitleMatch) {
+    return h(
+      Box,
+      { key: `ln-wrap-${msg.id}-${idx}` },
+      h(Text, { key: `ln-${msg.id}-${idx}`, color: 'cyanBright', bold: true }, boldTitleMatch[1].trim())
+    );
+  }
+
   return h(
     Box,
     { key: `ln-wrap-${msg.id}-${idx}` },
@@ -1544,12 +1726,70 @@ export function mergeActivitySummary(previousSummary, nextSummary, activityName)
   return lines.join('\n');
 }
 
+export function collapseActivityChainRows(inputRows, showToolDetails, copy, maxVisibleActivities = 3) {
+  const rows = Array.isArray(inputRows) ? inputRows : [];
+  if (showToolDetails) return rows.slice();
+  const maxVisible = Math.max(1, Number(maxVisibleActivities) || 3);
+  const collapsed = [];
+
+  const isCollapsibleActivity = (row) =>
+    row?.kind === 'activity' &&
+    ['tool', 'skill', 'system_tool'].includes(String(row?.activityType || 'tool'));
+
+  let index = 0;
+  while (index < rows.length) {
+    const row = rows[index];
+    if (!isCollapsibleActivity(row)) {
+      collapsed.push(row);
+      index += 1;
+      continue;
+    }
+
+    const group = [];
+    while (index < rows.length) {
+      const next = rows[index];
+      if (isCollapsibleActivity(next)) {
+        group.push([next]);
+        index += 1;
+        continue;
+      }
+      if (next?.kind === 'activity-summary' && group.length > 0) {
+        group[group.length - 1].push(next);
+        index += 1;
+        continue;
+      }
+      break;
+    }
+
+    if (group.length <= maxVisible) {
+      for (const item of group) collapsed.push(...item);
+      continue;
+    }
+
+    const hiddenCount = group.length - maxVisible;
+    collapsed.push({
+      kind: 'activity-collapsed',
+      hiddenCount,
+      text:
+        copy?.generic?.toolChainCollapsed != null
+          ? copy.generic.toolChainCollapsed(hiddenCount)
+          : `${hiddenCount} earlier tool calls hidden`
+    });
+    for (const item of group.slice(-maxVisible)) {
+      collapsed.push(...item);
+    }
+  }
+
+  return collapsed;
+}
+
 function buildMessageRows(msg, showToolDetails, contentWidth = 72, copy) {
   const rows = [];
   const pushTextRows = (text) => {
     const lines = String(text || '').split('\n');
     let codeFence = false;
-    for (const line of lines) {
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+      const line = lines[lineIndex];
       const trimmed = line.trim();
       const planProgress = parsePlanProgressLine(trimmed);
       if (planProgress) {
@@ -1570,6 +1810,16 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72, copy) {
         pushWrappedRow(rows, { kind: 'code', text: line || ' ', color: 'gray' }, contentWidth);
         continue;
       }
+      if (isMarkdownTableHeader(line, lines[lineIndex + 1])) {
+        const tableLines = [line];
+        lineIndex += 1; // skip separator
+        while (lineIndex + 1 < lines.length && splitMarkdownTableCells(lines[lineIndex + 1]).length > 1) {
+          tableLines.push(lines[lineIndex + 1]);
+          lineIndex += 1;
+        }
+        rows.push(...formatMarkdownTableBlock(tableLines, contentWidth));
+        continue;
+      }
       let color = msg.color || roleStyle(msg.label).text || 'white';
       if (line.startsWith('#')) color = 'cyanBright';
       else if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) color = 'magentaBright';
@@ -1651,7 +1901,9 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72, copy) {
     syntheticRows.push(...statusRows);
   }
 
-  return normalizeActivitySpacingRows(insertRowsAfterLastCodeRow(rows, syntheticRows));
+  return normalizeActivitySpacingRows(
+    insertRowsAfterLastCodeRow(collapseActivityChainRows(rows, showToolDetails, copy), syntheticRows)
+  );
 }
 
 function renderMessageRow(msg, row, idx, loaderTick) {
@@ -1695,6 +1947,49 @@ function renderMessageRow(msg, row, idx, loaderTick) {
       h(Text, { color: 'gray' }, `└ ${row.text}`)
     );
   }
+  if (row.kind === 'table') {
+    return h(
+      Box,
+      { key: `row-table-${msg.id}-${idx}`, marginLeft: 1 },
+      h(Text, { color: row.isHeader ? 'cyanBright' : 'gray', bold: Boolean(row.isHeader) }, row.text)
+    );
+  }
+  if (row.kind === 'table-separator') {
+    return h(
+      Box,
+      { key: `row-table-sep-${msg.id}-${idx}`, marginLeft: 1 },
+      h(Text, { color: 'gray' }, row.text)
+    );
+  }
+  if (row.kind === 'table-vertical') {
+    return h(
+      Box,
+      { key: `row-table-v-${msg.id}-${idx}`, marginLeft: 1 },
+      h(Text, { color: 'cyanBright', bold: true }, `${row.label}:`),
+      h(Text, { color: 'gray' }, row.text ? ` ${row.text}` : '')
+    );
+  }
+  if (row.kind === 'table-vertical-continuation') {
+    return h(
+      Box,
+      { key: `row-table-vc-${msg.id}-${idx}`, marginLeft: 3 },
+      h(Text, { color: 'gray' }, row.text)
+    );
+  }
+  if (row.kind === 'table-vertical-separator') {
+    return h(
+      Box,
+      { key: `row-table-vs-${msg.id}-${idx}`, marginLeft: 1 },
+      h(Text, { color: 'gray' }, row.text)
+    );
+  }
+  if (row.kind === 'activity-collapsed') {
+    return h(
+      Box,
+      { key: `row-tool-collapsed-${msg.id}-${idx}`, marginLeft: 1 },
+      h(Text, { color: 'gray' }, `└ ${row.text}`)
+    );
+  }
   if (row.kind === 'plan-progress') {
     return h(
       Box,
@@ -2539,6 +2834,26 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
     return aid;
   };
 
+  const maybeRefreshSyntheticNarration = (nextToolName) => {
+    const targetId = activeAssistantIdRef.current;
+    if (!targetId || !nextToolName) return;
+    setMessages((prev) =>
+      prev.map((m) => {
+        if (m.id !== targetId) return m;
+        if (!hasOnlySyntheticNarration(m)) return m;
+        const previousActivity = getLastToolActivity(m, ['done', 'running']);
+        if (!previousActivity) return m;
+        const bridge = buildInterToolNotice(previousActivity, nextToolName, copy);
+        if (!bridge) return m;
+        return {
+          ...m,
+          text: bridge,
+          syntheticPrelude: true
+        };
+      })
+    );
+  };
+
   const runSubmission = (line, userMessageId = null) => {
     inFlightRef.current = true;
     activeUserMessageIdRef.current = userMessageId;
@@ -2632,9 +2947,15 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
             setMessages((prev) =>
               prev.map((m) => {
                 if (m.id !== targetId) return m;
+                const responseText = typeof event.text === 'string' ? event.text.trim() : '';
+                const shouldSynthesizeCompletion = !responseText && m.syntheticPrelude;
                 return {
                   ...m,
-                  ...(typeof event.text === 'string' && event.text.length > 0 ? { text: event.text } : {}),
+                  ...(responseText
+                    ? { text: event.text, syntheticPrelude: false }
+                    : shouldSynthesizeCompletion
+                      ? { text: buildSyntheticCompletionText(m, copy), syntheticPrelude: false }
+                      : {}),
                   loading: false,
                   phase: undefined,
                   liveStatus: undefined,
@@ -2658,6 +2979,7 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
         }
         if (event?.type === 'tool:start') {
           ensureActiveAssistant();
+          maybeRefreshSyntheticNarration(event.name);
           const detail = describeToolActivity(event.name, copy);
           setRuntimeStatus(makeStatus(copy.runtime.toolRunning, detail, 'magentaBright'));
           setInputStage('tooling');