@migor/cli 0.10.7 → 0.10.8

package/CHANGELOG.md

@@ -5,6 +5,43 @@
 （0.x 阶段：minor 可含破坏性变更，每个破坏性变更都在对应版本的「迁移」小节里写明）。
 决策的完整证据链在 `docs/spec.md` §10（带时间线的决策日志）。
 
+## [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 +4509,8 @@ 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.8...HEAD
+[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,10 @@
  *    吃掉 9 行。同构且各列都是标量时改成表格，表头一行、数据一行。
  * 3. **路径拿不到**：想引用 `results[0].name` 只能用手数层级。每个键悬停出一个 `⧉`，
  *    点一下把路径写进剪贴板（表头写的是 `results[*].name`，因为它是一整列）。
+ * 4. **字符串里套着的 JSON 读不了**（2026-11-12）：MCP 的 text block、SSE 的 `data:`、把结果
+ *    序列化后又塞回 `content` 的工具 —— 这些值的类型是**字符串**，此前只显示成一串
+ *    `{\"a\":1` 的反斜杠汤，比无缩进的 JSON 更难读。现在首尾是 `{`…`}` / `[`…`]` 且解析成功的
+ *    字符串按容器铺开，并在行里打 `str→json` 标记 —— 不标出来，读者会以为工具真的返回了对象。
  *
  * ## 边界（都是「不这么做就会坏」的地方，不是口味）
  *
@@ -35,6 +39,11 @@
  *   会原样复现（这正是 `view.js` 的 `expanded` 集合存在的原因）。
  * - **表格化只在"真的同构"时发生**：元素必须全是普通对象、键集完全一致、列数 1..6、
  *   每列都是标量。任一不满足就回落树形 —— 表格里没法逐层展开，判错一次就是**丢数据**。
+ * - **字符串里的 JSON 只解析一层，且必须标出来**：判据是**首尾字符**（`{`…`}` / `[`…`]`），
+ *   不是「`JSON.parse` 成功」—— `"123"` / `"null"` / `"true"` 都能 parse 成功，显示成
+ *   数字/空值/布尔就是**改写工具返回的事实**。解析结果内部的字符串**不再二次解析**：
+ *   一层套一层是业务里的真实现象（SSE data 里再套 JSON），逐层展开会让 10KB 变成十万个节点。
+ *   表格单元格也不解析 —— 同构表已经放弃了逐层展开，单元格里放不下嵌套块。
  *
  * 零依赖、纯 DOM 构造（只用 createElement / appendChild / textContent / className /
  * dataset / innerHTML=''），与 view.js 共用同一套 DOM stub 跑测试。
@@ -50,6 +59,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 +84,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 +137,39 @@ 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;
+}
+
 /** 子键的 JSON 路径：对象用 `.key`，数组用 `[i]`。根是空串，所以 `[0]` 不会变成 `.[0]` */
 function pathOf(parent, key, isArr) {
   return isArr ? `${parent}[${key}]` : parent ? `${parent}.${key}` : key;
@@ -246,8 +302,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 +329,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 +353,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 +388,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) {
@@ -344,14 +409,28 @@ function renderInto(ctx, v, depth, path) {
 export function createFullView(value, opts = {}) {
   const fold = opts.fold instanceof Map ? opts.fold : new Map();
 
+  // 根是字符串 ⇒ 只有「里面装着 JSON」才会进来（调用方用 hasStructuredBody 先筛过）。
+  // 头部同时写出**两件事**：它原本是字符串（字符数）、解析后是什么规模 —— 只写后者，
+  // 读者会以为工具真的返回了对象。
+  const parsedRoot = 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 = 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);
+  head.appendChild(
+    fvEl('span', 'tr-full-type', fromJson ? `string · ${value.length} 字符 → ${label}` : label),
+  );
+  if (fromJson) head.appendChild(jsonBadge());
   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 ? String(value) : safeStringify(root), '已复制'),
+  );
   head.appendChild(copy);
   box.appendChild(head);
 
