@migor/cli 0.10.7 → 0.10.9

package/CHANGELOG.md

@@ -5,6 +5,95 @@
 （0.x 阶段：minor 可含破坏性变更，每个破坏性变更都在对应版本的「迁移」小节里写明）。
 决策的完整证据链在 `docs/spec.md` §10（带时间线的决策日志）。
 
+## [0.10.9] - 2026-11-12
+
+### 变更
+
+调试面板的**两个渲染面各补一格**：右栏「回复正文」支持 GFM 表格，调用树展开的工具出参能把
+**一整篇 Markdown** 渲染出来。无破坏性变更、无迁移动作。两包同步 0.10.8 → 0.10.9；
+`@migor/agentia` 此次仍只有版本常量变化（`src/` 一行未动），实际改动全在 CLI 面板与
+trace-view 渲染件。
+
+- **两个面缺的是两件事，来源是同一份真实素材**：右栏正文里 `###` 渲染出来了、表格却是一行行
+  `| # | 错误内容 |` 加 `|---|`；调用树里展开的 `tool.output` 干脆整篇是源文
+  （`<!-- 迁移自 … -->`、`# JS 错误巡检`、`|---|---|` 全在）。
+- **补 GFM 表格，并推翻当年那条「不做表格」的判断**：`markdown.ts` 头注当时明写「不做表格 /
+  任务列表 / 嵌套列表 —— 面板是调试视图，不是文档站」。**那个判断是错的**：agent 的产出里
+  「错误汇总 / 逐项统计 / 参数对照」天然就是表，砍掉它等于把最有信息量的几种结果打回源文，
+  读者被迫在脑子里做列对齐。
+- **成表的判据要两行同时成立、且列数相等**：只要「行里有 `|`」就成表，`a | b` 这种正文会被
+  吞成表头；只要「下一行像分隔行」就成表，`---` 分隔线下面那段会被吃掉。列按表头对齐
+  （缺列补空、多列丢掉），`\|` 是格子里的字面竖线，对齐三档走 `:--` / `--:` / `:--:`，
+  表格后紧跟的非 `|` 行立刻收尾（它没有围栏）。
+- **HTML 注释丢弃、可跨行**：真实素材开头三四行常是 `<!-- 迁移自 … -->` 这类作者旁注，让它们
+  以字面文本占掉首屏比不渲染更糟。**原文一个字节都不改** —— 隐藏只发生在渲染视图里；
+  **码块里的 `<!-- -->` 保留**：注释是注释，代码是代码。
+- **一整篇 Markdown 现在是「字符串」，原先没有任何落点**：SKILL.md、巡检报告这类工具出参展开后
+  是源文。现在走宿主注入 `createTraceView(root, { textBody })` —— 本包单独发布，反向
+  依赖 CLI 不可能；让它自带一份解析器，仓库里就有两份必然漂移的。
+- **「像不像 Markdown」的判据只认块级记号、且要两分**（围栏 / 表格各 2，标题 / 列表 / 引用各 1）。
+  **刻意不看行内记号**：`**kwargs` / `*args` 是 Python 源码里最常见的东西，按行内判会把整份
+  源码判成 Markdown，而段落合并会**毁掉它的缩进**。超 100k 不渲染。判错的代价不是「少渲染」，
+  是把一段本来好读的文本毁掉 ⇒ 宁漏不错（漏了还能看原文）。
+- **注入的正文只负责画、不再铺树**：`createFullView(value, { body })` 给了 body 就原样挂，头部
+  写 `string · N 字符` + `md` 标记（不与标记重复），「复制」取原文，`.tr-io` 仍持原文 ——
+  与结构化块走**同一条挂载路径**，否则「哪种正文」会从外观上分叉成两套。
+- **`textBody` 只在展开时调用、宿主抛错回落原文**：折叠态每条事件都重画整棵树，挂在那儿等于
+  每来一条事件就把所有历史正文白解析一遍；调试面板不该因为一条坏正文白屏。
+- ⚠️ **官网 Playground 不注入**（那里的工具出参保持原文）。这个不对称是**有意**的，写在
+  spec 里 —— 不写清楚就会在某个 PR 里被当成缺陷「顺手修掉」。
+
+### 新增：面板里的 Markdown（2026-11-12 ref-md-in-panel）
+
+- 决策见 `docs/spec.md` §10 2026-11-12 ref-md-in-panel，守卫登记见 `docs/guards.md` §1。
+- **验证**：CLI 252 → 257（表格 2、三种「像但不是」1、注释 1、接线 1）、trace-view
+  90 → 96（注入件 2、接线 4）。**反向验证 8 条各自咬住**：去掉列数相等 / 去掉 `\|` 转义 /
+  去掉跨行注释状态 / 把判据阈值降到 1；折叠态也调 `textBody` / 不把 body 交给块 / 忽略注入 /
+  去掉宿主抛错的兜底。
+- **顺带修一处守卫腐化**：trace-view 的「基线表不许重复键」用例原先按 `+ 2000` 字符切窗口，
+  表一长尾部条目就滑出射程而断言照样绿 —— 正是「守卫看起来在管、实际不管」。改成按对象字面量
+  的结束位置切。
+- 行数棘轮逐项登记在 `packages/cli/test/structure.test.mjs` 与
+  `packages/trace-view/test/structure.test.js`：`markdown.ts` 296→453、`inspector-page.html`
+  1493→1562、`view.js` 360→385、`full-view.js` 449→478、`trace-view.css` 375→386。
+
+## [0.10.8] - 2026-11-12
+
+### 变更
+
+调试面板展开态的**第二档**：字符串里套着的 JSON 也铺开。无破坏性变更、无迁移动作。
+两包同步 0.10.7 → 0.10.8；`@migor/agentia` 此次仍只有版本常量变化（`src/` 未动）。
+
+- **上一档解决的是「容器长什么样」，但真实 payload 里最常见的那一层不是容器**：工具把结构
+  `JSON.stringify` 后塞回文本字段（`tool.output.content`、MCP 的 text block、SSE 的 `data:`、
+  `content[0].text`）。这些值的类型是字符串 ⇒ 走纯文本老路 ⇒ 展开后是一串 `{\"a\":1`
+  的反斜杠汤，比 0.10.7 之前那个「一坨」更劝退。
+- **现在这类字符串也按容器铺开**，但**如实标出它原本是字符串**：行内打 `str→json` 标记，
+  根级头部写 `string · 232 字符 → object · 3 项`。只写解析后的规模，读者会以为工具真返回了对象。
+- **判据是首尾字符，不是「`JSON.parse` 成功」**：`"123"` / `"null"` / `"true"` 都能 parse，
+  把它们显示成数字 / 空值 / 布尔就是**改写工具返回的事实**。trim 后首尾须是 `{`…`}` 或
+  `[`…`]`，不吻合连 parse 都不试（普通文本占绝大多数，负路径不付反序列化成本）；超 100k 字符
+  不解析。
+- **只解析一层**：进了「解析出来的子树」就不再往下解析。一层套一层是真实现象，逐层展开会把
+  10KB 放大成十万个节点。
+- **表格里的格子不解析**：同构表已经放弃逐层展开，格子里放不下嵌套块。
+- 字符串根上点「复制」拿到的是**原始字符串**（能直接喂 `jq`），不是重排后的 JSON。
+
+### 新增：字符串里的 JSON 也铺开（2026-11-12 ref-trace-json-string）
+
+- **判据同源**：新导出 `hasStructuredBody(v)` 与块内共用同一份 `jsonInString`；`view.js` 用它
+  取代原先的 `typeof v === 'object'` ⇒「挂不挂块」与「块里画什么」不会分叉。
+  `createFullView` 与 `hasStructuredBody` 都进公共导出（bundle 导出面必须与 `src/index.js`
+  逐字一致，有 `test/bundle.test.js` 守着）。
+- **宿主侧无需改动**：本次没有新增静态件 —— `full-view.js` / `view.js` / `index.js` 都已在
+  CLI inspector 的 STATIC 白名单里，`dist/inspector` 随构建更新即可。
+- **验证**：trace-view 测试 75 → 90（+15）；反向验证 6 条各自咬住（摘标记 ⇒ 7 条红；
+  去「只解析一层」⇒ 嵌套用例红；接线退回「只认容器」⇒ 字符串出参挂块用例红；去 100k 上限 ⇒
+  超长用例红；去首尾先筛 ⇒ parse 计数与谓词两条红；头部只写解析后类型 ⇒ 头部用例红）。
+  另记一条**等价变异**的教训：第一版里「parse 结果再判类型」那段代码永远走不到（首尾判据
+  已经挡住标量字符串），任何用例都咬不住，已删除 —— 留着只会让下一个人以为那里有守卫。
+  决策见 `docs/spec.md` §10 2026-11-12 ref-trace-json-string，守卫登记见 `docs/guards.md` §1。
+
 ## [0.10.7] - 2026-11-12
 
 ### 变更
@@ -4472,7 +4561,9 @@ toolkit 142 / runtime 55 / engine 403 / container 10 / store 55 —— 全绿。
 首个公开发布：`@migor/agentia` + `@migor/cli`（scope `@migor/*`），两包版本同步。
 框架本体单包；CLI 独立成包（workspaces）。
 
-[Unreleased]: https://github.com/migoric/agentia/compare/v0.10.7...HEAD
+[Unreleased]: https://github.com/migoric/agentia/compare/v0.10.9...HEAD
+[0.10.9]: https://github.com/migoric/agentia/releases/tag/v0.10.9
+[0.10.8]: https://github.com/migoric/agentia/releases/tag/v0.10.8
 [0.10.7]: https://github.com/migoric/agentia/releases/tag/v0.10.7
 [0.10.6]: https://github.com/migoric/agentia/releases/tag/v0.10.6
 [0.10.5]: https://github.com/migoric/agentia/releases/tag/v0.10.5

package/dist/inspector/full-view.js

