pi-skill-evolve 0.1.4 → 0.1.6

package/extensions/skill-evolve/lib/web/session-file.ts

@@ -0,0 +1,136 @@
+/**
+ * 会话详情页的**读盘层**：从 sessionId 找到会话 .jsonl 绝对路径，读出来交给解析器。
+ *
+ * 两条来源（顺序固定）：
+ * 1. run.json 里已经写着 `sessionFile`（pi 派发时写下的绝对路径）；`?file=` 参数同理，但要**过安全闸**；
+ * 2. 该路径已不在本机（换了机器 / 清理过 sessions），就按 sessionId 在
+ *    `~/.pi/agent/sessions/*​/*.jsonl` 里按文件名反查 —— 文件名形如
+ *    `2026-11-08T02-48-52-675Z_<sessionId>.jsonl`，所以「文件名含 sessionId」就是精确命中。
+ *
+ * 安全闸（面板虽然是 127.0.0.1，但 query 参数来自浏览器，不能当可信路径用）：
+ * 只接受 **realpath 落在 sessions 根目录之下**、且**文件名含 sessionId**、且以 `.jsonl` 结尾的文件。
+ * 三条同时成立才读 —— 少了任何一条，`?file=/etc/passwd` 就能读到任意文件。
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { listRuns } from "../runs.ts";
+import { parseSessionText, type SessionTranscript } from "./session-view.ts";
+
+/** sessionId 只允许这些字符：它会被当文件名匹配词，绝不允许 `/` 之类进到路径里 */
+const SESSION_ID_PATTERN = /^[A-Za-z0-9._-]{4,128}$/;
+
+/** 反查 runs 时要扫多少条（与 data.ts 的 SCAN_LIMIT 同量级，够覆盖最近这批 run） */
+const RUN_SCAN_LIMIT = 100;
+
+export interface SessionSource {
+  sessionId: string;
+  /** 解析到的会话原文绝对路径；找不到 = null */
+  file: string | null;
+  /** 文件字节数（找不到 = 0） */
+  sizeBytes: number;
+  /** 解析结果；找不到文件 = null */
+  transcript: SessionTranscript | null;
+}
+
+/** pi 会话根目录：`~/.pi/agent/sessions`（测试用 home 覆盖，绝不读真实目录） */
+export function sessionsRoot(home?: string): string {
+  return path.join(home ?? os.homedir(), ".pi", "agent", "sessions");
+}
+
+/** 规范化 sessionId：不合法返回 null（调用方据此直接给「会话文件已不在本机」） */
+export function safeSessionId(raw: string): string | null {
+  const trimmed = raw.trim();
+  return SESSION_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+
+/** 路径是否真在根目录之下（用 realpath 比，符号链接绕不出去） */
+function insideRoot(root: string, file: string): boolean {
+  try {
+    const realRoot = fs.realpathSync(root);
+    const realFile = fs.realpathSync(file);
+    return realFile.startsWith(`${realRoot}${path.sep}`);
+  } catch {
+    return false;
+  }
+}
+
+/** 文件本身是不是这个会话的原文：basename 含 sessionId、后缀 .jsonl、且在根目录内 */
+function isSessionFile(root: string, sessionId: string, file: string): boolean {
+  if (!file.endsWith(".jsonl")) return false;
+  if (!path.basename(file).includes(sessionId)) return false;
+  return insideRoot(root, file);
+}
+
+/**
+ * 按 sessionId 在 sessions 根目录下反查（一层子目录，pi 按项目路径分目录）。
+ * 命中多条时取文件名最大的那条：名字以 ISO 时间开头，字典序最大 = 最近一次会话。
+ */
+export function findSessionFile(sessionId: string, root: string): string | null {
+  let dirs: fs.Dirent[];
+  try {
+    dirs = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let found: string | null = null;
+  for (const dir of dirs) {
+    if (!dir.isDirectory()) continue;
+    const sub = path.join(root, dir.name);
+    let names: string[];
+    try {
+      names = fs.readdirSync(sub);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".jsonl") || !name.includes(sessionId)) continue;
+      if (found === null || name > path.basename(found)) found = path.join(sub, name);
+    }
+  }
+  return found !== null && isSessionFile(root, sessionId, found) ? found : null;
+}
+
+/** 解析会话文件路径：先试给定路径（过安全闸），不行再按 sessionId 反查 */
+export function resolveSessionFile(input: { sessionId: string; file?: string | null; root: string }): string | null {
+  const { sessionId, file, root } = input;
+  if (file !== null && file !== undefined && file.length > 0) {
+    if (isSessionFile(root, sessionId, file)) return file;
+  }
+  return findSessionFile(sessionId, root);
+}
+
+/** run.json 里记着的会话路径：同 sessionId 的 run 里挑最近一条（队列条目没有这个字段，只能反查） */
+export function declaredSessionFile(evolutionDir: string, sessionId: string): string | null {
+  const runs = listRuns(evolutionDir, RUN_SCAN_LIMIT);
+  for (const run of runs) {
+    if (run.sessionId === sessionId && run.sessionFile !== null && run.sessionFile.length > 0) return run.sessionFile;
+  }
+  return null;
+}
+
+/**
+ * 读出会话原文并解析。找不到文件不抛错：页面要显示「会话文件已不在本机」这句人话，
+ * 而不是一个 500 或空白页。
+ */
+export function readSessionSource(input: {
+  evolutionDir: string;
+  sessionId: string;
+  file?: string | null;
+  home?: string;
+}): SessionSource {
+  const sessionId = safeSessionId(input.sessionId);
+  const root = sessionsRoot(input.home);
+  if (sessionId === null) return { sessionId: input.sessionId.trim(), file: null, sizeBytes: 0, transcript: null };
+  const declared = input.file ?? declaredSessionFile(input.evolutionDir, sessionId);
+  const file = resolveSessionFile({ sessionId, file: declared, root });
+  if (file === null) return { sessionId, file: null, sizeBytes: 0, transcript: null };
+  let raw: string;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    // 目录在但文件被删 / 没权限：与「不在本机」同一句话，不暴露系统错误
+    return { sessionId, file: null, sizeBytes: 0, transcript: null };
+  }
+  return { sessionId, file, sizeBytes: Buffer.byteLength(raw, "utf8"), transcript: parseSessionText(raw) };
+}