@@ -360,7 +439,8 @@ export function createFullView(value, opts = {}) {
   // 只重画正文（不动头部）：折叠不需要重建整棵树，滚动位置与头部反馈都留着
   ctx.repaint = () => {
     body.innerHTML = '';
-    renderInto(ctx, value, 0, '');
+    // 根若是从字符串解析来的，它的子树不再二次解析（只解析一层，防嵌套放大）
+    renderInto(ctx, root, 0, '', !fromJson);
   };
   ctx.repaint();
 

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,10 @@
  *    吃掉 9 行。同构且各列都是标量时改成表格，表头一行、数据一行。
  * 3. **路径拿不到**：想引用 `results[0].name` 只能用手数层级。每个键悬停出一个 `⧉`，
  *    点一下把路径写进剪贴板（表头写的是 `results[*].name`，因为它是一整列）。
+ * 4. **字符串里套着的 JSON 读不了**（2026-11-12）：MCP 的 text block、SSE 的 `data:`、把结果
+ *    序列化后又塞回 `content` 的工具 —— 这些值的类型是**字符串**，此前只显示成一串
+ *    `{\"a\":1` 的反斜杠汤，比无缩进的 JSON 更难读。现在首尾是 `{`…`}` / `[`…`]` 且解析成功的
+ *    字符串按容器铺开，并在行里打 `str→json` 标记 —— 不标出来，读者会以为工具真的返回了对象。
  *
  * ## 边界（都是「不这么做就会坏」的地方，不是口味）
  *
@@ -40,6 +44,11 @@
  *   会原样复现（这正是 `view.js` 的 `expanded` 集合存在的原因）。
  * - **表格化只在"真的同构"时发生**：元素必须全是普通对象、键集完全一致、列数 1..6、
  *   每列都是标量。任一不满足就回落树形 —— 表格里没法逐层展开，判错一次就是**丢数据**。
+ * - **字符串里的 JSON 只解析一层，且必须标出来**：判据是**首尾字符**（`{`…`}` / `[`…`]`），
+ *   不是「`JSON.parse` 成功」—— `"123"` / `"null"` / `"true"` 都能 parse 成功，显示成
+ *   数字/空值/布尔就是**改写工具返回的事实**。解析结果内部的字符串**不再二次解析**：
+ *   一层套一层是业务里的真实现象（SSE data 里再套 JSON），逐层展开会让 10KB 变成十万个节点。
+ *   表格单元格也不解析 —— 同构表已经放弃了逐层展开，单元格里放不下嵌套块。
  *
  * 零依赖、纯 DOM 构造（只用 createElement / appendChild / textContent / className /
  * dataset / innerHTML=''），与 view.js 共用同一套 DOM stub 跑测试。
@@ -55,6 +64,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 +89,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 +142,39 @@ 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;
+}
+
 /** 子键的 JSON 路径：对象用 `.key`，数组用 `[i]`。根是空串，所以 `[0]` 不会变成 `.[0]` */
 function pathOf(parent, key, isArr) {
   return isArr ? `${parent}[${key}]` : parent ? `${parent}.${key}` : key;
@@ -251,8 +307,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 +334,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 +358,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 +393,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) {
@@ -349,14 +414,28 @@ function renderInto(ctx, v, depth, path) {
 function createFullView(value, opts = {}) {
   const fold = opts.fold instanceof Map ? opts.fold : new Map();
 
+  // 根是字符串 ⇒ 只有「里面装着 JSON」才会进来（调用方用 hasStructuredBody 先筛过）。
+  // 头部同时写出**两件事**：它原本是字符串（字符数）、解析后是什么规模 —— 只写后者，
+  // 读者会以为工具真的返回了对象。
+  const parsedRoot = 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 = 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);
+  head.appendChild(
+    fvEl('span', 'tr-full-type', fromJson ? `string · ${value.length} 字符 → ${label}` : label),
+  );
+  if (fromJson) head.appendChild(jsonBadge());
   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 ? String(value) : safeStringify(root), '已复制'),
+  );
   head.appendChild(copy);
   box.appendChild(head);
 