@@ -16,6 +16,15 @@
  *    吃掉 9 行。同构且各列都是标量时改成表格，表头一行、数据一行。
  * 3. **路径拿不到**：想引用 `results[0].name` 只能用手数层级。每个键悬停出一个 `⧉`，
  *    点一下把路径写进剪贴板（表头写的是 `results[*].name`，因为它是一整列）。
+ * 4. **字符串里套着的 JSON 读不了**（2026-11-12）：MCP 的 text block、SSE 的 `data:`、把结果
+ *    序列化后又塞回 `content` 的工具 —— 这些值的类型是**字符串**，此前只显示成一串
+ *    `{\"a\":1` 的反斜杠汤，比无缩进的 JSON 更难读。现在首尾是 `{`…`}` / `[`…`]` 且解析成功的
+ *    字符串按容器铺开，并在行里打 `str→json` 标记 —— 不标出来，读者会以为工具真的返回了对象。
+ * 5. **一整篇 Markdown 的字符串正文**（2026-11-12 晚）：工具出参的另一种常见形态就是一份
+ *    SKILL.md / 错误汇总报告，类型仍是字符串 ⇒ 展开后是 `# 标题`、`|---|---|`、
+ *    `<!-- 迁移自 … -->` 的源文。本件**不**自带解析器 —— 那会是仓库里的第二份，必然与宿主
+ *    那份漂移，所以只接受宿主渲染好的元素（`opts.body`），自己负责头部
+ *    （`string · N 字符 · md` + `md` 标记）与「复制取原文」。
  *
  * ## 边界（都是「不这么做就会坏」的地方，不是口味）
  *
@@ -35,6 +44,13 @@
  *   会原样复现（这正是 `view.js` 的 `expanded` 集合存在的原因）。
  * - **表格化只在"真的同构"时发生**：元素必须全是普通对象、键集完全一致、列数 1..6、
  *   每列都是标量。任一不满足就回落树形 —— 表格里没法逐层展开，判错一次就是**丢数据**。
+ * - **字符串里的 JSON 只解析一层，且必须标出来**：判据是**首尾字符**（`{`…`}` / `[`…`]`），
+ *   不是「`JSON.parse` 成功」—— `"123"` / `"null"` / `"true"` 都能 parse 成功，显示成
+ *   数字/空值/布尔就是**改写工具返回的事实**。解析结果内部的字符串**不再二次解析**：
+ *   一层套一层是业务里的真实现象（SSE data 里再套 JSON），逐层展开会让 10KB 变成十万个节点。
+ *   表格单元格也不解析 —— 同构表已经放弃了逐层展开，单元格里放不下嵌套块。
+ * - **宿主正文不再解析**：`opts.body` 给了就**原样用**。同一段内容既渲染又铺树，读者会看到
+ *   两套互相矛盾的呈现 —— 那比不做这一档更糟。所以这条判据只有一处（`createFullView`）。
  *
  * 零依赖、纯 DOM 构造（只用 createElement / appendChild / textContent / className /
  * dataset / innerHTML=''），与 view.js 共用同一套 DOM stub 跑测试。
@@ -50,6 +66,8 @@ const MAX_DEPTH = 6;
 const OPEN_DEPTH = 2;
 /** 表格最多几列：再多横向就没法看了，回落树形 */
 const MAX_COLS = 6;
