@migor/cli 0.9.0 → 0.9.2

package/dist/inspector.js

@@ -60,6 +60,68 @@ function validateTrace(t) {
     }
     return null;
 }
+/**
+ * 入站校验：**增量记账事件**的形状（`POST /ingest-event`，① 实时右栏）。
+ *
+ * 为什么卡得比 `validateTrace` 还细：面板拿这些字段**直接建树**，而坏帧的报错现场在
+ * 浏览器里（最难查的地方）。缺一个 `spanId` 的表现是「树上少一个节点」而不是任何报错 ——
+ * 所以宁可在这里响亮拒（400 会被 runner 的 event sink 静默吞掉，但至少不会污染面板）。
+ */
+function validateTraceEvent(e) {
+    if (!e || typeof e !== 'object' || Array.isArray(e))
+        return '事件必须是对象';
+    const ev = e;
+    if (typeof ev.seq !== 'number' || !Number.isFinite(ev.seq))
+        return 'seq 必须是有穷 number';
+    switch (ev.type) {
+        case 'span.begin': {
+            const s = ev.span;
+            if (!s || typeof s !== 'object')
+                return 'span.begin 缺 span';
+            if (typeof s.spanId !== 'string' || s.spanId.length === 0)
+                return 'span.begin 的 span.spanId 缺失';
+            if (typeof s.traceId !== 'string' || s.traceId.length === 0) {
+                return 'span.begin 的 span.traceId 缺失';
+            }
+            if (typeof s.name !== 'string')
+                return 'span.begin 的 span.name 缺失';
+            if (typeof s.startedAt !== 'number' || !Number.isFinite(s.startedAt)) {
+                return 'span.begin 的 span.startedAt 非法';
+            }
+            return null;
+        }
+        case 'span.end': {
+            if (typeof ev.spanId !== 'string' || ev.spanId.length === 0)
+                return 'span.end 缺 spanId';
+            if (typeof ev.endedAt !== 'number' || !Number.isFinite(ev.endedAt))
+                return 'span.end 的 endedAt 非法';
+            if (typeof ev.status !== 'string')
+                return 'span.end 的 status 缺失';
+            return null;
+        }
+        case 'span.event': {
+            if (typeof ev.spanId !== 'string' || ev.spanId.length === 0)
+                return 'span.event 缺 spanId';
+            if (!ev.event || typeof ev.event.name !== 'string')
+                return 'span.event 缺 event.name';
+            return null;
+        }
+        case 'span.attribute': {
+            if (typeof ev.spanId !== 'string' || ev.spanId.length === 0)
+                return 'span.attribute 缺 spanId';
+            if (typeof ev.key !== 'string' || ev.key.length === 0)
+                return 'span.attribute 缺 key';
+            return null;
+        }
+        case 'span.link': {
+            if (typeof ev.spanId !== 'string' || ev.spanId.length === 0)
+                return 'span.link 缺 spanId';
+            return null;
+        }
+        default:
+            return `不认识的事件类型：${String(ev.type)}`;
+    }
+}
 /** 防 DNS rebinding：面板只服务本机，Host 不是 localhost/127.0.0.1/[::1] 的一律拒 */
 function isLocalHostHeader(host) {
     if (!host)
@@ -142,6 +204,11 @@ const MAX_RUNS = 50;
  * （见 `rememberNote`），所以它有自己的一条淘汰线。
  */
 const MAX_NOTES = MAX_RUNS;
+/**
+ * `GET /api/fs` 一次最多回多少个**文件**名（目录不设限：一个位置要列几百个目录，本身就
+ * 说明位置选错了）。超限回 `filesTruncated: true` —— 截断必须**明示**，不许静默少给。
+ */
+const FILE_LIMIT = 200;
 /** 静态资源目录（构建期由 scripts/copy-assets.mjs 就位） */
 const HERE = dirname(fileURLToPath(import.meta.url));
 const ASSETS = join(HERE, 'inspector');
@@ -159,6 +226,9 @@ const STATIC = new Map([
     ['summary.js', join(ASSETS, 'summary.js')],
     ['trace-view.css', join(ASSETS, 'trace-view.css')],
     ['panel-logic.js', join(HERE, 'panel-logic.js')],
+    // 面板的 Markdown 解析器（零依赖、按构造不产生 HTML —— 见 src/markdown.ts 的头注）。
+    // 与 panel-logic.js 同处 dist 根：两个都是 CLI 自己编译出来的模块，单测直接 import 它们。
+    ['markdown.js', join(HERE, 'markdown.js')],
 ]);
 /** 没有 dev 钩子时的状态（面板据此隐藏输入条） */
 function unavailableDevState() {
@@ -352,6 +422,42 @@ export function startInspector(opts = {}) {
                 json(res, 200, { ok: true });
                 return;
             }
+            /**
+             * **在飞 run 的增量记账事件**（① 实时右栏）：`POST /ingest-event`。
+             *
+             * 与 `POST /ingest` 的分工是刻意的两条缝（框架侧同名区分）：
+             * - 这条 = **此刻看到**：高频、逐笔、不落库、**不保证送达**；
+             * - 那条 = **最终账**：收尾一次、进 run 列表、被 `/api/runs` 读。
+             *
+             * 所以这里**只广播**、不建 run 记录：面板拿它把树「长」出来，收尾那份整棵 trace
+             * 回来时覆盖（`open()` 的渲染永远以收尾那份为准）。
+             *
+             * 202 而不是 200：已经广播出去了，但面板收没收到不归这里管（SSE 是单向流）。
+             * 没有 dev 钩子时回 503 —— 与 `/run` / `/run/abort` 同一口径（没有面板消费它）。
+             */
+            if (req.method === 'POST' && path === '/ingest-event') {
+                if (!opts.dev) {
+                    json(res, 503, { error: '这个 inspector 不是 agentia dev 起的（没有 runner）' });
+                    return;
+                }
+                const body = await readBody(req);
+                let ev;
+                try {
+                    ev = JSON.parse(body);
+                }
+                catch {
+                    json(res, 400, { error: 'body 不是合法 JSON' });
+                    return;
+                }
+                const problem = validateTraceEvent(ev);
+                if (problem) {
+                    json(res, 400, { error: problem });
+                    return;
+                }
+                opts.dev.traceEvent(ev);
+                json(res, 202, { ok: true });
+                return;
+            }
             if (req.method === 'GET' && path === '/api/runs') {
                 json(res, 200, order
                     .slice()
@@ -374,14 +480,25 @@ export function startInspector(opts = {}) {
                 return;
             }
             /**
-             * 目录浏览器：`GET /api/fs?path=<绝对路径>` → 该目录下的**子目录名**（不含文件）。
+             * 目录浏览器：`GET /api/fs?path=<绝对路径>` →
+             * `{ path, parent, dirs, dotDirs, files, filesTruncated }`。
              *
              * 为什么需要它：浏览器**拿不到**用户选的文件夹的绝对路径 —— `<input webkitdirectory>`
              * 只给相对路径，File System Access API 只给 handle.name。而 dev 环要的是绝对路径
              * （工具按它解析）。⇒ 要么让用户手打路径，要么服务端列目录。后者才是「工作目录是
              * 主控件」（D3/D7）该有的手感。
              *
-             * 只列**目录**、不读文件内容；且只在 dev 钩子在场时开放（只读面板不暴露文件树）。
+             * 三条口径（2026-09-22 复核后改，前两条是实测出来的缺口）：
+             * - **文件也列**（`files`，只给名字、不读内容）：面板据此提供「选这个文件」——
+             *   工作目录取它所在目录、prompt 空时填文件名。只列目录时，「让 agent 看某个文件」
+             *   只能靠用户自己把文件名打进 prompt。
+             * - **隐藏目录单列**（`dotDirs`，不在 `dirs` 里）：以前一批过滤掉，于是
+             *   `~/xxx/.yyy` 这类目录**根本点不进去**（`..` 只能退到它上面，进不去）。
+             *   单列是为了不把 `.git` / `.cache` 混进正常浏览，同时保证**可达**。
+             * - `files` 有上限（`FILE_LIMIT`）并回 `filesTruncated`：一次列几千个文件的名
+             *   没有意义，但**必须明示**截断（本仓纪律：不许静默少给）。
+             *
+             * 只列名字、**不读文件内容**；且只在 dev 钩子在场时开放（只读面板不暴露文件树）。
              * 越界不是威胁（本机 dev 工具，token 已经挡住了其它进程），但**不存在 / 不是目录**
              * 要响亮报错 —— 静默回退到项目根会让 agent 对着错的目录乱写（D5）。
              */
@@ -408,11 +525,26 @@ export function startInspector(opts = {}) {
                     json(res, 400, { error: `读不了这个目录：${e.message}` });
                     return;
                 }
-                const dirs = entries
-                    .filter((e) => !e.name.startsWith('.') && isDirLikeEntry(join(abs, e.name), e))
-                    .map((e) => e.name)
-                    .sort();
-                json(res, 200, { path: abs, parent: dirname(abs), dirs });
+                const dirs = [];
+                const dotDirs = [];
+                const files = [];
+                for (const e of entries) {
+                    if (isDirLikeEntry(join(abs, e.name), e)) {
+                        (e.name.startsWith('.') ? dotDirs : dirs).push(e.name);
+                        continue;
+                    }
+                    // 读不了内容的条目（管道 / socket / 权限）也当文件列出来 —— 列名字不需要读它
+                    if (!e.name.startsWith('.'))
+                        files.push(e.name);
+                }
+                json(res, 200, {
+                    path: abs,
+                    parent: dirname(abs),
+                    dirs: dirs.sort(),
+                    dotDirs: dotDirs.sort(),
+                    files: files.sort().slice(0, FILE_LIMIT),
+                    filesTruncated: files.length > FILE_LIMIT,
+                });
                 return;
             }
             if (req.method === 'POST' && path === '/run') {

package/dist/markdown.js

@@ -0,0 +1,243 @@
+/**
+ * 面板的 **Markdown 最小渲染器** —— 纯逻辑、零 DOM、零依赖。
+ *
+ * 为什么自己写而不引 `marked` / `markdown-it`：
+ * - **零运行时依赖是本 CLI 的硬承诺**（`package.json` 里没有 `dependencies`）。为了面板把一份
+ *   解析器 + 一份消毒器（DOMPurify 之类）塞进 dist，等于在 dev 链路里引入两个第三方供应链面，
+ *   而它们的产物**没法被本仓的单测验证**（我们只能验「我写的那部分」）。
+ * - 面板只需要**模型正文**这一种输入可读：标题 / 粗体 / 斜体 / 行内码 / 围栏码 / 列表 /
+ *   引用 / 分隔线 / 链接。这套子集手写不到 200 行，且**每条规则都能配一条单测**。
+ * - 最要紧的是**它按构造不产生 HTML**：返回值是一棵 token 树（`MdBlock` / `MdInline`），
+ *   没有任何「原样透传的 HTML」这一类。页面的渲染器只准用 `createElement` + `textContent`
+ *   把它变成 DOM ⇒ **模型输出里的 `<script>` 只会是字面文本**，不存在「忘了转义」这条路径。
+ *
+ * ⚠️ 本文件**不许碰 DOM**（不出现 `document` / `window`）—— 它要在 Node 里被直接 import 做单测。
+ *
+ * 支持的子集（刻意不做的都在「不做」里）：
+ * - 块：`#` 标题（1–6 级）、围栏码块（``` / ~~~，带语言标注）、无序/有序列表（**一层**）、
+ *   引用（合并成一段正文）、`---` 分隔线、段落
+ * - 行内：行内码、`**粗**`、`*斜*`、`[文字](链接)`、`<https://…>` 自动链接
+ *
+ * 不做（都是刻意的，不是漏）：
+ * - **不做 HTML 透传**（安全前提，见上）
+ * - 不做表格 / 任务列表 / 嵌套列表 / 脚注 / 数学 —— 面板是调试视图，不是文档站
+ * - 不做 setext 标题（`===` 下划线式）—— 与分隔线歧义大、收益小
+ * - 不做图片（`![]()`）—— 面板**不去外网取图**：一次 run 的正文不该触发网络请求
+ */
+/**
+ * 链接协议白名单。**这是安全边界，不是风格选择**：
+ * 模型输出里的 `[点我](javascript:alert(1))` 若被渲染成可点链接，面板就成了 XSS 的跳板
+ * （`href` 是唯一一处「我们主动写进属性」的值 —— 文本全走 `textContent` 是安全的，
+ * 属性不是）。不合法 ⇒ 这一条**整个降级成字面文本**（连 `[]()` 都照原样显示），
+ * 使用者一眼看得出「这里有个链接我没渲染」，而不是看到一个空链接或点不动的链接。
+ */
+export function isSafeHref(href) {
+    // 允许 http/https/mailto；**不允许** javascript: / data: / vbscript: / file: 等
+    return /^(https?:|mailto:)/i.test(href.trim());
+}
+const FENCE = /^\s{0,3}(`{3,}|~{3,})\s*([^\s`]*)/;
+const HEADING = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const HR = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const QUOTE = /^\s{0,3}>\s?(.*)$/;
+const UL = /^(\s*)([-*+])\s+(.*)$/;
+const OL = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+const BLANK = /^\s*$/;
+/**
+ * 把一段 Markdown 文本解析成块序列。
+ *
+ * 三条与「真 Markdown」不同但**刻意**的口径：
+ * - 缩进 ≥2 空格的续行归上一条列表项（列表只解析**一层**：更深一层当正文，不递归建树）；
+ * - 未闭合的围栏码块吃掉到文末（**不静默丢内容** —— 模型被截断时最常见的就是这个形态）；
+ * - 引用（`>`）合并成**一段正文**（面板里引用几乎总是模型在引日志，逐行建块只会更碎）。
+ */
+export function parseMarkdown(text) {
+    const src = String(text ?? '').replace(/\r\n?/g, '\n');
+    const lines = src.split('\n');
+    const blocks = [];
+    let i = 0;
+    let para = [];
+    const flushPara = () => {
+        if (para.length === 0)
+            return;
+        const joined = para.join('\n').trim();
+        para = [];
+        if (joined)
+            blocks.push({ type: 'p', inline: parseInline(joined, 0) });
+    };
+    while (i < lines.length) {
+        const line = lines[i];
+        // —— 围栏码块 ——
+        const fence = FENCE.exec(line);
+        if (fence) {
+            flushPara();
+            const marker = fence[1][0];
+            const min = fence[1].length;
+            const lang = fence[2] ?? '';
+            const body = [];
+            i++;
+            while (i < lines.length) {
+                const cur = lines[i];
+                const close = new RegExp(`^\\s{0,3}${marker === '`' ? '`' : '~'}{${min},}\\s*$`);
+                if (close.test(cur)) {
+                    i++;
+                    break;
+                }
+                body.push(cur);
+                i++;
+            }
+            blocks.push({ type: 'code', lang, text: body.join('\n') });
+            continue;
+        }
+        // —— 空行：段落到此为止 ——
+        if (BLANK.test(line)) {
+            flushPara();
+            i++;
+            continue;
+        }
+        // —— 分隔线（必须在列表之前判：`---` 也是无序列表的标记） ——
+        if (HR.test(line)) {
+            flushPara();
+            blocks.push({ type: 'hr' });
+            i++;
+            continue;
+        }
+        // —— 标题 ——
+        const h = HEADING.exec(line);
+        if (h) {
+            flushPara();
+            blocks.push({
+                type: 'h',
+                level: h[1].length,
+                inline: parseInline(h[2].trim(), 0),
+            });
+            i++;
+            continue;
+        }
+        // —— 引用：连续 `>` 行合成一段 ——
+        if (QUOTE.test(line)) {
+            flushPara();
+            const quoted = [];
+            while (i < lines.length && QUOTE.test(lines[i])) {
+                quoted.push(QUOTE.exec(lines[i])[1]);
+                i++;
+            }
+            const joined = quoted.join('\n').trim();
+            blocks.push({ type: 'quote', inline: parseInline(joined, 0) });
+            continue;
+        }
+        // —— 列表（无序 / 有序，各收一段连续的） ——
+        const ul = UL.exec(line);
+        const ol = olAt(line);
+        if (ul || ol) {
+            flushPara();
+            const ordered = ol !== null;
+            const items = [];
+            while (i < lines.length) {
+                const cur = lines[i];
+                const m = ordered ? olAt(cur) : UL.exec(cur);
+                if (m) {
+                    items.push(parseInline(m[3].trim(), 0));
+                    i++;
+                    continue;
+                }
+                // 续行：缩进 ≥2 且不是新的一条 ⇒ 并进上一项
+                if (items.length > 0 && /^\s{2,}\S/.test(cur) && !BLANK.test(cur)) {
+                    const last = items[items.length - 1];
+                    last.push(...parseInline(cur.trim(), 0));
+                    i++;
+                    continue;
+                }
+                break;
+            }
+            blocks.push({ type: 'list', ordered, items });
+            continue;
+        }
+        // —— 其余：段落（连续非空行合并，行内换行保留） ——
+        para.push(line.trim());
+        i++;
+    }
+    flushPara();
+    return blocks;
+}
+/** 有序列表标记（`1.` / `1)`），返回与 UL 同形的三组：缩进 / 标记 / 正文 */
+function olAt(line) {
+    const m = OL.exec(line);
+    return m ? m : null;
+}
+/**
+ * 行内解析。`depth` 是**递归上限**：`**a *b* c**` 这类嵌套只展开到第 3 层，
+ * 再深就按字面留着 —— 递归无上限时，一条构造出来的正文就能把面板卡死。
+ */
+export function parseInline(text, depth) {
+    const out = [];
+    let buf = '';
+    let i = 0;
+    const pushText = () => {
+        if (buf)
+            out.push({ type: 'text', text: buf });
+        buf = '';
+    };
+    while (i < text.length) {
+        const c = text[i];
+        // 行内码：`...`（不跨行；两端各去掉一个空格 —— 与 CommonMark 同款）
+        if (c === '`') {
+            const end = text.indexOf('`', i + 1);
+            if (end > i + 1) {
+                pushText();
+                let inner = text.slice(i + 1, end);
+                if (inner.startsWith(' ') && inner.endsWith(' ') && inner.trim())
+                    inner = inner.slice(1, -1);
+                out.push({ type: 'code', text: inner });
+                i = end + 1;
+                continue;
+            }
+        }
+        // 链接：[文字](地址) —— 地址不过白名单就整条降级成字面文本（见 isSafeHref）
+        if (c === '[') {
+            const m = /^\[([^\]]*)\]\(([^)\s]*)\)/.exec(text.slice(i));
+            if (m) {
+                const raw = text.slice(i, i + m[0].length);
+                const href = m[2].trim();
+                if (isSafeHref(href)) {
+                    pushText();
+                    out.push({ type: 'link', href, text: m[1].trim() });
+                }
+                else {
+                    buf += raw; // 字面保留（连 []() 一起）—— 让使用者看见「这里有个链接我没渲染」
+                }
+                i += m[0].length;
+                continue;
+            }
+        }
+        // 自动链接：<https://…>（裸的 `<` 一律当文本 —— 这正是「不做 HTML 透传」的落点）
+        if (c === '<') {
+            const m = /^<(https?:\/\/[^\s>]+)>/.exec(text.slice(i));
+            if (m) {
+                pushText();
+                out.push({ type: 'link', href: m[1], text: m[1] });
+                i += m[0].length;
+                continue;
+            }
+        }
+        // 强调：**粗** / *斜*（`__` / `_` 同义）
+        if (c === '*' || c === '_') {
+            const strong = text.startsWith(c + c, i);
+            const mark = strong ? c + c : c;
+            const end = text.indexOf(mark, i + mark.length);
+            if (end > i + mark.length) {
+                const inner = text.slice(i + mark.length, end);
+                if (inner.trim() && !inner.startsWith(' ') && !inner.endsWith(' ')) {
+                    pushText();
+                    const children = depth < 3 ? parseInline(inner, depth + 1) : [{ type: 'text', text: inner }];
+                    out.push(strong ? { type: 'strong', children } : { type: 'em', children });
+                    i = end + mark.length;
+                    continue;
+                }
+            }
+        }
+        buf += c;
+        i++;
+    }
+    pushText();
+    return out;
+}

package/dist/panel-logic.js

@@ -246,3 +246,170 @@ export function shortenPath(abs, opts = {}) {
         return `.${abs.slice(cwd.length)}`;
     return abs;
 }
+/** 空累加器：`state.live` 的初值，也是 e2e 折回的起点 */
+export function emptyTraceAccumulator() {
+    return { lastSeq: 0, traceId: '', spans: [] };
+}
+/**
+ * 应用一条增量记账事件。返回**它有没有被用上**（false = 丢了）。
+ *
+ * 丢的三种情形都是刻意的、**都不抛**：
+ * - `seq` 不前进（重复投递、迟到的旧帧）—— SSE 不保证送达，但送达的只能应用一次；
+ * - 指向**没见过的 `spanId`**（面板连上得晚，那个 `span.begin` 没收到）—— 绝不能凭空建
+ *   节点：那会造出一棵缺了上半截的假树。收尾那份会补齐；
+ * - 形状不认识（框架将来加了新事件类型）—— 静默放过，别让整个右栏停摆。
+ */
+export function applyTraceEvent(acc, ev) {
+    // 先卡 seq：它同时挡住「重复投递」与「乱序的旧帧」
+    if (!ev || typeof ev.seq !== 'number' || ev.seq <= acc.lastSeq)
+        return false;
+    const find = (spanId) => acc.spans.find((s) => s.spanId === spanId);
+    switch (ev.type) {
+        case 'span.begin': {
+            const src = ev.span;
+            // 拷一份：折回不该持有（更不该改写）协议对象 —— 面板会重画很多次
+            const copy = {
+                ...src,
+                attributes: { ...src.attributes },
+                events: (src.events ?? []).map((e) => ({ ...e })),
+            };
+            const seen = find(src.spanId);
+            // 同一个 `spanId` 再来一次 ⇒ **原地刷新**（重放幂等），不再挂一个同 id 的节点
+            if (seen)
+                Object.assign(seen, copy);
+            else {
+                acc.spans.push(copy);
+                if (!acc.traceId)
+                    acc.traceId = src.traceId;
+            }
+            break;
+        }
+        case 'span.end': {
+            const s = find(ev.spanId);
+            if (!s)
+                return false;
+            s.endedAt = ev.endedAt;
+            s.status = ev.status;
+            if (ev.error)
+                s.error = { ...ev.error };
+            if (ev.usage)
+                s.usage = { ...ev.usage };
+            break;
+        }
+        case 'span.event': {
+            const s = find(ev.spanId);
+            if (!s)
+                return false;
+            s.events.push({ ...ev.event });
+            break;
+        }
+        case 'span.attribute': {
+            const s = find(ev.spanId);
+            if (!s)
+                return false;
+            s.attributes = { ...s.attributes, [ev.key]: ev.value };
+            break;
+        }
+        case 'span.link': {
+            const s = find(ev.spanId);
+            if (!s)
+                return false;
+            s.links = [...(s.links ?? []), ev.link];
+            break;
+        }
+        default:
+            return false;
+    }
+    acc.lastSeq = ev.seq;
+    return true;
+}
+/**
+ * 当前已知的这棵树（交给 `playTrace` 画）。返回的是**副本** —— 渲染层拿它排序 / 展开，
+ * 不该回头改到累加器（下一次重画还要用同一份账）。
+ *
+ * `status` 只区分**在飞**与**已收尾**：根 span 还没有 `endedAt` 就是「在飞」，渲染层据此
+ * **不收尾**（否则根会被画成「已在某一刻完成」，那是个假事实）。收尾后取根自己的状态
+ * （`ok` / `error`），与框架口径一致。
+ */
+export function partialTrace(acc) {
+    const spans = acc.spans.map((s) => ({
+        ...s,
+        attributes: { ...s.attributes },
+        events: s.events.map((e) => ({ ...e })),
+    }));
+    const root = spans.find((s) => s.parentSpanId === null);
+    const status = root && root.endedAt === undefined ? 'running' : (root?.status ?? 'running');
+    return { traceId: acc.traceId, spans, status };
+}
+// ---------- ② 回复正文的归属 ----------
+/**
+ * 「`open(id)` 该不该**保留**屏幕上这条回复」。
+ *
+ * 背景：`run-done` 把回复正文写上去之后，面板会**自动 open 刚跑完的那一轮** ——
+ * 而 `open()` 原本无条件清掉回复区，于是那句回复在十几毫秒后被自己擦掉（看起来像「没回复」）。
+ *
+ * 口径与 `open()` 的原意图对齐：只有「现在打开的就是这条回复的主人」才保留；其余一律清
+ * （打开一条历史 run 时若还挂着**别人**的回复，那是张冠李戴 —— 比空白更糟）。
+ * `replyFor` 为 null（还没跑过 / 已清）**不等于**「谁都对」：默认清。
+ */
+export function replyBelongsTo(openId, replyFor) {
+    if (!openId || !replyFor)
+        return false;
+    return openId === replyFor;
+}
+// ---------- ③ 目录浏览 / 选文件 ----------
+/**
+ * 点「浏览…」时该打开哪个目录：**总是**按输入框的值。
+ *
+ * 旧实现把它当**开关**（面板开着时再点一次就关掉），于是「在输入框敲了目标路径 → 点浏览…」
+ * 这个最自然的动作反而是把面板关掉，用户就以为「选不了别的目录」。空值才回落到缺省工作目录；
+ * 首尾空白不该让路径读错。
+ */
+export function browseTarget(value, defaultDir) {
+    const v = value.trim();
+    return v.length > 0 ? v : defaultDir;
+}
+/**
+ * 点一个**文件**之后的 prompt 该是什么。
+ *
+ * 口径：**只在 prompt 为空时**填文件名（省一次打字）；用户已经写好的话**一个字都不动** ——
+ * 悄悄改写用户输入比少填一次糟得多。`filled` 是给面板回话用的（提示文案不同）。
+ * 工作目录的切换（取该文件**所在的**目录）由调用方做，不在这个纯判定里。
+ */
+export function promptAfterFilePick(current, name) {
+    if (current.trim().length > 0)
+        return { prompt: current, filled: false };
+    return { prompt: name, filled: true };
+}
+// ---------- ③ 消息折叠：长正文默认收起，短的不加控件 ----------
+/**
+ * 超过这么多行就默认折叠。12 行是「一屏大致读得完」的量级 —— 面板右栏在 1223px 下正文行高
+ * 约 18px，12 行 ≈ 216px，正好是不把调用树挤出去的上限。
+ */
+export const COLLAPSE_MAX_LINES = 12;
+/** 单行长正文的兜底阈值：一行 2000 字符（模型不换行时很常见）同样该收起来 */
+export const COLLAPSE_MAX_CHARS = 1200;
+/**
+ * 「这段正文要不要折叠」。**判定是纯逻辑** —— 渲染层只管按结果挂控件，
+ * 不自己量高度（量高度依赖布局与字体，单测里量不出来，等于把规则藏进浏览器）。
+ *
+ * 为什么不按像素量：像素阈值在字体/缩放/窄屏下会漂，同一个回复在不同机器上折叠与否都不一样；
+ * 行数 + 字符数是**输入本身的属性**，可复现、可断言。
+ *
+ * `hint` 是给展开控件用的文案（面板拿它当按钮标题，再加个 caret）；不折叠时是空串 ——
+ * **短消息上挂一个「展开」是噪声**，所以控件只在真的长时出现。
+ */
+export function collapseDecision(text, opts = {}) {
+    const t = String(text ?? '');
+    const lines = t.length === 0 ? 0 : t.split('\n').length;
+    const chars = t.length;
+    const maxLines = opts.maxLines ?? COLLAPSE_MAX_LINES;
+    const maxChars = opts.maxChars ?? COLLAPSE_MAX_CHARS;
+    const collapsed = lines > maxLines || chars > maxChars;
+    const hint = collapsed
+        ? lines > 1
+            ? `展开全文（共 ${lines} 行）`
+            : `展开全文（共 ${chars} 字符）`
+        : '';
+    return { collapsed, lines, chars, hint };
+}

package/dist/templates/package.json

@@ -9,10 +9,10 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@migor/agentia": "^0.9.0"
+    "@migor/agentia": "^0.9.2"
   },
   "devDependencies": {
-    "@migor/cli": "^0.9.0",
+    "@migor/cli": "^0.9.2",
     "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.9.0",
+  "version": "0.9.2",
   "description": "Agentia 框架命令行工具：create 脚手架 + g 能力生成 + dev 本地可观测面板（trace inspector）",
   "type": "module",
   "bin": {