package/extensions/skill-evolve/lib/web/session-render.ts

@@ -0,0 +1,189 @@
+/**
+ * 会话正文与目录的**渲染**：把 session-view.ts 解析出来的块拼成 HTML 与目录条目。
+ *
+ * 与解析拆开是因为两件事的行数各自都不小：解析要处理 pi 的 JSONL 细节，
+ * 渲染要处理 Markdown、折叠、目录锚点与总输出上限 —— 合在一个文件里必然破 300 行。
+ *
+ * 三条口径：
+ * 1. **正文走 Markdown-lite**：pi 的对话里满是 `**加粗**`、`` `代码` ``、列表，
+ *    原样输出等于让人读一堆星号（用户 2026-11-08：「Markdown 原样输出」）；
+ * 2. **工具块默认收起**，抬头给「次数 + 首个参数摘要」——`bash ×9` 看不出调了什么；
+ * 3. **正文与目录一次遍历产出**：锚点 id 与目录 href 因此不会对不上。
+ */
+import { renderMarkdownLite } from "./markdown-lite.ts";
+import {
+  MAX_MESSAGES,
+  MAX_OUTPUT,
+  MAX_TEXT,
+  MAX_USER_TEXT,
+  type SessionEntry,
+  type SessionToolCall,
+  type SessionTranscript,
+} from "./session-view.ts";
+import { escapeHtml, formatTime, formatTimeSeconds } from "./text.ts";
+
+/** 折叠抬头里的首个参数摘要上限 */
+export const TOOL_PREVIEW = 60;
+/** 目录条目里的用户消息摘要上限 */
+export const TOC_TEXT = 40;
+
+/** 截断并加省略号：中文一行话也可能超长，所以在字符数上截，不在行上截 */
+function clip(text: string, max: number): string {
+  const trimmed = text.trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+/** 工具调用的抬头：`read ×3、bash ×2`（同名的合成一个计数，别写三遍 read） */
+function toolSummary(calls: readonly SessionToolCall[]): string {
+  const counts = new Map<string, number>();
+  for (const call of calls) counts.set(call.name, (counts.get(call.name) ?? 0) + 1);
+  return [...counts.entries()].map(([name, count]) => `${name} ×${count}`).join("、");
+}
+
+/** 一个工具调用块：名字 + 参数摘要 + 结果前 200 字（全转义，original 里可能带尖括号） */
+function toolBlock(call: SessionToolCall): string {
+  return `<div class="tool">
+<p class="tool-name">${escapeHtml(call.name)}</p>
+<pre class="tool-args">${escapeHtml(call.args.length > 0 ? call.args : "（无参数）")}</pre>
+<pre class="tool-result">${escapeHtml(call.result)}</pre>
+</div>`;
+}
+
+/**
+ * 一组工具调用：`<details>` **默认收起**（不加 `open`）——
+ * 一段会话动辄几百次调用，默认展开等于把对话正文顶到十屏之外。
+ * 抬头里给「首个参数摘要」：`bash ×9` 看不出调了什么，`rg -n "x" lib` 一眼就知道。
+ */
+function toolGroup(calls: readonly SessionToolCall[]): string {
+  const first = calls[0];
+  // 摘要按工具取（bash 取 command 第一行、read 取文件名…），取不到就只留 `▸ bash ×9`
+  const preview = first === undefined ? "" : clip(first.summary, TOOL_PREVIEW);
+  const tail = preview.length === 0 ? "" : ` · <span class="muted">${escapeHtml(preview)}</span>`;
+  return `<details class="tools"><summary>▸ ${escapeHtml(toolSummary(calls))}${tail}</summary>
+${calls.map(toolBlock).join("\n")}
+</details>`;
+}
+
+/** `only=user` 时工具调用的替身：一行说清省略了多少次，并给「看全部」的链接 */
+function omittedLine(calls: readonly SessionToolCall[], expandHref: string | null): string {
+  const more = expandHref === null ? "" : `（<a href="${escapeHtml(expandHref)}">看全部</a>）`;
+  return `<p class="hint">… 本轮省略 ${calls.length} 次工具调用${more}</p>`;
+}
+
+/** 目录条目：`19:35 · 前 40 字`（换行压成空格，否则目录会被一段代码撑成几行） */
+export interface TocEntry {
+  id: string;
+  at: number | null;
+  text: string;
+}
+
+export interface TranscriptView {
+  /** 消息流 HTML */
+  body: string;
+  /** 目录条目（只收 user 消息，顺序与正文一致） */
+  toc: TocEntry[];
+  /** 实际渲染的块数 */
+  shown: number;
+  /** 是否撞到总输出上限 */
+  truncated: boolean;
+}
+
+export interface RenderSessionOptions {
+  /** 因「只渲染最后 200 条」丢掉的条数（>0 时在顶部说明一句） */
+  dropped?: number;
+  /** 只看对话：工具调用压成一行 */
+  onlyUser?: boolean;
+  /** 「看全部」链接（去掉 only=user 的同一会话地址） */
+  expandHref?: string | null;
+}
+
+/** 一条对话消息：徽章 + 时刻 + Markdown-lite 正文（用户底色更亮，扫读时能一眼分段） */
+function messageBlock(
+  entry: Extract<SessionEntry, { kind: "user" | "assistant" }>,
+  id: string,
+  label: { text: string; tone: string },
+): { html: string; text: string } {
+  const max = entry.kind === "user" ? MAX_USER_TEXT : MAX_TEXT;
+  const body = clip(entry.text, max);
+  if (body.length === 0) return { html: "", text: "" };
+  const at = entry.at === null ? "" : `<span class="at">${formatTimeSeconds(entry.at)}</span>`;
+  const html = `<div class="msg ${entry.kind} m" id="${id}">
+<div class="mhead"><span class="badge ${label.tone}">${label.text}</span>${at}</div>
+<div class="msg-body">${renderMarkdownLite(body)}</div>
+</div>`;
+  return { html, text: body.replace(/\s+/g, " ").trim() };
+}
+
+/**
+ * 会话正文 + 目录：**一次遍历同时产出两者**，锚点 id 与目录 href 因此不会对不上
+ * （分两处各自编号迟早出现「点了目录跳错块」）。
+ */
+export function renderTranscript(
+  transcript: SessionTranscript,
+  options: RenderSessionOptions = {},
+): TranscriptView {
+  const parts: string[] = [];
+  const toc: TocEntry[] = [];
+  let size = 0;
+  let shown = 0;
+  let truncated = false;
+  if (options.dropped !== undefined && options.dropped > 0) {
+    parts.push(
+      `<p class="hint">只渲染最后 ${MAX_MESSAGES} 条消息，前面还有 ${options.dropped} 条未显示（看全文请用 rg/read 打开原文件）。</p>`,
+    );
+  }
+  for (const entry of transcript.entries) {
+    const id = `m-${shown + 1}`;
+    const rendered =
+      entry.kind === "tools"
+        ? {
+            html:
+              options.onlyUser === true ? omittedLine(entry.calls, options.expandHref ?? null) : toolGroup(entry.calls),
+            text: "",
+          }
+        : messageBlock(
+            entry,
+            id,
+            entry.kind === "user" ? { text: "用户", tone: "blue" } : { text: "助手", tone: "green" },
+          );
+    if (rendered.html.length === 0) continue;
+    if (size + rendered.html.length > MAX_OUTPUT) {
+      truncated = true;
+      break;
+    }
+    shown += 1;
+    parts.push(rendered.html);
+    size += rendered.html.length;
+    if (entry.kind === "user") {
+      toc.push({ id, at: entry.at, text: clip(rendered.text, TOC_TEXT) });
+    }
+  }
+  if (shown === 0) {
+    return {
+      body: '<p class="empty">这段会话里没有可渲染的对话（可能全是工具调用与系统提示）。</p>',
+      toc,
+      shown,
+      truncated,
+    };
+  }
+  if (truncated) {
+    parts.push(
+      `<p class="hint">已达页面输出上限（${Math.round(MAX_OUTPUT / 1024)}KB），后面还有内容未渲染：继续看请用 rg/read 打开原文件。</p>`,
+    );
+  }
+  return { body: parts.join("\n"), toc, shown, truncated };
+}
+
+/**
+ * 目录内容（左侧粘性栏与窄屏折叠目录共用同一份）：
+ * 只列 user 消息 —— 一段会话里用户消息就是天然的「章节」。
+ */
+export function renderToc(toc: readonly TocEntry[]): string {
+  if (toc.length === 0) return `<p class="hint">这段会话里没有用户消息。</p>`;
+  return toc
+    .map((item) => {
+      const when = item.at === null ? "—" : formatTime(item.at);
+      return `<a href="#${item.id}">${escapeHtml(when)} · ${escapeHtml(item.text)}</a>`;
+    })
+    .join("\n");
+}

package/extensions/skill-evolve/lib/web/session-view.ts

@@ -0,0 +1,276 @@
+/**
+ * 会话详情页的**纯函数**：把 pi 的会话 JSONL 解析成「可渲染的块」，再拼成 HTML 片段与目录。
+ *
+ * 为什么要这一页（用户 2026-11-08：「支持打开会话的详情, 工具调用可收起展开, 默认收起」）：
+ * 面板上每条 run 都关联一段 pi 会话，出问题时要看的是「那段对话里到底发生了什么」——
+ * 而 sessions/*.jsonl 有几 MB、几千行，在编辑器里翻根本对不上哪句是哪轮。
+ *
+ * 结构口径（与 pi 的真实写入一致）：
+ * - 只取顶层 `type === "message"` 的条目，其余（session / model_change / thinking_level_change / custom）全跳过；
+ * - `message.role` = user / assistant / toolResult / system；system 不渲染（它是系统提示词，不是对话）；
+ * - assistant 的内容里 `text` 是给人看的、`thinking` 不渲染、`toolCall` 聚成折叠块；
+ * - toolResult 消息按 `toolCallId` 回连到那次调用（结果贴在该调用的参数之后）；
+ * - 时间取该条 JSONL 记录顶层的 `timestamp`（ISO 字符串），拿不到就是 null。
+ *
+ * 三条上限（会话可能很大，页面不能被一段对话撑爆浏览器）：
+ * 只渲染最后 200 条消息 · 单条 4000 字 · 用户原文 2000 字 · 总输出超 2MB 就停手并指路原文件。
+ *
+ * 这个文件里**没有一行 IO**：入参是字符串，出参是数据结构，所以能直接拿临时 JSONL 片段做单测。
+ * HTML 与目录在 ./session-render.ts —— 解析与渲染各自都够一屏，混在一起必然破 300 行。
+ */
+
+/** 只渲染最后多少条 message（更早的对话对排查当前问题几乎无用） */
+export const MAX_MESSAGES = 200;
+/** 单条消息正文上限 */
+export const MAX_TEXT = 4000;
+/** 用户消息正文上限：用户要的是「原文」，所以给得比 assistant 宽，但仍要防一次粘贴几万字 */
+export const MAX_USER_TEXT = 2000;
+/** 一次工具调用的参数摘要上限（目录与折叠抬头只用 60 字，见 `TOOL_PREVIEW`） */
+export const MAX_ARGS = 400;
+/** 折叠抬头里那句「调了什么」的上限：一行看得完，不抢工具名的位置 */
+export const TOOL_SUMMARY = 60;
+/** 一次工具调用的结果上限 */
+export const MAX_RESULT = 200;
+/** 整页会话正文的输出上限（字符数，UTF-8 下中文 3 字节，这里按保守值算） */
+export const MAX_OUTPUT = 2 * 1024 * 1024;
+
+export interface SessionToolCall {
+  name: string;
+  /** 参数原文（JSON 压成一行后截断）：展开后给「完整参数」看 */
+  args: string;
+  /** 抬头摘要：按工具挑一个可读参数（见 `toolArgSummary`），取不到就是空串 */
+  summary: string;
+  /** 结果前 200 字（没有结果就是「（没有结果）」） */
+  result: string;
+}
+
+export type SessionEntry =
+  | { kind: "user"; text: string; at: number | null }
+  | { kind: "assistant"; text: string; at: number | null }
+  | { kind: "tools"; calls: SessionToolCall[]; at: number | null };
+
+/**
+ * 解析中途的调用记录：结果（toolResult）总是排在携带 toolCall 的 assistant 消息**之后**，
+ * 所以先带 id 收进来，全文扫完再回填结果 —— 边扫边取会永远取不到（那时结果还没出现）。
+ */
+interface RawCall {
+  id: string;
+  name: string;
+  args: string;
+  summary: string;
+}
+
+export interface SessionTranscript {
+  entries: SessionEntry[];
+  /** 解析到的 message 总条数（不限 200） */
+  messages: number;
+  /** 工具调用总次数 */
+  toolCalls: number;
+  /** 因为只留最后 200 条而丢掉的消息条数 */
+  dropped: number;
+  /** 第一条 / 最后一条消息的时间：概览卡片的「10:32 → 11:52」用它 */
+  firstAt: number | null;
+  lastAt: number | null;
+}
+
+/** 截断并加省略号：中文一行话也可能超长，所以在字符数上截，不在行上截 */
+function clip(text: string, max: number): string {
+  const trimmed = text.trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+/** 顶层时间戳：ISO 字符串或已是数字；解析不了就当没有（不拿当前时间冒充） */
+function stamp(record: Record<string, unknown>): number | null {
+  const raw = record.timestamp;
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (typeof raw !== "string") return null;
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+/** 参数压成一行 JSON：多行缩进在面板里只会占满屏 */
+function argumentsText(value: unknown): string {
+  let text: string;
+  if (typeof value === "string") {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value) ?? "";
+    } catch {
+      text = String(value);
+    }
+  }
+  return clip(text.replace(/\s+/g, " "), MAX_ARGS);
+}
+
+/** bash 的 command：只要第一行（多行脚本会把抬头撑成一屏），`\n` 还原成空格，首尾引号去掉 */
+function commandHead(command: string | null): string | null {
+  if (command === null) return null;
+  const firstLine = command.split("\n")[0] ?? "";
+  return firstLine.replace(/\\n/g, " ").replace(/^[\s"'`]+|[\s"'`]+$/g, "");
+}
+
+/** 路径的文件名：`read /home/x/a.ts` 的抬头只值 `a.ts`，整条路径会把抬头挤满 */
+function basenameOf(path: string): string {
+  const parts = path.split("/").filter((part) => part.length > 0);
+  return parts.length > 0 ? (parts[parts.length - 1] as string) : path;
+}
+
+/** 参数对象里第一个非空字符串值：没有统一约定的工具就取它，总比一串 JSON 强 */
+function firstString(record: Record<string, unknown> | null): string | null {
+  if (record === null) return null;
+  for (const value of Object.values(record)) {
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+
+/**
+ * 折叠抬头的参数摘要：**按工具取那一个可读参数**，绝不把整段 JSON 泄出来。
+ * `bash` → command 第一行；`read`/`edit`/`write` → path 的文件名；`rg`/`grep` → pattern；
+ * `compress` → 没有单一可读参数（整段对话都在入参里），留空只显示 `×N`；
+ * 其它工具取第一个字符串参数。取不到一律返回空串（抬头就只剩 `×N`）。
+ * 参数本身是裸字符串时（少数工具直接传字符串）就把它当那一个参数。
+ */
+export function toolArgSummary(name: string, args: unknown): string {
+  if (name === "compress") return "";
+  const record = typeof args === "object" && args !== null && !Array.isArray(args)
+    ? (args as Record<string, unknown>)
+    : null;
+  const single = typeof args === "string" ? args : null;
+  const field = (key: string): string | null => {
+    const value = record === null ? null : record[key];
+    return typeof value === "string" ? value : null;
+  };
+  let picked: string | null;
+  if (name === "bash") picked = commandHead(field("command") ?? single);
+  else if (name === "read" || name === "edit" || name === "write") {
+    const path = field("path") ?? single;
+    picked = path === null ? null : basenameOf(path);
+  } else if (name === "rg" || name === "grep") picked = field("pattern") ?? single;
+  else picked = firstString(record) ?? single;
+  return picked === null ? "" : clip(picked, TOOL_SUMMARY);
+}
+
+/** toolResult / user 的 content：可能是字符串，也可能是 [{type:"text",text}]，图片只留一句占位 */
+function contentText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const part of content) {
+    if (typeof part !== "object" || part === null) continue;
+    const record = part as Record<string, unknown>;
+    if (record.type === "text" && typeof record.text === "string") parts.push(record.text);
+    else if (record.type === "image") parts.push("（图片输出）");
+  }
+  return parts.join("\n");
+}
+
+/** 工具结果：只留前 200 字（完整输出在原理行数里，面板里看首尾就够判断成败） */
+function resultText(content: unknown): string {
+  return clip(contentText(content), MAX_RESULT);
+}
+
+/** assistant 内容块：文本拼接、toolCall 收集；thinking 不渲染（它是推理过程，不是回答） */
+function readAssistantParts(content: unknown): { text: string; calls: RawCall[] } {
+  if (typeof content === "string") return { text: content, calls: [] };
+  if (!Array.isArray(content)) return { text: "", calls: [] };
+  const texts: string[] = [];
+  const calls: RawCall[] = [];
+  for (const part of content) {
+    if (typeof part !== "object" || part === null) continue;
+    const record = part as Record<string, unknown>;
+    if (record.type === "text" && typeof record.text === "string") texts.push(record.text);
+    else if (record.type === "toolCall") {
+      const name = typeof record.name === "string" && record.name.length > 0 ? record.name : "（未命名工具）";
+      calls.push({
+        id: typeof record.id === "string" ? record.id : "",
+        name,
+        args: argumentsText(record.arguments),
+        summary: toolArgSummary(name, record.arguments),
+      });
+    }
+  }
+  return { text: texts.join("\n"), calls };
+}
+
+/** 解析整份 JSONL：坏行跳过（可能是进程被 kill 时写了一半的最后一行） */
+export function parseSessionText(raw: string): SessionTranscript {
+  type Pending = { entry: SessionEntry | { kind: "tools"; calls: RawCall[]; at: number | null }; roles: string[] };
+  const kept: Pending[] = [];
+  const results = new Map<string, string>();
+  const stamps: number[] = [];
+  let messages = 0;
+  for (const line of raw.split(/\r?\n/)) {
+    if (line.trim().length === 0) continue;
+    let record: Record<string, unknown>;
+    try {
+      record = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    if (record.type !== "message") continue;
+    const message = record.message;
+    if (typeof message !== "object" || message === null) continue;
+    const fields = message as Record<string, unknown>;
+    const role = typeof fields.role === "string" ? fields.role : "";
+    const at = stamp(record);
+    messages += 1;
+    if (at !== null) stamps.push(at);
+    if (role === "toolResult") {
+      // 结果先存起来：它总是排在携带 toolCall 的那条 assistant 消息之后
+      const id = typeof fields.toolCallId === "string" ? fields.toolCallId : "";
+      if (id.length > 0) results.set(id, resultText(fields.content));
+      continue;
+    }
+    if (role === "user") {
+      kept.push({ entry: { kind: "user", text: contentText(fields.content), at }, roles: [role] });
+      continue;
+    }
+    if (role !== "assistant") continue; // system 是系统提示词，不是对话
+    const parts = readAssistantParts(fields.content);
+    if (parts.text.trim().length > 0) {
+      const last = kept[kept.length - 1];
+      // 一条 assistant 消息里「文本 + toolCall」并存：文本先出，工具另起一段，顺序与真实发生一致
+      if (last && last.roles[last.roles.length - 1] === "assistant-text") {
+        last.entry = { kind: "assistant", text: `${(last.entry as { text: string }).text}\n${parts.text}`, at };
+      } else {
+        kept.push({ entry: { kind: "assistant", text: parts.text, at }, roles: ["assistant-text"] });
+      }
+    }
+    if (parts.calls.length > 0) {
+      const last = kept[kept.length - 1];
+      // 连续工具调用（中间没有文本）聚成一个折叠块：一次 read 一个块会堆出上百个折叠框
+      if (last && last.entry.kind === "tools" && last.roles[last.roles.length - 1] !== "assistant-text") {
+        (last.entry.calls as RawCall[]).push(...parts.calls);
+      } else {
+        kept.push({ entry: { kind: "tools", calls: [...parts.calls], at }, roles: ["tools"] });
+      }
+    }
+  }
+  const toolCalls = kept.reduce((sum, item) => (item.entry.kind === "tools" ? sum + item.entry.calls.length : sum), 0);
+  const dropped = Math.max(0, kept.length - MAX_MESSAGES);
+  // 全文扫完再回填结果：toolResult 一定在 toolCall 之后出现
+  const entries: SessionEntry[] = kept.slice(dropped).map((item) =>
+    item.entry.kind === "tools"
+      ? {
+          kind: "tools",
+          at: item.entry.at,
+          calls: (item.entry.calls as RawCall[]).map((call) => ({
+            name: call.name,
+            args: call.args,
+            summary: call.summary,
+            result: results.get(call.id) ?? "（没有结果）",
+          })),
+        }
+      : item.entry,
+  );
+  return {
+    entries,
+    messages,
+    toolCalls,
+    dropped,
+    firstAt: stamps.length === 0 ? null : Math.min(...stamps),
+    lastAt: stamps.length === 0 ? null : Math.max(...stamps),
+  };
+}