codemini-cli 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemini-cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Coding CLI optimized for small-model workflows and Windows PowerShell",
   "keywords": [
     "cli",

package/src/cli.js

@@ -4,7 +4,7 @@ import { handleConfig } from './commands/config.js';
 import { handleDoctor } from './commands/doctor.js';
 import { handleSkill } from './commands/skill.js';
 
-const VERSION = '0.2.7';
+const VERSION = '0.2.8';
 
 function printHelp() {
   console.log(`codemini ${VERSION}

package/src/core/agent-loop.js

@@ -14,6 +14,101 @@ function safeJsonParse(raw) {
   }
 }
 
+function parseInlineRangePath(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const match = text.match(/^(.*?):(\d+)(?:-(\d+))?$/);
+  if (!match) return null;
+  const [, maybePath, startRaw, endRaw] = match;
+  if (!maybePath || /^(?:[A-Za-z])$/.test(maybePath)) return null;
+  const start = Number(startRaw);
+  const end = Number(endRaw || startRaw);
+  if (!Number.isFinite(start) || start <= 0) return null;
+  if (!Number.isFinite(end) || end < start) return null;
+  return { path: maybePath, start_line: start, end_line: end };
+}
+
+function normalizeToolArguments(toolName, args, rawArguments) {
+  const rawText = typeof rawArguments === 'string' ? rawArguments.trim() : '';
+  const primitive =
+    args == null || Array.isArray(args) || typeof args !== 'object'
+      ? args
+      : null;
+  const source =
+    args && typeof args === 'object' && !Array.isArray(args)
+      ? { ...args }
+      : {};
+
+  if (primitive != null && typeof primitive !== 'object') {
+    source._raw = rawText || String(primitive);
+  } else if (!source._raw && rawText && source._invalid_json) {
+    source._raw = rawText;
+  }
+
+  const stringValue =
+    typeof primitive === 'string'
+      ? primitive.trim()
+      : String(source._raw || '').trim();
+
+  if (toolName === 'read') {
+    const value = String(source.path || source.file_path || source.file || stringValue || '').trim();
+    if (value) source.path = value;
+    if (source.offset != null && source.start_line == null) source.start_line = source.offset;
+    if (source.limit != null && source.end_line == null && Number(source.start_line) > 0) {
+      source.end_line = Number(source.start_line) + Number(source.limit) - 1;
+    }
+    const range = parseInlineRangePath(source.path);
+    if (range) {
+      source.path = range.path;
+      if (source.start_line == null) source.start_line = range.start_line;
+      if (source.end_line == null) source.end_line = range.end_line;
+    }
+    return source;
+  }
+
+  if (toolName === 'list') {
+    const value = String(source.path || source.dir || source.directory || stringValue || '.').trim();
+    return { ...source, path: value || '.' };
+  }
+
+  if (toolName === 'glob') {
+    const pattern = String(source.pattern || source.glob || source.query || stringValue || '').trim();
+    if (pattern) source.pattern = pattern;
+    if (!source.path && source.directory) source.path = source.directory;
+    return source;
+  }
+
+  if (toolName === 'grep') {
+    const pattern = String(source.pattern || source.query || source.symbol || source.q || stringValue || '').trim();
+    if (pattern) source.pattern = pattern;
+    if (!source.path && (source.directory || source.dir || source.cwd)) {
+      source.path = source.directory || source.dir || source.cwd;
+    }
+    return source;
+  }
+
+  if (toolName === 'write') {
+    const value = String(source.path || source.file_path || source.file || stringValue || '').trim();
+    if (value) source.path = value;
+    if (source.content == null && source.text != null) source.content = source.text;
+    if (source.content == null && source.new_content != null) source.content = source.new_content;
+    return source;
+  }
+
+  if (toolName === 'edit') {
+    const value = String(source.path || source.file || source.file_path || '').trim();
+    if (value && !source.path) source.path = value;
+    return source;
+  }
+
+  return source;
+}
+
+function emptyToolResultMarker(toolName) {
+  const name = String(toolName || 'tool').trim() || 'tool';
+  return `(${name} completed with no output)`;
+}
+
 function clipToolResult(result, maxChars = 12000) {
   const raw = typeof result === 'string' ? result : JSON.stringify(result);
   if (!maxChars || raw.length <= maxChars) return raw;
@@ -374,9 +469,12 @@ function formatToolDisplayName(name, args) {
 function formatToolResult(toolResult, toolName, args, toolFormatters, toolResultMaxChars) {
   if (toolFormatters && typeof toolFormatters[toolName] === 'function') {
     const formatted = toolFormatters[toolName](toolResult, args);
-    if (typeof formatted === 'string') return formatted;
+    if (typeof formatted === 'string') {
+      return formatted.trim() ? formatted : emptyToolResultMarker(toolName);
+    }
   }
-  return compactToolResult(toolResult, toolName, args, toolResultMaxChars);
+  const fallback = compactToolResult(toolResult, toolName, args, toolResultMaxChars);
+  return String(fallback || '').trim() ? fallback : emptyToolResultMarker(toolName);
 }
 
 // ─── Main agent loop ────────────────────────────────────────────────
@@ -469,8 +567,8 @@ export async function runAgentLoop({
     // ─── P1a: Partition into read-only (parallel) and write (serial) ──
 
     const callsWithMeta = toolCalls.map((call) => {
-      const args = safeJsonParse(call.arguments);
       const toolName = normalizeToolCallName(call.name);
+      const args = normalizeToolArguments(toolName, safeJsonParse(call.arguments), call.arguments);
       const displayName = formatToolDisplayName(toolName, args);
       const isReadOnly = READ_ONLY_TOOLS.has(toolName);
       return { call, args, toolName, displayName, isReadOnly };

package/src/core/default-system-prompt.js

@@ -2,6 +2,42 @@ import os from 'node:os';
 import fs from 'node:fs';
 import { getShellSystemPrompt } from './shell-profile.js';
 
+function getToolFewShotBlock() {
+  const cwd = process.cwd();
+  return `# Tool Examples
+
+Use these as style examples for tool calls:
+
+Current working directory: ${cwd}
+When a tool takes file_path, build it from the current working directory and prefer absolute paths.
+If the user mentions a project-relative path like src/app.ts, resolve it from ${cwd} instead of guessing parent directories.
+
+1. File discovery then read
+User: compare the auth flow
+Assistant: first locate the relevant files
+Tool: glob({"pattern":"src/**/*auth*.ts"})
+Tool: read({"file_path":"${cwd}/src/auth/service.ts"})
+
+2. Targeted search then exact text edit
+User: rename loginUser to signInUser
+Assistant: first find the exact occurrences
+Tool: grep({"pattern":"loginUser","path":"src"})
+Tool: edit({"file_path":"${cwd}/src/auth/service.ts","old_string":"loginUser","new_string":"signInUser"})
+
+3. Read a specific range
+User: inspect the reducer around line 120
+Assistant: read only the needed range
+Tool: read({"path":"${cwd}/src/store/reducer.ts:110-150"})
+
+4. Create a new file
+User: add a notes file
+Assistant: create the file directly
+Tool: write({"file":"${cwd}/notes.txt","text":"todo\\n"})
+
+Prefer these direct tool shapes over multi-step metadata reads or shell fallbacks.
+Prefer explicit absolute file_path values when the current working directory is known.`;
+}
+
 function getEnvBlock() {
   const cwd = process.cwd();
   let isGitRepo = false;
@@ -22,5 +58,7 @@ OS Version: ${os.version || os.release()}
 export function buildDefaultSystemPrompt(config = {}) {
   return `${getShellSystemPrompt(config?.shell?.default)}
 
+${getToolFewShotBlock()}
+
 ${getEnvBlock()}`;
 }

package/src/core/provider/openai-compatible.js

@@ -47,6 +47,16 @@ function normalizeToolCallArguments(argumentsText) {
   return '{}';
 }
 
+function normalizeIncomingToolCallArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') return argumentsValue;
+  if (argumentsValue == null) return '{}';
+  try {
+    return JSON.stringify(argumentsValue);
+  } catch {
+    return '{}';
+  }
+}
+
 function sanitizeGatewayMessages(messages) {
   const source = Array.isArray(messages) ? messages : [];
   return source
@@ -115,7 +125,18 @@ function buildPayload({ model, temperature, messages, tools, stream = false }) {
   return payload;
 }
 
-function buildFinalStreamResult(text, toolCallsByIndex, usage) {
+function hasTrailingToolContext(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  for (let index = source.length - 1; index >= 0; index -= 1) {
+    const message = source[index];
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'tool') return true;
+    if (message.role === 'assistant' || message.role === 'user') return false;
+  }
+  return false;
+}
+
+function buildFinalStreamResult(text, toolCallsByIndex, usage, messages) {
   const toolCalls = Array.from(toolCallsByIndex.entries())
     .sort((a, b) => a[0] - b[0])
     .map(([, tc], i) => ({
@@ -126,6 +147,13 @@ function buildFinalStreamResult(text, toolCallsByIndex, usage) {
     .filter((tc) => tc.name);
 
   if (!text && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage
+      };
+    }
     throw new Error('Gateway stream returned empty assistant response');
   }
 
@@ -216,7 +244,7 @@ export async function createChatCompletion({
   const toolCalls = (message.tool_calls || []).map((tc) => ({
     id: tc.id,
     name: tc.function?.name,
-    arguments: tc.function?.arguments || '{}'
+    arguments: normalizeIncomingToolCallArguments(tc.function?.arguments)
   }));
 
   if (!text && toolCalls.length === 0) {
@@ -280,7 +308,9 @@ export async function createChatCompletionStream({
       const current = toolCallsByIndex.get(idx) || emptyToolCall(idx);
       if (td.id) current.id = td.id;
       if (td.function?.name) current.name = `${current.name}${td.function.name}`;
-      if (td.function?.arguments) current.arguments = `${current.arguments}${td.function.arguments}`;
+      if (td.function?.arguments !== undefined) {
+        current.arguments = `${current.arguments}${normalizeIncomingToolCallArguments(td.function.arguments)}`;
+      }
       toolCallsByIndex.set(idx, current);
       if (onToolCallDelta) {
         onToolCallDelta({
@@ -293,5 +323,5 @@ export async function createChatCompletionStream({
     }
   }
 
-  return buildFinalStreamResult(text, toolCallsByIndex, usage);
+  return buildFinalStreamResult(text, toolCallsByIndex, usage, messages);
 }

package/src/core/shell-profile.js

@@ -123,11 +123,11 @@ export function getShellSystemPrompt(value) {
 # Using your tools
 
 ALWAYS prefer dedicated tools over raw shell commands:
-- Use read to inspect files — NEVER use cat, head, or tail via run
+- Use read to inspect files — NEVER use cat, head, or tail via run. read returns content directly by default; demo-style shapes like {file_path:"src/app.ts"}, {path:"src/app.ts:10-40"}, or {file_path:"src/app.ts", offset:10, limit:30} are accepted
 - Use grep to search file contents — NEVER use grep or rg via run
 - Use glob to find files by pattern — NEVER use find via run
-- Use edit to modify existing files — this is the DEFAULT path for code changes
-- Use write only for creating new files or complete rewrites (set full_file_rewrite=true for existing code files)
+- Use edit to modify existing files — this is the DEFAULT path for code changes. Demo-style aliases like {file_path:"src/app.ts", old_string:"foo", new_string:"bar"} are accepted
+- Use write only for creating new files or complete rewrites (set full_file_rewrite=true for existing code files). Aliases like {file:"notes.txt", text:"..."} are accepted
 - Use patch to apply unified diffs
 - Use run for one-shot shell commands: install, build, test, or other finite tasks
 - For long-running processes (dev servers, watchers), use start_service instead of run
@@ -140,6 +140,17 @@ For services: use start_service to launch, list_services/get_service_status/get_
 
 Some tools are loaded on demand. If a needed tool is not listed, call tool_search first to load it.
 
+Common tool call patterns:
+- Read a file: {path:"src/app.ts"} or {file_path:"src/app.ts", offset:20, limit:40}
+- Read a specific range inline: {path:"src/app.ts:20-60"}
+- Search text: {pattern:"loginUser", path:"src"} or {query:"loginUser", directory:"src"}
+- Find files: {pattern:"src/**/*.ts"} or {query:"src/**/*.ts"}
+- Edit exact text: {file_path:"src/app.ts", old_string:"foo", new_string:"bar"}
+- Edit with shorthand: {path:"src/app.ts", old_text:"foo", content:"bar"}
+- Write a new file: {file:"notes.txt", text:"..."} or {path:"src/page.tsx", content:"..."}
+- When the environment provides a Working directory, prefer absolute file_path values rooted there instead of guessing prefixes
+- If the user gives a relative path like src/app.ts, resolve it from the current Working directory rather than inventing ../ or sibling folders
+
 # Doing tasks
 
 - You are a terminal-first CLI coding agent, not a generic chat assistant

package/src/core/tools.js

@@ -119,6 +119,111 @@ function splitLines(text) {
   return String(text || '').split('\n');
 }
 
+function parseInlineReadRange(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const match = text.match(/^(.*?):(\d+)(?:-(\d+))?$/);
+  if (!match) return null;
+  const [, maybePath, startRaw, endRaw] = match;
+  if (!maybePath || /^(?:[A-Za-z])$/.test(maybePath)) return null;
+  const startLine = Number(startRaw);
+  const endLine = Number(endRaw || startRaw);
+  if (!Number.isFinite(startLine) || startLine <= 0) return null;
+  if (!Number.isFinite(endLine) || endLine < startLine) return null;
+  return {
+    path: maybePath,
+    start_line: startLine,
+    end_line: endLine
+  };
+}
+
+function normalizeReadArgs(rawArgs) {
+  const source =
+    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+      ? { ...rawArgs }
+      : { path: typeof rawArgs === 'string' ? rawArgs : '' };
+
+  const normalized = { ...source };
+  const aliasPath = String(source.path || source.file_path || source.file || source.target || '').trim();
+  if (aliasPath) normalized.path = aliasPath;
+
+  if (!Number.isFinite(Number(normalized.start_line)) && Number.isFinite(Number(source.offset))) {
+    normalized.start_line = Number(source.offset);
+  }
+
+  if (!Number.isFinite(Number(normalized.end_line)) && Number.isFinite(Number(source.limit))) {
+    const startLine = Number(normalized.start_line);
+    const limit = Number(source.limit);
+    if (startLine > 0 && limit > 0) {
+      normalized.end_line = startLine + limit - 1;
+    }
+  }
+
+  const inlineRange = parseInlineReadRange(normalized.path);
+  if (inlineRange) {
+    normalized.path = inlineRange.path;
+    if (!Number.isFinite(Number(normalized.start_line))) normalized.start_line = inlineRange.start_line;
+    if (!Number.isFinite(Number(normalized.end_line))) normalized.end_line = inlineRange.end_line;
+  }
+
+  return normalized;
+}
+
+function normalizePathArgs(rawArgs, aliases = []) {
+  const source =
+    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+      ? { ...rawArgs }
+      : { path: typeof rawArgs === 'string' ? rawArgs : '' };
+  const normalized = { ...source };
+  const keys = ['path', ...aliases];
+  for (const key of keys) {
+    const value = String(source?.[key] || '').trim();
+    if (value) {
+      normalized.path = value;
+      break;
+    }
+  }
+  return normalized;
+}
+
+function normalizePatternArgs(rawArgs, aliases = [], defaultPathAliases = []) {
+  const source =
+    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+      ? { ...rawArgs }
+      : { pattern: typeof rawArgs === 'string' ? rawArgs : '' };
+  const normalized = { ...source };
+  for (const key of ['pattern', ...aliases]) {
+    const value = String(source?.[key] || '').trim();
+    if (value) {
+      normalized.pattern = value;
+      break;
+    }
+  }
+  for (const key of ['path', ...defaultPathAliases]) {
+    const value = String(source?.[key] || '').trim();
+    if (value) {
+      normalized.path = value;
+      break;
+    }
+  }
+  return normalized;
+}
+
+function normalizeWriteArgs(rawArgs) {
+  const source =
+    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+      ? { ...rawArgs }
+      : { path: typeof rawArgs === 'string' ? rawArgs : '' };
+  const normalized = { ...source };
+  const filePath = String(source.path || source.file_path || source.file || '').trim();
+  if (filePath) normalized.path = filePath;
+  if (normalized.content == null) {
+    if (source.text != null) normalized.content = source.text;
+    if (source.new_content != null) normalized.content = source.new_content;
+  }
+  return normalized;
+}
+
 function findUniqueLineBlock(lines, blockContent) {
   const probeLines = splitLines(blockContent);
   if (probeLines.length === 0 || (probeLines.length === 1 && probeLines[0] === '')) return null;
@@ -665,16 +770,17 @@ async function getFileState(root, relativePath) {
 }
 
 async function readFile(root, args) {
-  const target = resolveInWorkspace(root, args?.path);
+  const normalizedArgs = normalizeReadArgs(args);
+  const target = resolveInWorkspace(root, normalizedArgs?.path);
   const stat = await fs.stat(target);
   const text = await fs.readFile(target, 'utf8');
   const lines = splitLines(text);
   const totalLines = lines.length;
-  const startLineRaw = Number(args?.start_line);
-  const endLineRaw = Number(args?.end_line);
-  const defaultLines = Number(args?.default_lines || 220);
-  const maxChars = Number(args?.max_chars || 24000);
-  const includeContent = Boolean(args?.include_content);
+  const startLineRaw = Number(normalizedArgs?.start_line);
+  const endLineRaw = Number(normalizedArgs?.end_line);
+  const defaultLines = Number(normalizedArgs?.default_lines || 220);
+  const maxChars = Number(normalizedArgs?.max_chars || 24000);
+  const wantsMetadataOnly = normalizedArgs?.metadata_only === true || normalizedArgs?.include_content === false;
 
   let startLine = Number.isFinite(startLineRaw) && startLineRaw > 0 ? startLineRaw : 1;
   let endLine =
@@ -684,12 +790,12 @@ async function readFile(root, args) {
   startLine = Math.max(1, Math.min(startLine, totalLines));
   endLine = Math.max(startLine, Math.min(endLine, totalLines));
 
-  const tokenSeed = `${args?.path}|${stat.size}|${stat.mtimeMs}|${startLine}|${endLine}`;
+  const tokenSeed = `${normalizedArgs?.path}|${stat.size}|${stat.mtimeMs}|${startLine}|${endLine}`;
   const readToken = sha1(tokenSeed).slice(0, 16);
 
-  if (!includeContent) {
+  if (wantsMetadataOnly) {
     return {
-      path: args?.path,
+      path: normalizedArgs?.path,
       phase: 'metadata',
       size_bytes: stat.size,
       modified_at: new Date(stat.mtimeMs).toISOString(),
@@ -701,21 +807,6 @@ async function readFile(root, args) {
     };
   }
 
-  if (String(args?.read_token || '') !== readToken) {
-    return {
-      path: args?.path,
-      phase: 'metadata',
-      error: 'read_token mismatch or missing',
-      size_bytes: stat.size,
-      modified_at: new Date(stat.mtimeMs).toISOString(),
-      total_lines: totalLines,
-      suggested_start_line: startLine,
-      suggested_end_line: endLine,
-      read_token: readToken,
-      next: 'Retry with include_content=true and read_token from latest metadata'
-    };
-  }
-
   let content = lines.slice(startLine - 1, endLine).join('\n');
   let truncated = false;
   if (maxChars > 0 && content.length > maxChars) {
@@ -725,14 +816,14 @@ async function readFile(root, args) {
 
   // Read deduplication: if same path+range+mtime was read before, return a short stub
   const isDuplicate = checkReadDedup(
-    args?.path,
+    normalizedArgs?.path,
     startLine,
     endLine,
     stat.mtimeMs
   );
   if (isDuplicate) {
     return {
-      path: args?.path,
+      path: normalizedArgs?.path,
       phase: 'content',
       start_line: startLine,
       end_line: endLine,
@@ -744,7 +835,7 @@ async function readFile(root, args) {
   }
 
   return {
-    path: args?.path,
+    path: normalizedArgs?.path,
     phase: 'content',
     start_line: startLine,
     end_line: endLine,
@@ -755,7 +846,8 @@ async function readFile(root, args) {
 }
 
 async function writeFile(root, args) {
-  const rawPath = String(args?.path || args?.file_path || '').trim();
+  const normalizedArgs = normalizeWriteArgs(args);
+  const rawPath = String(normalizedArgs?.path || '').trim();
   if (!rawPath) {
     throw new Error('write requires a file path like weather/WeatherForecast.js');
   }
@@ -778,18 +870,18 @@ async function writeFile(root, args) {
   } catch {
     existed = false;
   }
-  if (existed && !args?.append && !args?.full_file_rewrite && isCodeLikePath(rawPath)) {
+  if (existed && !normalizedArgs?.append && !normalizedArgs?.full_file_rewrite && isCodeLikePath(rawPath)) {
     throw new Error(
       'write blocks full overwrite for existing code files by default. Use grep/read -> edit for minimal edits, or pass full_file_rewrite=true when a whole-file rewrite is truly intended.'
     );
   }
   await fs.mkdir(path.dirname(target), { recursive: true });
-  if (args?.append) {
-    await fs.appendFile(target, args?.content || '', 'utf8');
+  if (normalizedArgs?.append) {
+    await fs.appendFile(target, normalizedArgs?.content || '', 'utf8');
   } else {
-    await fs.writeFile(target, args?.content || '', 'utf8');
+    await fs.writeFile(target, normalizedArgs?.content || '', 'utf8');
   }
-  const after = args?.append ? `${before}${args?.content || ''}` : args?.content || '';
+  const after = normalizedArgs?.append ? `${before}${normalizedArgs?.content || ''}` : normalizedArgs?.content || '';
   const beforeLines = splitLines(before);
   const afterLines = splitLines(after);
   let changeLine = 0;
@@ -805,7 +897,7 @@ async function writeFile(root, args) {
   return {
     ok: true,
     path: rawPath,
-    action: args?.append ? 'append' : existed ? 'overwrite' : 'create',
+    action: normalizedArgs?.append ? 'append' : existed ? 'overwrite' : 'create',
     changed_line: changeLine || Math.max(1, afterLines.length),
     diff_preview: previewLines.map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n')
   };
@@ -1208,12 +1300,13 @@ async function searchCode(root, args) {
 }
 
 async function grep(root, args) {
-  const pattern = String(args?.pattern || args?.query || '').trim();
+  const normalizedArgs = normalizePatternArgs(args, ['query', 'symbol', 'q'], ['directory', 'dir', 'cwd']);
+  const pattern = String(normalizedArgs?.pattern || '').trim();
   if (!pattern) throw new Error('grep requires pattern');
-  const maxResults = Math.max(1, Math.min(200, Number(args?.max_results || 50)));
-  const caseSensitive = Boolean(args?.case_sensitive);
-  const files = await walkTextFiles(root, args?.path || '.', normalizeFileTypes(args));
-  const regex = args?.regex
+  const maxResults = Math.max(1, Math.min(200, Number(normalizedArgs?.max_results || 50)));
+  const caseSensitive = Boolean(normalizedArgs?.case_sensitive);
+  const files = await walkTextFiles(root, normalizedArgs?.path || '.', normalizeFileTypes(normalizedArgs));
+  const regex = normalizedArgs?.regex
     ? new RegExp(pattern, caseSensitive ? 'g' : 'gi')
     : new RegExp(escapeRegex(pattern), caseSensitive ? 'g' : 'gi');
   const matches = [];
@@ -1242,12 +1335,13 @@ async function grep(root, args) {
 }
 
 async function glob(root, args) {
-  const pattern = String(args?.pattern || '').trim();
+  const normalizedArgs = normalizePatternArgs(args, ['glob', 'query'], ['directory', 'dir', 'cwd']);
+  const pattern = String(normalizedArgs?.pattern || '').trim();
   if (!pattern) throw new Error('glob requires pattern');
-  const maxResults = Math.max(1, Math.min(500, Number(args?.max_results || 200)));
+  const maxResults = Math.max(1, Math.min(500, Number(normalizedArgs?.max_results || 200)));
   const regex = globToRegex(pattern);
-  const entries = await walkWorkspaceEntries(root, args?.path || '.', {
-    includeHidden: Boolean(args?.include_hidden)
+  const entries = await walkWorkspaceEntries(root, normalizedArgs?.path || '.', {
+    includeHidden: Boolean(normalizedArgs?.include_hidden)
   });
   const matches = entries
     .filter((entry) => entry.type === 'file' && regex.test(entry.path))
@@ -1261,10 +1355,11 @@ async function glob(root, args) {
 }
 
 async function list(root, args) {
-  const relativePath = String(args?.path || '.').trim() || '.';
+  const normalizedArgs = normalizePathArgs(args, ['dir', 'directory', 'target']);
+  const relativePath = String(normalizedArgs?.path || '.').trim() || '.';
   const target = resolveInWorkspace(root, relativePath);
   const entries = await fs.readdir(target, { withFileTypes: true });
-  const includeHidden = Boolean(args?.include_hidden);
+  const includeHidden = Boolean(normalizedArgs?.include_hidden);
   const items = entries
     .filter((entry) => includeHidden || !entry.name.startsWith('.'))
     .map((entry) => ({
@@ -1552,6 +1647,8 @@ function normalizeEditTargetArgs(args = {}) {
       edit: normalizedEdit
     };
   }
+  const topLevelOldText = args?.old_text ?? args?.old_string;
+  const topLevelContent = args?.content;
   return {
     file,
     ast_target: args?.ast_target,
@@ -1560,7 +1657,7 @@ function normalizeEditTargetArgs(args = {}) {
       target: args?.target,
       new_content: args?.new_content ?? args?.content,
       old_text: args?.old_text,
-      new_text: args?.new_text,
+      new_text: args?.new_text ?? (topLevelOldText != null && topLevelContent != null ? topLevelContent : undefined),
       old_string: args?.old_string,
       new_string: args?.new_string,
       anchor_text: args?.anchor_text,
@@ -1754,18 +1851,22 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'read',
         description:
-          'Inspect a file. Call once for metadata and a read_token, then again with include_content=true and the same token to get content. Use this before editing. Do not use run with cat, head, or tail for file reads.',
+          'Inspect a file and return content directly by default. Demo-style aliases like file_path, offset, and limit are accepted. Use metadata_only=true only when you want file metadata without content. Do not use run with cat, head, or tail for file reads.',
         parameters: {
           type: 'object',
           properties: {
-            path: { type: 'string', description: 'File path to read' },
+            path: { type: 'string', description: 'File path to read. You can also include an inline range like src/app.ts:10-40.' },
+            file_path: { type: 'string', description: 'Alias for path' },
             start_line: { type: 'number', description: '1-based start line' },
             end_line: { type: 'number', description: 'Inclusive end line' },
+            offset: { type: 'number', description: 'Alias for start_line' },
+            limit: { type: 'number', description: 'Number of lines to read starting from offset/start_line' },
             max_chars: { type: 'number', description: 'Max chars to return' },
-            include_content: { type: 'boolean', description: 'Set true on the second call' },
-            read_token: { type: 'string', description: 'Token from the first call' }
+            include_content: { type: 'boolean', description: 'Legacy compatibility flag. Content is returned by default.' },
+            read_token: { type: 'string', description: 'Legacy compatibility token. No longer required for content reads.' },
+            metadata_only: { type: 'boolean', description: 'Set true to return metadata without content.' }
           },
-          required: ['path']
+          required: []
         }
       }
     },
@@ -1774,13 +1875,14 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'grep',
         description:
-          'Search file contents. Use this for code search before read or edit. Do not use run with grep or rg for normal code search.',
+          'Search file contents. Use this for code search before read or edit. Aliases like query and directory are accepted. Do not use run with grep or rg for normal code search.',
         parameters: {
           type: 'object',
           properties: {
             pattern: { type: 'string', description: 'Search pattern' },
             query: { type: 'string', description: 'Alias for pattern' },
             path: { type: 'string', description: 'Directory or file to search' },
+            directory: { type: 'string', description: 'Alias for path' },
             regex: { type: 'boolean', description: 'Treat pattern as regex' },
             case_sensitive: { type: 'boolean', description: 'Case-sensitive matching' },
             max_results: { type: 'number', description: 'Max matches to return' },
@@ -1796,12 +1898,14 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'glob',
         description:
-          'Find files by glob pattern. Use this for file discovery before read. Do not use run with find for normal file lookup.',
+          'Find files by glob pattern. Use this for file discovery before read. Aliases like query and directory are accepted. Do not use run with find for normal file lookup.',
         parameters: {
           type: 'object',
           properties: {
             pattern: { type: 'string', description: 'Glob pattern' },
             path: { type: 'string', description: 'Directory to search' },
+            query: { type: 'string', description: 'Alias for pattern' },
+            directory: { type: 'string', description: 'Alias for path' },
             include_hidden: { type: 'boolean', description: 'Include dotfiles' },
             max_results: { type: 'number', description: 'Max results' }
           },
@@ -1813,11 +1917,12 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       type: 'function',
       function: {
         name: 'list',
-        description: 'List files and directories in a workspace path. Use this for quick directory discovery before deeper reads.',
+        description: 'List files and directories in a workspace path. Use this for quick directory discovery before deeper reads. Aliases like directory are accepted, and plain string paths are tolerated by the runtime.',
         parameters: {
           type: 'object',
           properties: {
             path: { type: 'string', description: 'Directory path to list' },
+            directory: { type: 'string', description: 'Alias for path' },
             include_hidden: { type: 'boolean', description: 'Include dotfiles' }
           }
         }
@@ -1859,13 +1964,16 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'write',
         description:
-          'Create a new file or overwrite a file. Always include path (or file_path) and content. Use this for new files or explicit full rewrites only. Example: {path:"src/page.html", content:"..."} . If the file path is not decided yet, do not call write yet. Prefer edit for existing code changes.',
+          'Create a new file or overwrite a file. Always include path and content. Aliases like file, file_path, text, and new_content are accepted. Use this for new files or explicit full rewrites only. Example: {path:"src/page.html", content:"..."} . If the file path is not decided yet, do not call write yet. Prefer edit for existing code changes.',
         parameters: {
           type: 'object',
           properties: {
             path: { type: 'string', description: 'Required file path like src/app.js or pages/index.html. Never omit this.' },
             file_path: { type: 'string', description: 'Alias for path, compatible with simpler demo-style tool calls' },
+            file: { type: 'string', description: 'Alias for path' },
             content: { type: 'string', description: 'Content to write' },
+            text: { type: 'string', description: 'Alias for content' },
+            new_content: { type: 'string', description: 'Alias for content' },
             append: { type: 'boolean', description: 'Append instead of overwrite' },
             full_file_rewrite: { type: 'boolean', description: 'Set true for whole-file rewrites' }
           },

package/src/tui/chat-app.js

@@ -88,6 +88,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 +220,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 +355,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 || '{}'));
@@ -880,20 +1184,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 +1859,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 +1943,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 +2034,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 +2080,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,