@@ -365,7 +444,8 @@ function createFullView(value, opts = {}) {
   // 只重画正文（不动头部）：折叠不需要重建整棵树，滚动位置与头部反馈都留着
   ctx.repaint = () => {
     body.innerHTML = '';
-    renderInto(ctx, value, 0, '');
+    // 根若是从字符串解析来的，它的子树不再二次解析（只解析一层，防嵌套放大）
+    renderInto(ctx, root, 0, '', !fromJson);
   };
   ctx.repaint();
 
@@ -393,10 +473,13 @@ 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 常显），
+/* 展开态的正文有两种形状，由 `full` 的类型决定（2026-11-11，2026-11-12 扩了一档）：
+ *   - 纯文本字符串 → 老路：`.tr-io` 里放原文，靠 `.tr-open` 换行（纯文本正文、官网模拟回放）；
+ *   - 对象/数组 → 追加一个 `.tr-full` 结构化块（折叠 / 成表 / 路径复制），`.tr-io` 由 CSS 隐藏；
+ *   - **装着 JSON 的字符串**（`content: "{\"rows\":[...]}"`，工具把结构序列化后塞回文本字段）
+ *     → 同上一档，块头写明「string · N 字符 → object · M 项」并打 `str→json` 标记。
+ * 判据与块内完全同源（`hasStructuredBody`），「挂不挂块」与「块里画什么」因此不会跑偏。
+ * 前两档并存是刻意的：纯文本那条路有 test/style.test.js 的两个不变量守着（最小宽度、caret 常显），
  * 全换成本件会让那两个守卫失去落点。 */
 
 
@@ -523,9 +606,10 @@ 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';
+        // `full` 是对象/数组、或**装着 JSON 的字符串**时（2026-11-11 / 2026-11-12）：`.tr-io`
+        // 仍放**原文**（结构化块挂在行后、由 CSS 隐藏本格），所以「展开拿到的是原文而不是
+        // 62 字符摘要」这条不变量原样成立。
+        const structured = hasStructuredBody(ev.full);
         const fullText = structured ? rawArg(ev.full) : ev.full || '';
         const io = el('span', 'tr-io', (open ? fullText : ev.text) || '');
         // 展开后正文已在行里，再挂一个占满整行的原生 tooltip 只会挡视线
@@ -1089,10 +1173,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 +1187,7 @@ export {
   fmtArg,
   fmtMs,
   fmtNum,
+  hasStructuredBody,
   playTrace,
   rawArg,
   renderSummary,

package/dist/inspector/trace-view.css

@@ -284,6 +284,18 @@
 .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;
+}
 /* `⧉` 复制路径：hover 才露。与 .tr-caret 的区别是**它暴露的是动作、不是信息** ——
    路径的内容（键名）始终写在行里，常显只会给每行多一个字形噪声。
    没有剪贴板实现时照样显示、点了不谎报成功（见 full-view.js 的 copyInto）。 */

package/dist/inspector/view.js

@@ -17,12 +17,15 @@
  * 宿主需提供的 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 常显），
+/* 展开态的正文有两种形状，由 `full` 的类型决定（2026-11-11，2026-11-12 扩了一档）：
+ *   - 纯文本字符串 → 老路：`.tr-io` 里放原文，靠 `.tr-open` 换行（纯文本正文、官网模拟回放）；
+ *   - 对象/数组 → 追加一个 `.tr-full` 结构化块（折叠 / 成表 / 路径复制），`.tr-io` 由 CSS 隐藏；
+ *   - **装着 JSON 的字符串**（`content: "{\"rows\":[...]}"`，工具把结构序列化后塞回文本字段）
+ *     → 同上一档，块头写明「string · N 字符 → object · M 项」并打 `str→json` 标记。
+ * 判据与块内完全同源（`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: '⊕' };
 
@@ -147,9 +150,10 @@ 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';
+        // `full` 是对象/数组、或**装着 JSON 的字符串**时（2026-11-11 / 2026-11-12）：`.tr-io`
+        // 仍放**原文**（结构化块挂在行后、由 CSS 隐藏本格），所以「展开拿到的是原文而不是
+        // 62 字符摘要」这条不变量原样成立。
+        const structured = hasStructuredBody(ev.full);
         const fullText = structured ? rawArg(ev.full) : ev.full || '';
         const io = el('span', 'tr-io', (open ? fullText : ev.text) || '');
         // 展开后正文已在行里，再挂一个占满整行的原生 tooltip 只会挡视线

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.8"
   },
   "devDependencies": {
-    "@migor/cli": "^0.10.7",
+    "@migor/cli": "^0.10.8",
     "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.8",
   "description": "CLI for the Agentia framework: scaffold a project, generate a capability, and open a local trace inspector for runs.",
   "type": "module",
   "bin": {