+/** 多长的字符串才值得尝试从里面解析 JSON。再长的话，parse 与随后的渲染成本都不值得 */
+const MAX_JSON_STR = 100_000;
 
 function fvEl(tag, cls, text) {
   const node = document.createElement(tag);
@@ -73,6 +91,18 @@ function isStructured(v) {
   return v !== null && typeof v === 'object';
 }
 
+/**
+ * 有没有「结构化正文」可铺 —— 容器，或者**装着 JSON 的字符串**。
+ *
+ * 后者是业务里的常态：`tool.output` 的 `content` 常常就是 `JSON.stringify(...)` 的结果
+ * （工具把结构序列化后塞回文本字段，MCP 的 text block 更是如此）。此前这种值是字符串 ⇒
+ * 走纯文本老路 ⇒ 展开后是一串 `{\"a\":1` 的反斜杠汤。判据与 `jsonInString` 完全同一套，
+ * 所以「挂不挂块」与「块里画什么」不会跑偏。
+ */
+export function hasStructuredBody(v) {
+  return isStructured(v) || jsonInString(v) !== null;
+}
+
 /** 普通对象（排除数组与 null）—— 表格化与"容器"判定都只要这一种 */
 function isPlainObject(v) {
   return isStructured(v) && !Array.isArray(v);
@@ -114,6 +144,47 @@ function oneLine(v) {
   return `<${kind} · ${sizeOf(v)} 项> ${clipped}`;
 }
 
+/**
+ * 「字符串里套着 JSON」：返回解析出来的容器，其余（普通文本、标量字符串、坏 JSON）一律 `null`。
+ *
+ * 判据是**首尾字符**而不是「parse 成功」，这一条是这段代码的全部要害：`"123"`、`"null"`、
+ * `"true"` 都能被 `JSON.parse` 吃下去，但把它们显示成数字/空值/布尔，等于把工具返回的
+ * 字符串改写成另一种类型 —— 调试面板的第一职责是如实。所以先看 trim 后的首尾一个字符，
+ * 不吻合就连 parse 都不试（普通文本占绝大多数，省掉无谓的反序列化）。
+ * 截断过的 JSON（尾部被切掉）在这里自然失败，回落成原样字符串。
+ */
+function jsonInString(v) {
+  if (typeof v !== 'string' || v.length < 2 || v.length > MAX_JSON_STR) return null;
+  const t = v.trim();
+  if (t.length < 2) return null;
+  const head = t[0];
+  const tail = t[t.length - 1];
+  if (!((head === '{' && tail === '}') || (head === '[' && tail === ']'))) return null;
+  try {
+    // 首尾判据已经保证了这里解析出来的必然是对象或数组（`{`…`}` / `[`…`]`），
+    // 所以不再重复判类型 —— 那会是一条永远走不到的防御分支（变异测试实测盖不住）。
+    return JSON.parse(t);
+  } catch {
+    return null;
+  }
+}
+
+/** 「这个字符串里装着 JSON」的标记。**必须显眼**：不标出来，读者会以为工具真的返回了对象。
+ *  title 顺带交代两件容易误会的事 —— 原文还在（`.tr-io` 与块内原值），路径需先 parse 这一层。 */
+function jsonBadge() {
+  const b = fvEl('span', 'tr-full-json', 'str→json');
+  b.title = '这个值是字符串，内容是 JSON（已按对象展示；内部路径需先 JSON.parse 这一层）';
+  return b;
+}
+
+/** 「这段正文被渲染过」的标记。同样**必须显眼**：Markdown 源文与渲染结果差得很远，
+ *  不标出来，读者会以为工具返回的就是排好版的样子（而它返回的是一串 `#` 与 `|`）。 */
+function mdBadge() {
+  const b = fvEl('span', 'tr-full-md', 'md');
+  b.title = '这个字符串按 Markdown 渲染（原文仍在 .tr-io 与「复制」里，一字未改）';
+  return b;
+}
+
 /** 子键的 JSON 路径：对象用 `.key`，数组用 `[i]`。根是空串，所以 `[0]` 不会变成 `.[0]` */
 function pathOf(parent, key, isArr) {
   return isArr ? `${parent}[${key}]` : parent ? `${parent}.${key}` : key;
@@ -246,8 +317,9 @@ function startRow(depth, caret) {
  * @param {any} v         值
  * @param {number} depth  当前缩进层级（根为 0）
  * @param {string} path   当前值的 JSON 路径（根为空串）
+ * @param {boolean} [allowParse] 还允许不允从字符串里解析 JSON（进了「解析出来的子树」就为 false）
  */
-function renderInto(ctx, v, depth, path) {
+function renderInto(ctx, v, depth, path, allowParse = true) {
   const box = ctx.body;
 
   if (!isStructured(v)) {
@@ -272,14 +344,19 @@ function renderInto(ctx, v, depth, path) {
     const child = isArr ? v[Number(k)] : v[k];
     const keyText = isArr ? `[${k}]` : `${k}:`;
     const childPath = pathOf(path, k, isArr);
+    // 字符串里套着的 JSON（`content: "{\"rows\":[...]}"`）⇒ 按容器铺。`allowParse` 只在
+    // 「刚从一个字符串里解析出来」的那棵子树上为 false —— 一层套一层会放大成十万个节点。
+    const parsed = allowParse ? jsonInString(child) : null;
+    const val = parsed ?? child;
+    const fromJson = parsed !== null;
     // 「能否折叠」只看三件事：是容器、非空、没到深度上限 —— 与下面几个分支同一套判据。
     // 先算出来是为了让箭头槽位在起行时就有正确字形（叶子行留空格位，键名才会对齐）。
-    const foldable = isStructured(child) && sizeOf(child) > 0 && depth < MAX_DEPTH;
+    const foldable = isStructured(val) && sizeOf(val) > 0 && depth < MAX_DEPTH;
     const open = foldable && isOpen(ctx.fold, childPath, depth);
     const row = startRow(depth, foldable ? (open ? '▾' : '▸') : '');
 
     // 叶子：同一行里写完（缩进 + 键名 + 路径 + 值）
-    if (!isStructured(child)) {
+    if (!isStructured(val)) {
       const p = primitive(child);
       row.appendChild(fvEl('span', 'tr-full-key', keyText));
       row.appendChild(pathBtn(childPath));
@@ -291,28 +368,31 @@ function renderInto(ctx, v, depth, path) {
     // 深度用尽 ⇒ 整体压成一行（并标明它是个容器），避免缩进吃掉全部宽度
     if (depth >= MAX_DEPTH) {
       row.appendChild(fvEl('span', 'tr-full-key', keyText));
-      row.appendChild(fvEl('span', 'tr-full-null', ' ' + oneLine(child)));
+      if (fromJson) row.appendChild(jsonBadge());
+      row.appendChild(fvEl('span', 'tr-full-null', ' ' + oneLine(val)));
       box.appendChild(row);
       continue;
     }
 
-    // 空容器：留一对括号，别让它看起来像"展开失败"
-    if (sizeOf(child) === 0) {
+    // 空容器：留一对括号，别让它看起来像"展开失败"（`"{}"` / `"[]"` 这类字符串也走这里）
+    if (sizeOf(val) === 0) {
       row.appendChild(fvEl('span', 'tr-full-key', keyText));
-      row.appendChild(fvEl('span', 'tr-full-null', Array.isArray(child) ? ' []' : ' {}'));
+      if (fromJson) row.appendChild(jsonBadge());
+      row.appendChild(fvEl('span', 'tr-full-null', Array.isArray(val) ? ' []' : ' {}'));
       box.appendChild(row);
       continue;
     }
 
     row.appendChild(fvEl('span', 'tr-full-key', keyText));
     row.appendChild(pathBtn(childPath));
+    if (fromJson) row.appendChild(jsonBadge());
     if (!open) {
-      const kind = Array.isArray(child) ? 'array' : 'object';
-      row.appendChild(fvEl('span', 'tr-full-hint', ` { ${kind} · ${sizeOf(child)} 项 }`));
-    } else if (Array.isArray(child) && tableColsOf(child)) {
+      const kind = Array.isArray(val) ? 'array' : 'object';
+      row.appendChild(fvEl('span', 'tr-full-hint', ` { ${kind} · ${sizeOf(val)} 项 }`));
+    } else if (Array.isArray(val) && tableColsOf(val)) {
       // 成表时行内不铺子项，只在键名后标一句规模 —— 否则 `▾ targets:` 后面直接跟着表格，
       // 看不出这是个数组、也看不出表格是不是全部内容（是不是被截断了）
-      row.appendChild(fvEl('span', 'tr-full-hint', ` array · ${child.length} 项`));
+      row.appendChild(fvEl('span', 'tr-full-hint', ` array · ${val.length} 项`));
     }
     row.dataset.fold = childPath;
     row.addEventListener('click', (e) => {
@@ -323,7 +403,7 @@ function renderInto(ctx, v, depth, path) {
     });
     box.appendChild(row);
 
-    if (open) renderInto(ctx, child, depth + 1, childPath);
+    if (open) renderInto(ctx, val, depth + 1, childPath, fromJson ? false : allowParse);
   }
 
   if (keys.length > show.length) {
@@ -336,33 +416,62 @@ function renderInto(ctx, v, depth, path) {
 /**
  * 建一个结构化正文块。
  * @param {any} value  `ev.full` 的**原值**（不是序列化后的字符串）
- * @param {{fold?: Map<string, boolean>}} [opts]
+ * @param {{fold?: Map<string, boolean>, body?: Element}} [opts]
  *   `fold` 是**调用方持有**的折叠状态（路径 → 是否展开）。省略时本块自建一份，
  *   此时折叠状态活不过下一次「全量重建」—— 只对一次性渲染（测试、静态快照）够用。
+ *   `body` 是**宿主已经渲染好的正文**（如 Markdown）：给了就原样用，不再走缩进/折叠，
+ *   本件只负责头部（类型 / `md` 标记 / 复制）与挂载位置。
  * @returns {Element}  `.tr-full` 块；调用方负责 append 到展开行之后
  */
 export function createFullView(value, opts = {}) {
   const fold = opts.fold instanceof Map ? opts.fold : new Map();
+  /* 宿主渲染好的正文。**判据只此一处**：给了它就不解析、不铺树 —— 否则会同时出现
+     两套呈现（宿主渲染的正文 + 本件又在旁边铺一遍原值），那比不渲染更糟。 */
+  const injected = opts.body && typeof opts.body === 'object' ? opts.body : null;
+
+  // 根是字符串 ⇒ 只有「里面装着 JSON」或「宿主认得的正文」才会进来。
+  // 头部同时写出**两件事**：它原本是字符串（字符数）、以及它是怎么被展示的 —— 只写后者，
+  // 读者会以为工具真的返回了对象 / 排好版的正文。
+  const parsedRoot = injected ? null : jsonInString(value);
+  const root = parsedRoot ?? value;
+  const fromJson = parsedRoot !== null;
 
   const box = fvEl('div', 'tr-full');
-  box.dataset.kind = Array.isArray(value) ? 'array' : 'object';
+  box.dataset.kind = injected ? 'md' : Array.isArray(root) ? 'array' : 'object';
 
   const head = fvEl('div', 'tr-full-head');
-  head.appendChild(fvEl('span', 'tr-full-type', typeLabelOf(value)));
+  const label = typeLabelOf(root);
+  let typeText = label;
+  if (fromJson) typeText = `string · ${value.length} 字符 → ${label}`;
+  // 注入正文时不写「→ md」：紧跟其后的 `md` 标记已经说了这件事，
+  // 同一行说两遍只会让人以为其中一个另有含义（字符数才是头部真正要补的信息）
+  else if (injected) typeText = `string · ${value.length} 字符`;
+  head.appendChild(fvEl('span', 'tr-full-type', typeText));
+  if (fromJson) head.appendChild(jsonBadge());
+  if (injected) head.appendChild(mdBadge());
   const copy = fvEl('span', 'tr-full-copy', '复制');
   copy.dataset.copy = '1';
-  copy.addEventListener('click', () => copyInto(copy, safeStringify(value), '已复制'));
+  // 字符串根复制的是**原文**（拿到手能直接喂 jq / 贴回上游）；容器根复制的是缩进后的 JSON
+  copy.addEventListener('click', () =>
+    copyInto(copy, fromJson || injected ? String(value) : safeStringify(root), '已复制'),
+  );
   head.appendChild(copy);
   box.appendChild(head);
 
   const body = fvEl('div', 'tr-full-body');
-  const ctx = { body, fold, repaint: null };
-  // 只重画正文（不动头部）：折叠不需要重建整棵树，滚动位置与头部反馈都留着
-  ctx.repaint = () => {
-    body.innerHTML = '';
-    renderInto(ctx, value, 0, '');
-  };
-  ctx.repaint();
+  if (injected) {
+    // 宿主正文自带排版；本件的缩进/折叠那一套对散文没有意义（它也没有「路径」可复制）
+    body.appendChild(injected);
+  } else {
+    const ctx = { body, fold, repaint: null };
+    // 只重画正文（不动头部）：折叠不需要重建整棵树，滚动位置与头部反馈都留着
+    ctx.repaint = () => {
+      body.innerHTML = '';
+      // 根若是从字符串解析来的，它的子树不再二次解析（只解析一层，防嵌套放大）
+      renderInto(ctx, root, 0, '', !fromJson);
+    };
+    ctx.repaint();
+  }
 
   box.appendChild(body);
   return box;

package/dist/inspector/index.js

@@ -12,8 +12,9 @@ export {
 } from './view.js';
 export { playTrace } from './fromTrace.js';
 export { summarizeTrace, renderSummary } from './summary.js';
-/* 结构化正文块（2026-11-11）：`full` 是对象/数组时，渲染器会给展开行挂上这个块。
- * 单独导出是因为它是**纯函数式的 DOM 构造**（入参 → 元素），宿主可以拿它渲染任意值 ——
- * 而 bundle 的导出面必须与这里逐字一致（`test/bundle.test.js`），所以内部件不进公共面、
- * 这一件必须进。 */
-export { createFullView } from './full-view.js';
+/* 结构化正文块（2026-11-11）：`full` 是容器时，渲染器会给展开行挂上这个块；
+ * 2026-11-12 起「装着 JSON 的字符串」也走这条路（`hasStructuredBody` 是同一个判据，
+ * 宿主自己判断要不要挂块时用得上）。单独导出是因为它是**纯函数式的 DOM 构造**
+ * （入参 → 元素），宿主可以拿它渲染任意值 —— 而 bundle 的导出面必须与这里逐字一致
+ * （`test/bundle.test.js`），所以内部件不进公共面、这两件必须进。 */
+export { createFullView, hasStructuredBody } from './full-view.js';

package/dist/inspector/trace-view.bundle.js

@@ -21,6 +21,15 @@
  *    吃掉 9 行。同构且各列都是标量时改成表格，表头一行、数据一行。
  * 3. **路径拿不到**：想引用 `results[0].name` 只能用手数层级。每个键悬停出一个 `⧉`，
  *    点一下把路径写进剪贴板（表头写的是 `results[*].name`，因为它是一整列）。
+ * 4. **字符串里套着的 JSON 读不了**（2026-11-12）：MCP 的 text block、SSE 的 `data:`、把结果
+ *    序列化后又塞回 `content` 的工具 —— 这些值的类型是**字符串**，此前只显示成一串
+ *    `{\"a\":1` 的反斜杠汤，比无缩进的 JSON 更难读。现在首尾是 `{`…`}` / `[`…`]` 且解析成功的
+ *    字符串按容器铺开，并在行里打 `str→json` 标记 —— 不标出来，读者会以为工具真的返回了对象。
+ * 5. **一整篇 Markdown 的字符串正文**（2026-11-12 晚）：工具出参的另一种常见形态就是一份
+ *    SKILL.md / 错误汇总报告，类型仍是字符串 ⇒ 展开后是 `# 标题`、`|---|---|`、
+ *    `<!-- 迁移自 … -->` 的源文。本件**不**自带解析器 —— 那会是仓库里的第二份，必然与宿主
+ *    那份漂移，所以只接受宿主渲染好的元素（`opts.body`），自己负责头部
+ *    （`string · N 字符 · md` + `md` 标记）与「复制取原文」。
  *
  * ## 边界（都是「不这么做就会坏」的地方，不是口味）
  *
@@ -40,6 +49,13 @@
  *   会原样复现（这正是 `view.js` 的 `expanded` 集合存在的原因）。
  * - **表格化只在"真的同构"时发生**：元素必须全是普通对象、键集完全一致、列数 1..6、
  *   每列都是标量。任一不满足就回落树形 —— 表格里没法逐层展开，判错一次就是**丢数据**。
+ * - **字符串里的 JSON 只解析一层，且必须标出来**：判据是**首尾字符**（`{`…`}` / `[`…`]`），
+ *   不是「`JSON.parse` 成功」—— `"123"` / `"null"` / `"true"` 都能 parse 成功，显示成
+ *   数字/空值/布尔就是**改写工具返回的事实**。解析结果内部的字符串**不再二次解析**：
+ *   一层套一层是业务里的真实现象（SSE data 里再套 JSON），逐层展开会让 10KB 变成十万个节点。
+ *   表格单元格也不解析 —— 同构表已经放弃了逐层展开，单元格里放不下嵌套块。
+ * - **宿主正文不再解析**：`opts.body` 给了就**原样用**。同一段内容既渲染又铺树，读者会看到
+ *   两套互相矛盾的呈现 —— 那比不做这一档更糟。所以这条判据只有一处（`createFullView`）。
  *
  * 零依赖、纯 DOM 构造（只用 createElement / appendChild / textContent / className /
  * dataset / innerHTML=''），与 view.js 共用同一套 DOM stub 跑测试。
@@ -55,6 +71,8 @@ const MAX_DEPTH = 6;
 const OPEN_DEPTH = 2;
 /** 表格最多几列：再多横向就没法看了，回落树形 */
 const MAX_COLS = 6;
+/** 多长的字符串才值得尝试从里面解析 JSON。再长的话，parse 与随后的渲染成本都不值得 */
+const MAX_JSON_STR = 100_000;
 
 function fvEl(tag, cls, text) {
   const node = document.createElement(tag);
@@ -78,6 +96,18 @@ function isStructured(v) {
   return v !== null && typeof v === 'object';
 }
 
+/**
+ * 有没有「结构化正文」可铺 —— 容器，或者**装着 JSON 的字符串**。
+ *
+ * 后者是业务里的常态：`tool.output` 的 `content` 常常就是 `JSON.stringify(...)` 的结果
+ * （工具把结构序列化后塞回文本字段，MCP 的 text block 更是如此）。此前这种值是字符串 ⇒
+ * 走纯文本老路 ⇒ 展开后是一串 `{\"a\":1` 的反斜杠汤。判据与 `jsonInString` 完全同一套，
+ * 所以「挂不挂块」与「块里画什么」不会跑偏。
+ */
+function hasStructuredBody(v) {
+  return isStructured(v) || jsonInString(v) !== null;
+}
+
 /** 普通对象（排除数组与 null）—— 表格化与"容器"判定都只要这一种 */
 function isPlainObject(v) {
   return isStructured(v) && !Array.isArray(v);
@@ -119,6 +149,47 @@ function oneLine(v) {
   return `<${kind} · ${sizeOf(v)} 项> ${clipped}`;
 }
 
+/**
+ * 「字符串里套着 JSON」：返回解析出来的容器，其余（普通文本、标量字符串、坏 JSON）一律 `null`。
+ *
+ * 判据是**首尾字符**而不是「parse 成功」，这一条是这段代码的全部要害：`"123"`、`"null"`、
+ * `"true"` 都能被 `JSON.parse` 吃下去，但把它们显示成数字/空值/布尔，等于把工具返回的
+ * 字符串改写成另一种类型 —— 调试面板的第一职责是如实。所以先看 trim 后的首尾一个字符，
+ * 不吻合就连 parse 都不试（普通文本占绝大多数，省掉无谓的反序列化）。
+ * 截断过的 JSON（尾部被切掉）在这里自然失败，回落成原样字符串。
+ */
+function jsonInString(v) {
+  if (typeof v !== 'string' || v.length < 2 || v.length > MAX_JSON_STR) return null;
+  const t = v.trim();
+  if (t.length < 2) return null;
+  const head = t[0];
+  const tail = t[t.length - 1];
+  if (!((head === '{' && tail === '}') || (head === '[' && tail === ']'))) return null;
+  try {
+    // 首尾判据已经保证了这里解析出来的必然是对象或数组（`{`…`}` / `[`…`]`），
+    // 所以不再重复判类型 —— 那会是一条永远走不到的防御分支（变异测试实测盖不住）。
+    return JSON.parse(t);
+  } catch {
+    return null;
+  }
+}
+
+/** 「这个字符串里装着 JSON」的标记。**必须显眼**：不标出来，读者会以为工具真的返回了对象。
+ *  title 顺带交代两件容易误会的事 —— 原文还在（`.tr-io` 与块内原值），路径需先 parse 这一层。 */
+function jsonBadge() {
+  const b = fvEl('span', 'tr-full-json', 'str→json');
+  b.title = '这个值是字符串，内容是 JSON（已按对象展示；内部路径需先 JSON.parse 这一层）';
+  return b;
+}
+
+/** 「这段正文被渲染过」的标记。同样**必须显眼**：Markdown 源文与渲染结果差得很远，
+ *  不标出来，读者会以为工具返回的就是排好版的样子（而它返回的是一串 `#` 与 `|`）。 */
+function mdBadge() {
+  const b = fvEl('span', 'tr-full-md', 'md');
+  b.title = '这个字符串按 Markdown 渲染（原文仍在 .tr-io 与「复制」里，一字未改）';
+  return b;
+}
+
 /** 子键的 JSON 路径：对象用 `.key`，数组用 `[i]`。根是空串，所以 `[0]` 不会变成 `.[0]` */
 function pathOf(parent, key, isArr) {
   return isArr ? `${parent}[${key}]` : parent ? `${parent}.${key}` : key;
@@ -251,8 +322,9 @@ function startRow(depth, caret) {
  * @param {any} v         值
  * @param {number} depth  当前缩进层级（根为 0）
  * @param {string} path   当前值的 JSON 路径（根为空串）
+ * @param {boolean} [allowParse] 还允许不允从字符串里解析 JSON（进了「解析出来的子树」就为 false）
  */
-function renderInto(ctx, v, depth, path) {
+function renderInto(ctx, v, depth, path, allowParse = true) {
   const box = ctx.body;
 
   if (!isStructured(v)) {
@@ -277,14 +349,19 @@ function renderInto(ctx, v, depth, path) {
     const child = isArr ? v[Number(k)] : v[k];
     const keyText = isArr ? `[${k}]` : `${k}:`;
     const childPath = pathOf(path, k, isArr);
+    // 字符串里套着的 JSON（`content: "{\"rows\":[...]}"`）⇒ 按容器铺。`allowParse` 只在
+    // 「刚从一个字符串里解析出来」的那棵子树上为 false —— 一层套一层会放大成十万个节点。
+    const parsed = allowParse ? jsonInString(child) : null;
+    const val = parsed ?? child;
+    const fromJson = parsed !== null;
     // 「能否折叠」只看三件事：是容器、非空、没到深度上限 —— 与下面几个分支同一套判据。
     // 先算出来是为了让箭头槽位在起行时就有正确字形（叶子行留空格位，键名才会对齐）。
-    const foldable = isStructured(child) && sizeOf(child) > 0 && depth < MAX_DEPTH;
+    const foldable = isStructured(val) && sizeOf(val) > 0 && depth < MAX_DEPTH;
     const open = foldable && isOpen(ctx.fold, childPath, depth);
     const row = startRow(depth, foldable ? (open ? '▾' : '▸') : '');
 
     // 叶子：同一行里写完（缩进 + 键名 + 路径 + 值）
-    if (!isStructured(child)) {
+    if (!isStructured(val)) {
       const p = primitive(child);
       row.appendChild(fvEl('span', 'tr-full-key', keyText));
       row.appendChild(pathBtn(childPath));
@@ -296,28 +373,31 @@ function renderInto(ctx, v, depth, path) {
     // 深度用尽 ⇒ 整体压成一行（并标明它是个容器），避免缩进吃掉全部宽度
     if (depth >= MAX_DEPTH) {
       row.appendChild(fvEl('span', 'tr-full-key', keyText));
-      row.appendChild(fvEl('span', 'tr-full-null', ' ' + oneLine(child)));
+      if (fromJson) row.appendChild(jsonBadge());
+      row.appendChild(fvEl('span', 'tr-full-null', ' ' + oneLine(val)));
       box.appendChild(row);
       continue;
     }
 
-    // 空容器：留一对括号，别让它看起来像"展开失败"
-    if (sizeOf(child) === 0) {
+    // 空容器：留一对括号，别让它看起来像"展开失败"（`"{}"` / `"[]"` 这类字符串也走这里）
+    if (sizeOf(val) === 0) {
       row.appendChild(fvEl('span', 'tr-full-key', keyText));
-      row.appendChild(fvEl('span', 'tr-full-null', Array.isArray(child) ? ' []' : ' {}'));
+      if (fromJson) row.appendChild(jsonBadge());
+      row.appendChild(fvEl('span', 'tr-full-null', Array.isArray(val) ? ' []' : ' {}'));
       box.appendChild(row);
       continue;
     }
 
     row.appendChild(fvEl('span', 'tr-full-key', keyText));
     row.appendChild(pathBtn(childPath));
+    if (fromJson) row.appendChild(jsonBadge());
     if (!open) {
-      const kind = Array.isArray(child) ? 'array' : 'object';
-      row.appendChild(fvEl('span', 'tr-full-hint', ` { ${kind} · ${sizeOf(child)} 项 }`));
-    } else if (Array.isArray(child) && tableColsOf(child)) {
+      const kind = Array.isArray(val) ? 'array' : 'object';
+      row.appendChild(fvEl('span', 'tr-full-hint', ` { ${kind} · ${sizeOf(val)} 项 }`));
+    } else if (Array.isArray(val) && tableColsOf(val)) {
       // 成表时行内不铺子项，只在键名后标一句规模 —— 否则 `▾ targets:` 后面直接跟着表格，
       // 看不出这是个数组、也看不出表格是不是全部内容（是不是被截断了）
-      row.appendChild(fvEl('span', 'tr-full-hint', ` array · ${child.length} 项`));
+      row.appendChild(fvEl('span', 'tr-full-hint', ` array · ${val.length} 项`));
     }
     row.dataset.fold = childPath;
     row.addEventListener('click', (e) => {
@@ -328,7 +408,7 @@ function renderInto(ctx, v, depth, path) {
     });
     box.appendChild(row);
 
-    if (open) renderInto(ctx, child, depth + 1, childPath);
+    if (open) renderInto(ctx, val, depth + 1, childPath, fromJson ? false : allowParse);
   }
 
   if (keys.length > show.length) {
@@ -341,33 +421,62 @@ function renderInto(ctx, v, depth, path) {
 /**
  * 建一个结构化正文块。
  * @param {any} value  `ev.full` 的**原值**（不是序列化后的字符串）
- * @param {{fold?: Map<string, boolean>}} [opts]
+ * @param {{fold?: Map<string, boolean>, body?: Element}} [opts]
  *   `fold` 是**调用方持有**的折叠状态（路径 → 是否展开）。省略时本块自建一份，
  *   此时折叠状态活不过下一次「全量重建」—— 只对一次性渲染（测试、静态快照）够用。
+ *   `body` 是**宿主已经渲染好的正文**（如 Markdown）：给了就原样用，不再走缩进/折叠，
+ *   本件只负责头部（类型 / `md` 标记 / 复制）与挂载位置。
  * @returns {Element}  `.tr-full` 块；调用方负责 append 到展开行之后
  */
 function createFullView(value, opts = {}) {
   const fold = opts.fold instanceof Map ? opts.fold : new Map();
+  /* 宿主渲染好的正文。**判据只此一处**：给了它就不解析、不铺树 —— 否则会同时出现
+     两套呈现（宿主渲染的正文 + 本件又在旁边铺一遍原值），那比不渲染更糟。 */
+  const injected = opts.body && typeof opts.body === 'object' ? opts.body : null;
+
+  // 根是字符串 ⇒ 只有「里面装着 JSON」或「宿主认得的正文」才会进来。
+  // 头部同时写出**两件事**：它原本是字符串（字符数）、以及它是怎么被展示的 —— 只写后者，
+  // 读者会以为工具真的返回了对象 / 排好版的正文。
+  const parsedRoot = injected ? null : jsonInString(value);
+  const root = parsedRoot ?? value;
+  const fromJson = parsedRoot !== null;
 
   const box = fvEl('div', 'tr-full');
-  box.dataset.kind = Array.isArray(value) ? 'array' : 'object';
+  box.dataset.kind = injected ? 'md' : Array.isArray(root) ? 'array' : 'object';
 
   const head = fvEl('div', 'tr-full-head');
-  head.appendChild(fvEl('span', 'tr-full-type', typeLabelOf(value)));
+  const label = typeLabelOf(root);
+  let typeText = label;
+  if (fromJson) typeText = `string · ${value.length} 字符 → ${label}`;
+  // 注入正文时不写「→ md」：紧跟其后的 `md` 标记已经说了这件事，
+  // 同一行说两遍只会让人以为其中一个另有含义（字符数才是头部真正要补的信息）
+  else if (injected) typeText = `string · ${value.length} 字符`;
+  head.appendChild(fvEl('span', 'tr-full-type', typeText));
+  if (fromJson) head.appendChild(jsonBadge());
+  if (injected) head.appendChild(mdBadge());
   const copy = fvEl('span', 'tr-full-copy', '复制');
   copy.dataset.copy = '1';
-  copy.addEventListener('click', () => copyInto(copy, safeStringify(value), '已复制'));
+  // 字符串根复制的是**原文**（拿到手能直接喂 jq / 贴回上游）；容器根复制的是缩进后的 JSON
+  copy.addEventListener('click', () =>
+    copyInto(copy, fromJson || injected ? String(value) : safeStringify(root), '已复制'),
+  );
   head.appendChild(copy);
   box.appendChild(head);
 
   const body = fvEl('div', 'tr-full-body');
-  const ctx = { body, fold, repaint: null };
-  // 只重画正文（不动头部）：折叠不需要重建整棵树，滚动位置与头部反馈都留着
-  ctx.repaint = () => {
-    body.innerHTML = '';
-    renderInto(ctx, value, 0, '');
-  };
-  ctx.repaint();
+  if (injected) {
+    // 宿主正文自带排版；本件的缩进/折叠那一套对散文没有意义（它也没有「路径」可复制）
+    body.appendChild(injected);
+  } else {
+    const ctx = { body, fold, repaint: null };
+    // 只重画正文（不动头部）：折叠不需要重建整棵树，滚动位置与头部反馈都留着
+    ctx.repaint = () => {
+      body.innerHTML = '';
+      // 根若是从字符串解析来的，它的子树不再二次解析（只解析一层，防嵌套放大）
+      renderInto(ctx, root, 0, '', !fromJson);
+    };
+    ctx.repaint();
+  }
 
   box.appendChild(body);
   return box;
@@ -393,10 +502,16 @@ function createFullView(value, opts = {}) {
  * 宿主需提供的 CSS 变量：--ice --faint --text（见 trace-view.css）。
  */
 
-/* 展开态的正文有两种形状，由 `full` 的类型决定（2026-11-11）：
- *   - 字符串 → 老路：`.tr-io` 里放原文，靠 `.tr-open` 换行（纯文本正文、官网模拟回放）；
- *   - 对象/数组 → 追加一个 `.tr-full` 结构化块（折叠 / 成表 / 路径复制），`.tr-io` 由 CSS 隐藏。
- * 两档并存是刻意的：字符串那条路有 test/style.test.js 的两个不变量守着（最小宽度、caret 常显），
+/* 展开态的正文有三种形状（2026-11-11，2026-11-12 扩了两档）：
+ *   - 纯文本字符串 → 老路：`.tr-io` 里放原文，靠 `.tr-open` 换行（纯文本正文、官网模拟回放）；
+ *   - 对象/数组 → 追加一个 `.tr-full` 结构化块（折叠 / 成表 / 路径复制），`.tr-io` 由 CSS 隐藏；
+ *   - **装着 JSON 的字符串**（`content: "{\"rows\":[...]}"`，工具把结构序列化后塞回文本字段）
+ *     → 同上一档，块头写明「string · N 字符 → object · M 项」并打 `str→json` 标记；
+ *   - **一整篇 Markdown 的字符串**（工具出参就是一份 SKILL.md / 报告）→ 由宿主注入的
+ *     `opts.textBody(text)` 渲染成正文块，块头打 `md` 标记。注入是刻意的：本包是独立
+ *     发布单元，解析器只有一份（在宿主里），两边各带一份必然漂移。
+ * 判据与块内完全同源（`hasStructuredBody`），「挂不挂块」与「块里画什么」因此不会跑偏。
+ * 前两档并存是刻意的：纯文本那条路有 test/style.test.js 的两个不变量守着（最小宽度、caret 常显），
  * 全换成本件会让那两个守卫失去落点。 */
 
 
@@ -464,6 +579,9 @@ function createTraceView(rootEl, opts = {}) {
   let price = opts.price ?? null;
   const onUsage = opts.onUsage ?? null;
   const usageEls = opts.usage ?? null;
+  /* 字符串正文的宿主渲染器（可选）：`(text) => Element | null`。返回 null = 「不是那种
+     正文，保持原文」。本包不自带 Markdown 解析器 —— 见文件头注。 */
+  const textBody = typeof opts.textBody === 'function' ? opts.textBody : null;
 
   let traceRoot = null;
   const spanMap = new Map();
@@ -491,6 +609,17 @@ function createTraceView(rootEl, opts = {}) {
     renderTrace();
   }
 
+  /** 宿主渲染器包一层：**只在展开时调用**（折叠态每条事件都会重画，挂在那儿等于白解析
+   *  一遍所有历史正文）；宿主抛错也不许让整棵树白屏 —— 回落原文即可。 */
+  function textBodyOf(v) {
+    if (!textBody || typeof v !== 'string') return null;
+    try {
+      return textBody(v) || null;
+    } catch {
+      return null;
+    }
+  }
+
   function renderTrace() {
     rootEl.innerHTML = '';
     const rows = [];
@@ -523,10 +652,13 @@ function createTraceView(rootEl, opts = {}) {
         // 这一格整个不渲染，别把「无工具」显示成假工具名（.tr-name 是 flex:none，.tr-io 自然占满）
         if (ev.tool) row.appendChild(el('span', 'tr-name', ev.tool));
         // 展开态用全文（ev.full），折叠态用摘要（ev.text）—— 折叠态因此与加展开之前逐字一致。
-        // `full` 是对象/数组时（2026-11-11）：`.tr-io` 仍放**原文**（结构化块挂在行后、由 CSS
-        // 隐藏本格），所以「展开拿到的是原文而不是 62 字符摘要」这条不变量原样成立。
-        const structured = ev.full !== null && typeof ev.full === 'object';
-        const fullText = structured ? rawArg(ev.full) : ev.full || '';
+        // `full` 是对象/数组、装着 JSON 的字符串、或宿主认得的正文（Markdown）时
+        // （2026-11-11 / 2026-11-12）：`.tr-io` 仍放**原文**（结构化块挂在行后、由 CSS 隐藏本格），
+        // 所以「展开拿到的是原文而不是 62 字符摘要」这条不变量原样成立。
+        const structured = hasStructuredBody(ev.full);
+        const mdBody = open && !structured ? textBodyOf(ev.full) : null;
+        const blocked = structured || mdBody !== null;
+        const fullText = blocked ? rawArg(ev.full) : ev.full || '';
         const io = el('span', 'tr-io', (open ? fullText : ev.text) || '');
         // 展开后正文已在行里，再挂一个占满整行的原生 tooltip 只会挡视线
         io.title = open ? '' : ev.text || '';
@@ -534,7 +666,7 @@ function createTraceView(rootEl, opts = {}) {
         if (ev.full) {
           row.dataset.expandable = '1'; // 可展开标记：CSS 靠它出 caret / cursor，测试靠它找行
           row.appendChild(el('span', 'tr-caret', open ? '▾' : '▸'));
-          if (open) row.className += ' tr-open' + (structured ? ' tr-structured' : '');
+          if (open) row.className += ' tr-open' + (blocked ? ' tr-structured' : '');
           row.addEventListener('click', () => {
             if (!hasSelection()) toggleExpand(ev.key);
           });
@@ -543,13 +675,15 @@ function createTraceView(rootEl, opts = {}) {
         // 结构化正文是**兄弟块**而不是 `.tr-io` 的子节点：行是 flex + nowrap，
         // 塞进去会把树的列对齐打乱；独立成块才能自己换行、自己缩进。
         // 折叠状态按事件键取一份带进去（2026-11-11 晚）：块每次重建都 new，状态不能放块里。
-        if (open && structured) {
+        // `body` 是宿主渲染好的正文（Markdown），交给同一条挂载路径：块头、复制、`.tr-io`
+        // 隐藏这些行为必须一致，否则「哪种正文」会从**外观**上分叉成两套。
+        if (open && blocked) {
           let fold = folds.get(ev.key);
           if (!fold) {
             fold = new Map();
             folds.set(ev.key, fold);
           }
-          rootEl.appendChild(createFullView(ev.full, { fold }));
+          rootEl.appendChild(createFullView(ev.full, { fold, body: mdBody }));
         }
         return;
       }
@@ -1089,10 +1223,11 @@ function escapeHtml(s) {
 
 
 
-/* 结构化正文块（2026-11-11）：`full` 是对象/数组时，渲染器会给展开行挂上这个块。
- * 单独导出是因为它是**纯函数式的 DOM 构造**（入参 → 元素），宿主可以拿它渲染任意值 ——
- * 而 bundle 的导出面必须与这里逐字一致（`test/bundle.test.js`），所以内部件不进公共面、
- * 这一件必须进。 */
+/* 结构化正文块（2026-11-11）：`full` 是容器时，渲染器会给展开行挂上这个块；
+ * 2026-11-12 起「装着 JSON 的字符串」也走这条路（`hasStructuredBody` 是同一个判据，
+ * 宿主自己判断要不要挂块时用得上）。单独导出是因为它是**纯函数式的 DOM 构造**
+ * （入参 → 元素），宿主可以拿它渲染任意值 —— 而 bundle 的导出面必须与这里逐字一致
+ * （`test/bundle.test.js`），所以内部件不进公共面、这两件必须进。 */
 
 export {
   CAP_ICO,
@@ -1102,6 +1237,7 @@ export {
   fmtArg,
   fmtMs,
   fmtNum,
+  hasStructuredBody,
   playTrace,
   rawArg,
   renderSummary,

package/dist/inspector/trace-view.css

@@ -284,6 +284,29 @@
 .tr-full-hint {
   color: var(--faint);
 }
+/* 「这个字符串里装着 JSON」的标记。它不是装饰，是**事实的一部分**：没有它，读者会以为
+   工具真的返回了对象。所以常显、不等 hover，也不跟 .tr-full-hint 一样隐形 —— 但保持
+   低对比度，避免每行都在喊。 */
+.tr-full-json {
+  color: var(--faint);
+  font-size: 10px;
+  line-height: 1.4;
+  border: 1px solid #2c2c32;
+  border-radius: 3px;
+  padding: 0 4px;
+  margin-right: 4px;
+}
+/* `md`：这段正文被 Markdown 渲染过（2026-11-12）。与 `str→json` 同一套外观 ——
+   两者都是「你看到的不是原样」的告示，样式分叉只会让人以为它们是不同性质的东西。 */
+.tr-full-md {
+  color: var(--faint);
+  font-size: 10px;
+  line-height: 1.4;
+  border: 1px solid #2c2c32;
+  border-radius: 3px;
+  padding: 0 4px;
+  margin-right: 4px;
+}
 /* `⧉` 复制路径：hover 才露。与 .tr-caret 的区别是**它暴露的是动作、不是信息** ——
    路径的内容（键名）始终写在行里，常显只会给每行多一个字形噪声。
    没有剪贴板实现时照样显示、点了不谎报成功（见 full-view.js 的 copyInto）。 */

package/dist/inspector/view.js

@@ -17,12 +17,18 @@
  * 宿主需提供的 CSS 变量：--ice --faint --text（见 trace-view.css）。
  */
 
-/* 展开态的正文有两种形状，由 `full` 的类型决定（2026-11-11）：
- *   - 字符串 → 老路：`.tr-io` 里放原文，靠 `.tr-open` 换行（纯文本正文、官网模拟回放）；
- *   - 对象/数组 → 追加一个 `.tr-full` 结构化块（折叠 / 成表 / 路径复制），`.tr-io` 由 CSS 隐藏。
- * 两档并存是刻意的：字符串那条路有 test/style.test.js 的两个不变量守着（最小宽度、caret 常显），
+/* 展开态的正文有三种形状（2026-11-11，2026-11-12 扩了两档）：
+ *   - 纯文本字符串 → 老路：`.tr-io` 里放原文，靠 `.tr-open` 换行（纯文本正文、官网模拟回放）；
+ *   - 对象/数组 → 追加一个 `.tr-full` 结构化块（折叠 / 成表 / 路径复制），`.tr-io` 由 CSS 隐藏；
+ *   - **装着 JSON 的字符串**（`content: "{\"rows\":[...]}"`，工具把结构序列化后塞回文本字段）
+ *     → 同上一档，块头写明「string · N 字符 → object · M 项」并打 `str→json` 标记；
+ *   - **一整篇 Markdown 的字符串**（工具出参就是一份 SKILL.md / 报告）→ 由宿主注入的
+ *     `opts.textBody(text)` 渲染成正文块，块头打 `md` 标记。注入是刻意的：本包是独立
+ *     发布单元，解析器只有一份（在宿主里），两边各带一份必然漂移。
+ * 判据与块内完全同源（`hasStructuredBody`），「挂不挂块」与「块里画什么」因此不会跑偏。
+ * 前两档并存是刻意的：纯文本那条路有 test/style.test.js 的两个不变量守着（最小宽度、caret 常显），
  * 全换成本件会让那两个守卫失去落点。 */
-import { createFullView } from './full-view.js';
+import { createFullView, hasStructuredBody } from './full-view.js';
 
 export const CAP_ICO = { tool: '⚙', skill: '◆', prompt: '¶', subagent: '⊕' };
 
@@ -88,6 +94,9 @@ export function createTraceView(rootEl, opts = {}) {
   let price = opts.price ?? null;
   const onUsage = opts.onUsage ?? null;
   const usageEls = opts.usage ?? null;
+  /* 字符串正文的宿主渲染器（可选）：`(text) => Element | null`。返回 null = 「不是那种
+     正文，保持原文」。本包不自带 Markdown 解析器 —— 见文件头注。 */
+  const textBody = typeof opts.textBody === 'function' ? opts.textBody : null;
 
   let traceRoot = null;
   const spanMap = new Map();
@@ -115,6 +124,17 @@ export function createTraceView(rootEl, opts = {}) {
     renderTrace();
   }
 
+  /** 宿主渲染器包一层：**只在展开时调用**（折叠态每条事件都会重画，挂在那儿等于白解析
+   *  一遍所有历史正文）；宿主抛错也不许让整棵树白屏 —— 回落原文即可。 */
+  function textBodyOf(v) {
+    if (!textBody || typeof v !== 'string') return null;
+    try {
+      return textBody(v) || null;
+    } catch {
+      return null;
+    }
+  }
+
   function renderTrace() {
     rootEl.innerHTML = '';
     const rows = [];
@@ -147,10 +167,13 @@ export function createTraceView(rootEl, opts = {}) {
         // 这一格整个不渲染，别把「无工具」显示成假工具名（.tr-name 是 flex:none，.tr-io 自然占满）
         if (ev.tool) row.appendChild(el('span', 'tr-name', ev.tool));
         // 展开态用全文（ev.full），折叠态用摘要（ev.text）—— 折叠态因此与加展开之前逐字一致。
-        // `full` 是对象/数组时（2026-11-11）：`.tr-io` 仍放**原文**（结构化块挂在行后、由 CSS
-        // 隐藏本格），所以「展开拿到的是原文而不是 62 字符摘要」这条不变量原样成立。
-        const structured = ev.full !== null && typeof ev.full === 'object';
-        const fullText = structured ? rawArg(ev.full) : ev.full || '';
+        // `full` 是对象/数组、装着 JSON 的字符串、或宿主认得的正文（Markdown）时
+        // （2026-11-11 / 2026-11-12）：`.tr-io` 仍放**原文**（结构化块挂在行后、由 CSS 隐藏本格），
+        // 所以「展开拿到的是原文而不是 62 字符摘要」这条不变量原样成立。
+        const structured = hasStructuredBody(ev.full);
+        const mdBody = open && !structured ? textBodyOf(ev.full) : null;
+        const blocked = structured || mdBody !== null;
+        const fullText = blocked ? rawArg(ev.full) : ev.full || '';
         const io = el('span', 'tr-io', (open ? fullText : ev.text) || '');
         // 展开后正文已在行里，再挂一个占满整行的原生 tooltip 只会挡视线
         io.title = open ? '' : ev.text || '';
@@ -158,7 +181,7 @@ export function createTraceView(rootEl, opts = {}) {
         if (ev.full) {
           row.dataset.expandable = '1'; // 可展开标记：CSS 靠它出 caret / cursor，测试靠它找行
           row.appendChild(el('span', 'tr-caret', open ? '▾' : '▸'));
-          if (open) row.className += ' tr-open' + (structured ? ' tr-structured' : '');
+          if (open) row.className += ' tr-open' + (blocked ? ' tr-structured' : '');
           row.addEventListener('click', () => {
             if (!hasSelection()) toggleExpand(ev.key);
           });
@@ -167,13 +190,15 @@ export function createTraceView(rootEl, opts = {}) {
         // 结构化正文是**兄弟块**而不是 `.tr-io` 的子节点：行是 flex + nowrap，
         // 塞进去会把树的列对齐打乱；独立成块才能自己换行、自己缩进。
         // 折叠状态按事件键取一份带进去（2026-11-11 晚）：块每次重建都 new，状态不能放块里。
-        if (open && structured) {
+        // `body` 是宿主渲染好的正文（Markdown），交给同一条挂载路径：块头、复制、`.tr-io`
+        // 隐藏这些行为必须一致，否则「哪种正文」会从**外观**上分叉成两套。
+        if (open && blocked) {
           let fold = folds.get(ev.key);
           if (!fold) {
             fold = new Map();
             folds.set(ev.key, fold);
           }
-          rootEl.appendChild(createFullView(ev.full, { fold }));
+          rootEl.appendChild(createFullView(ev.full, { fold, body: mdBody }));
         }
         return;
       }

package/dist/inspector-page.html

@@ -180,6 +180,20 @@
       .md blockquote { margin: 0 0 6px; padding-left: 9px; border-left: 2px solid var(--border); color: var(--muted); }
       .md a { color: var(--ice); }
       .md hr { border: 0; border-top: 1px solid var(--border); margin: 8px 0; }
+      /* 表格（2026-11-12）：右栏只有 ~400px，内边距压到 3px 6px，列多时还能读；
+         对齐用类名，不用 inline style（与「innerHTML 只许一处」同类纪律）。 */
+      .md-table { border-collapse: collapse; margin: 0 0 6px; font-size: 11.5px; }
+      .md-table:last-child { margin-bottom: 0; }
+      .md-table th, .md-table td { border: 1px solid var(--border); padding: 3px 6px; }
+      .md-table th { background: var(--card); color: var(--text); font-weight: 600; }
+      .md-table .md-right { text-align: right; }
+      .md-table .md-center { text-align: center; }
+      .md-table .md-left { text-align: left; }
+      /* trace 树里的 Markdown 正文（2026-11-12）：树本身是 11px，正文块跟着收紧一档；
+         字体不换 —— 一块正文突然换成无衬线，会和相邻的行错开视觉基线。 */
+      .md-trace { font-size: 11.5px; line-height: 1.55; }
+      .md-trace .md-h { font-size: 12px; margin: 8px 0 3px; }
+      .md-trace .md-table { font-size: 11px; }
       /* 正文用无衬线正文栈（模型输出是散文，等宽栈读它更累）；码块与行内码仍是等宽。
          挂在 `.md-wrap`（渲染器的包装节点）而不是 `#reply .md, .turn .md`：单一类选择器
          既不用管特异性排序，也让「哪块是模型正文」只由一处决定。 */
@@ -352,7 +366,7 @@
 
     <script type="module">
       import { createTraceView, playTrace, summarizeTrace, renderSummary } from './index.js';
-      import { parseMarkdown } from './markdown.js';
+      import { parseMarkdown, looksLikeMarkdown } from './markdown.js';
       import {
         HISTORY_DRAFT,
         applyTraceEvent,
@@ -423,12 +437,17 @@
       const view = createTraceView(traceEl, {
         // 无公开单价 → 不估算成本；只展示 token
         usage: { in: $('u-in'), out: $('u-out') },
+        // 展开的工具出参若是 Markdown（SKILL.md / 报告），渲染成正文而不是源文；
+        // 判据与解析器只有一份（markdown.ts），见 traceTextBody 的口径注
+        textBody: traceTextBody,
       });
 
       // 并排 A/B 的**第二棵**树。刻意不共用 `view`：`createTraceView` 绑一个容器 +
       // 一个 usage 出口，两棵树塞进同一容器会互相清空（trace-view 的 `playTrace` 是
       // 整容器替换式的）。共用 `u-in`/`u-out` 也无意义 —— 那两个读数属于「正在看的那条」。
-      const view2 = createTraceView(trace2El);
+      // `textBody` 与主树用**同一个**：同一份 trace 在两栏里必须长成同一个样子，
+      // 否则「并排看差异」会先看见渲染差异。
+      const view2 = createTraceView(trace2El, { textBody: traceTextBody });
 
       // ---------- 并排 A/B（档 B） ----------
 
@@ -871,6 +890,37 @@
               list.appendChild(li);
             }
             el.appendChild(list);
+          } else if (b.type === 'table') {
+            /* 表格（2026-11-12）：错误汇总 / 逐项统计天然成表，一律渲染。
+               对齐走类名（`md-left` / `md-right` / `md-center`），不写 inline style ——
+               全页对 style 属性的写入为 0，这条和「innerHTML 只许一处」同一类纪律。 */
+            const table = document.createElement('table');
+            table.className = 'md-table';
+            const thead = document.createElement('thead');
+            const htr = document.createElement('tr');
+            b.header.forEach((cell, ci) => {
+              const th = document.createElement('th');
+              const al = b.align[ci];
+              if (al) th.className = 'md-' + al;
+              appendInline(th, cell);
+              htr.appendChild(th);
+            });
+            thead.appendChild(htr);
+            table.appendChild(thead);
+            const tbody = document.createElement('tbody');
+            for (const row of b.rows) {
+              const tr = document.createElement('tr');
+              row.forEach((cell, ci) => {
+                const td = document.createElement('td');
+                const al = b.align[ci];
+                if (al) td.className = 'md-' + al;
+                appendInline(td, cell);
+                tr.appendChild(td);
+              });
+              tbody.appendChild(tr);
+            }
+            table.appendChild(tbody);
+            el.appendChild(table);
           } else if (b.type === 'quote') {
             const q = document.createElement('blockquote');
             appendInline(q, b.inline);
@@ -885,6 +935,25 @@
         }
       }
 
+      /**
+       * trace 树里「一整篇 Markdown」的字符串正文 —— 挂给 trace-view 的 `textBody` 钩子。
+       *
+       * 工具出参的另一种常见形态就是一份 SKILL.md / 错误汇总报告：类型是**字符串** ⇒
+       * 之前只能走 `.tr-io` 的原文，展开后是 `<!-- 迁移自 … -->`、`# 标题`、`|---|---|`
+       * 的源文。这里把它渲染成正文（`<!-- -->` 已在解析层丢弃）。
+       *
+       * 返回 `null` 表示「这不是 Markdown，保持原文」。判据与解析器都只有一份，在
+       * `markdown.ts`：trace-view 是**独立发布包**，不能反向依赖 CLI，所以走**注入**
+       * 而不是让它自己再带一份解析器 —— 两份必然漂移。
+       */
+      function traceTextBody(text) {
+        if (!looksLikeMarkdown(text)) return null;
+        const box = document.createElement('div');
+        box.className = 'md md-trace';
+        renderMarkdownInto(box, text);
+        return box;
+      }
+
       /**
        * 一段**模型正文**（最终回复 / 助手轮）→ 填进 `wrap`。
        *

package/dist/markdown.js

@@ -15,15 +15,22 @@
  *
  * 支持的子集（刻意不做的都在「不做」里）：
  * - 块：`#` 标题（1–6 级）、围栏码块（``` / ~~~，带语言标注）、无序/有序列表（**一层**）、
- *   引用（合并成一段正文）、`---` 分隔线、段落
+ *   引用（合并成一段正文）、`---` 分隔线、**GFM 表格**（表头 / 分隔行 / 对齐 / `\|` 转义）、段落
  * - 行内：行内码、`**粗**`、`*斜*`、`[文字](链接)`、`<https://…>` 自动链接
+ * - **HTML 注释被丢弃**（`<!-- … -->`，可跨行）：注释不是正文。真实素材里最常见的就是
+ *   「迁移自 …」「TODO: 这条规则已废弃」这类作者旁注，让它们以字面文本占掉开头三四行，
+ *   比不渲染更糟。原文一个字节都不改（调用方手里仍是原串）⇒ 「隐藏」只发生在**渲染视图**里。
  *
  * 不做（都是刻意的，不是漏）：
- * - **不做 HTML 透传**（安全前提，见上）
- * - 不做表格 / 任务列表 / 嵌套列表 / 脚注 / 数学 —— 面板是调试视图，不是文档站
+ * - **不做 HTML 透传**（安全前提，见上）—— 注释是唯一的例外，且是**丢掉**而不是渲染
+ * - **不做任务列表 / 嵌套列表 / 脚注 / 数学** —— 面板是调试视图，不是文档站
  * - 不做 setext 标题（`===` 下划线式）—— 与分隔线歧义大、收益小
  * - 不做图片（`![]()`）—— 面板**不去外网取图**：一次 run 的正文不该触发网络请求
  * - 不做**词内** `_` 强调（`read_file_tool` 原样显示）—— 与 CommonMark 同口径，见 `parseInline`
+ *
+ * ⚠️ 表格是 2026-11-12 补的（原先明写「不做表格」）。**那个判断是错的**：agent 的产出里
+ * 「错误汇总 / 逐项统计 / 参数对照」天然就是表，砍掉表格等于把最有信息量的几种结果打回
+ * 一行行 `| a | b |` 加上 `|---|---|` 的源文 —— 面板的读者被迫在脑子里做列对齐。
  */
 /**
  * 链接协议白名单。**这是安全边界，不是风格选择**：
@@ -43,6 +50,14 @@ const QUOTE = /^\s{0,3}>\s?(.*)$/;
 const UL = /^(\s*)([-*+])\s+(.*)$/;
 const OL = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
 const BLANK = /^\s*$/;
+/**
+ * 表格的分隔行：`| --- | :--: |` / `--- | ---` 两种写法都收。
+ * 至少**两列**（`(\|…)+` 强制的）—— 单列「表格」在面板里就是一段带竖线的文本，
+ * 成表只会白占一行表头，还容易被 `a | b` 这种正文误判。
+ */
+const TABLE_SEP = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/;
+/** 「这个字符串值不值得渲染」的长度上限（见 `looksLikeMarkdown`）—— 几百 KB 逐行建 DOM 只会卡住面板 */
+const MAX_RENDER_CHARS = 100_000;
 /** 「单词字符」：`_` 的词内排除用它判边界（与 CommonMark 的 intraword 规则同口径） */
 const WORD_CHAR = /[A-Za-z0-9_]/;
 /** 下标可能越界（`text[-1]` / `text[len]` 都是 `undefined`）⇒ 越界一律当「不是单词字符」 */
@@ -52,15 +67,18 @@ function isWordChar(ch) {
 /**
  * 把一段 Markdown 文本解析成块序列。
  *
- * 三条与「真 Markdown」不同但**刻意**的口径：
+ * 四条与「真 Markdown」不同但**刻意**的口径：
  * - 缩进 ≥2 空格的续行归上一条列表项（列表只解析**一层**：更深一层当正文，不递归建树）；
  * - 未闭合的围栏码块吃掉到文末（**不静默丢内容** —— 模型被截断时最常见的就是这个形态）；
- * - 引用（`>`）合并成**一段正文**（面板里引用几乎总是模型在引日志，逐行建块只会更碎）。
+ * - 引用（`>`）合并成**一段正文**（面板里引用几乎总是模型在引日志，逐行建块只会更碎）；
+ * - 表格按**表头**宽度对齐：缺的列补空、多出来的列丢掉（与 GFM 同口径）。表格之后紧接的
+ *   非 `|` 行立刻收尾 —— 表格没有围栏，边界只能靠「下一行还像不像表格」来判断。
  */
 export function parseMarkdown(text) {
     const src = String(text ?? '').replace(/\r\n?/g, '\n');
     const lines = src.split('\n');
     const blocks = [];
+    const comment = { open: false };
     let i = 0;
     let para = [];
     const flushPara = () => {
@@ -72,7 +90,9 @@ export function parseMarkdown(text) {
             blocks.push({ type: 'p', inline: parseInline(joined, 0) });
     };
     while (i < lines.length) {
-        const line = lines[i];
+        // 注释先剥掉再看这一行是什么（围栏码块的内容由下面的内层循环整段吞掉，不会走到这里 ⇒
+        // 码块里的 `<!-- … -->` 原样保留，这正是「代码是字面量」的意思）
+        const line = stripComments(lines[i], comment);
         // —— 围栏码块 ——
         const fence = FENCE.exec(line);
         if (fence) {
@@ -159,6 +179,34 @@ export function parseMarkdown(text) {
             blocks.push({ type: 'list', ordered, items });
             continue;
         }
+        // —— 表格（GFM）：表头行 + 分隔行**同时**成立才算 ——
+        // 两条都要，是这条判据的全部要害：只要「行里有 `|`」就成表，`a | b` 这种正文会被
+        // 吞成一行表头；只要「下一行像分隔行」就成表，`---` 分隔线下面那段会被吃掉。
+        if (isTableStart(line, lines[i + 1])) {
+            flushPara();
+            const header = splitRow(line).map((c) => parseInline(c, 0));
+            const align = splitRow(stripComments(lines[i + 1], { open: comment.open })).map(alignOf);
+            const rows = [];
+            i += 2;
+            while (i < lines.length) {
+                // 表格没有围栏：边界只能靠「下一行还像不像表格」。空白、另一个块的起始、
+                // 不含 `|` 的行，三者任一条都收尾（否则后面的正文会被当成格子吃掉）。
+                const raw = lines[i];
+                if (!raw.includes('|') || BLANK.test(raw))
+                    break;
+                if (FENCE.test(raw) || HR.test(raw) || HEADING.test(raw) || QUOTE.test(raw))
+                    break;
+                if (UL.test(raw) || olAt(raw))
+                    break;
+                const cells = splitRow(raw).slice(0, header.length);
+                while (cells.length < header.length)
+                    cells.push('');
+                rows.push(cells.map((c) => parseInline(c, 0)));
+                i++;
+            }
+            blocks.push({ type: 'table', align, header, rows });
+            continue;
+        }
         // —— 其余：段落（连续非空行合并，行内换行保留） ——
         para.push(line.trim());
         i++;
@@ -166,6 +214,122 @@ export function parseMarkdown(text) {
     flushPara();
     return blocks;
 }
+/**
+ * 剥掉 HTML 注释（可跨行）。`state.open` 跨行携带 —— 块级解析是逐行扫的，
+ * 没有这个开关，一段被空行隔开的三行注释会被当成三段正文（每段都带着半截 `<!--`）。
+ *
+ * 只在**非码块**的行上调用。码块内容由围栏那段内层循环整段吞掉，走不到这里 ——
+ * 所以「代码里的 `<!-- -->` 原样保留」不是靠额外判断，是靠调用点。
+ */
+function stripComments(line, state) {
+    let s = line;
+    for (;;) {
+        if (state.open) {
+            const end = s.indexOf('-->');
+            if (end < 0)
+                return '';
+            s = s.slice(end + 3);
+            state.open = false;
+            continue;
+        }
+        const start = s.indexOf('<!--');
+        if (start < 0)
+            return s;
+        const end = s.indexOf('-->', start + 4);
+        if (end < 0) {
+            state.open = true;
+            return s.slice(0, start);
+        }
+        s = s.slice(0, start) + s.slice(end + 3);
+    }
+}
+/**
+ * 一行表格 → 格子文本（已 trim，`\|` 解成 `|`）。
+ * 首尾的定界竖线去掉；**但**以 `\|` 结尾时不能去 —— 那是最后一个格子里的字面竖线。
+ */
+function splitRow(line) {
+    let s = line.trim();
+    if (s.startsWith('|'))
+        s = s.slice(1);
+    if (s.endsWith('|') && !s.endsWith('\\|'))
+        s = s.slice(0, -1);
+    const cells = [];
+    let buf = '';
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === '\\' && s[i + 1] === '|') {
+            buf += '|';
+            i++;
+            continue;
+        }
+        if (c === '|') {
+            cells.push(buf.trim());
+            buf = '';
+            continue;
+        }
+        buf += c;
+    }
+    cells.push(buf.trim());
+    return cells;
+}
+/** 分隔行的单个格子 → 对齐方式 */
+function alignOf(cell) {
+    const t = cell.trim();
+    const left = t.startsWith(':');
+    const right = t.endsWith(':');
+    if (left && right)
+        return 'center';
+    if (right)
+        return 'right';
+    if (left)
+        return 'left';
+    return null;
+}
+/** 这一行是不是表格的开头：表头含 `|`、下一行是分隔行、且两行列数**相等** */
+function isTableStart(head, sep) {
+    if (sep === undefined || !head.includes('|') || !TABLE_SEP.test(sep))
+        return false;
+    return splitRow(head).length === splitRow(sep).length;
+}
+/**
+ * 这段正文「值不值得按 Markdown 渲染」—— 给**宿主**用（trace 树里展开的工具出参）。
+ *
+ * 判据只认**块级**记号，且要求**至少两分**（围栏码块与表格各算两分，其余各一分）：
+ * 标题 + 列表 = 2 分 ✅；只有一堆 `#` 注释 ❌；只有一处围栏码块 ✅。
+ *
+ * 为什么这么严：判错的代价不是「少渲染一点」，而是**把一段本来好读的文本毁掉** ——
+ * 日志行被并成段落、原有缩进被吃掉、行首的 `#` 与 `|` 凭空消失。所以宁可漏（保持原文），
+ * 不可错。
+ *
+ * 刻意**不**看行内记号（`**粗**` / `[x](y)`）：`**kwargs` / `*args` 是 Python 源码里最常见
+ * 的东西，按行内记号判会把整份源码判成 Markdown —— 而那正是工具出参的另一种常见形态。
+ *
+ * 超过 `MAX_RENDER_CHARS` 一律不渲染：几百 KB 的正文逐行建 DOM 只会把面板卡住，
+ * 而这种长度的东西本来就该用「复制」拿走。
+ */
+export function looksLikeMarkdown(text) {
+    if (typeof text !== 'string' || text.length > MAX_RENDER_CHARS)
+        return false;
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const kinds = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (FENCE.test(line))
+            kinds.add('fence');
+        else if (isTableStart(line, lines[i + 1]))
+            kinds.add('table');
+        else if (HEADING.test(line))
+            kinds.add('h');
+        else if (QUOTE.test(line))
+            kinds.add('q');
+        else if (UL.test(line) || olAt(line))
+            kinds.add('list');
+    }
+    let score = 0;
+    for (const k of kinds)
+        score += k === 'fence' || k === 'table' ? 2 : 1;
+    return score >= 2;
+}
 /** 有序列表标记（`1.` / `1)`），返回与 UL 同形的三组：缩进 / 标记 / 正文 */
 function olAt(line) {
     const m = OL.exec(line);

package/dist/templates/package.json

@@ -11,10 +11,10 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@migor/agentia": "^0.10.7"
+    "@migor/agentia": "^0.10.9"
   },
   "devDependencies": {
-    "@migor/cli": "^0.10.7",
+    "@migor/cli": "^0.10.9",
     "tsx": "^4.19.0",
     "typescript": "^7.0.2",
     "@types/node": "^22.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@migor/cli",
-  "version": "0.10.7",
+  "version": "0.10.9",
   "description": "CLI for the Agentia framework: scaffold a project, generate a capability, and open a local trace inspector for runs.",
   "type": "module",
   "bin": {