pi-skill-evolve 0.1.4 → 0.1.6

package/extensions/skill-evolve/lib/web/data.ts

@@ -1,5 +1,5 @@
 /**
- * 只读 Web 面板的数据聚合：把 `.pi/evolution/` 的散落文件拼成三个视图要的形状。
+ * 只读 Web 面板的数据聚合：把 `.pi/evolution/` 的散落文件拼成五个视图要的形状。
  *
  * 三条纪律：
  * 1. **只读**：这里不写盘、不开监听、不改任何状态 —— 面板永远不能变成第二个写入方；
@@ -7,60 +7,34 @@
  *    null / []，绝不因为一条烂记录让整页 500（用户从飞书点进来只想要个概览）；
  * 3. **数字不重算**：summary 直接复用 collectPanelState，和 TUI 状态栏同一口径 ——
  *    两处各算一套，迟早出现「TUI 说待批 2、网页说待批 3」。
+ *
+ * 这里只留**视图形状 + 聚合入口**：四类待处理条目的判定在 ./pending.ts，已处理在 ./done.ts，
+ * 待审批 / 已采纳 / 报告各自一个文件 —— 合在一起必然破 300 行闸门。
  */
-import * as fs from "node:fs";
-import * as path from "node:path";
 import { collectPanelState } from "../panel.ts";
-import { readQueue, type QueueItem } from "../queue.ts";
-import { listRuns, type RunSummary } from "../runs.ts";
-import { CHILD_LOG } from "../spawn-plan.ts";
-import { classifyStale, readLogTail } from "../stale.ts";
-import { readRunError } from "../stale.ts";
-import { asNumber, asText } from "./json-read.ts";
+import { readQueue } from "../queue.ts";
+import { listRuns } from "../runs.ts";
 import { buildApplied, type AppliedItem } from "./applied.ts";
 import { buildApprovals, type ApprovalItem } from "./approvals.ts";
+import { buildDone, type DoneItem } from "./done.ts";
+import { buildPending, type PendingItem } from "./pending.ts";
 import { buildReports, type RunReport } from "./reports.ts";
 
 export { MAX_FINDING_ROWS } from "./reports.ts";
 export type { FindingRow, RunReport } from "./reports.ts";
 export type { ApprovalItem } from "./approvals.ts";
 export type { AppliedItem } from "./applied.ts";
+export type { PendingItem, PendingKind } from "./pending.ts";
+export type { DoneItem } from "./done.ts";
+export { DONE_LIMIT } from "./done.ts";
 
-/** 列表页（技能管理页 `skills` 与两个详情页 `run` / `skill` 不在这个联合里，见 filter.ts 的 PANEL_VIEWS） */
+/** 列表页（技能管理页 `skills` 与三个详情页 `run` / `skill` / `session` 不在这个联合里，见 filter.ts 的 PANEL_VIEWS） */
 export const WEB_VIEWS = ["pending", "approvals", "applied", "done", "reports"] as const;
 export type WebView = (typeof WEB_VIEWS)[number];
 
-/** 已处理列表上限：网页是「翻最近发生了什么」，不是审计日志（审计看 runs/ 目录本身） */
-export const DONE_LIMIT = 50;
 /** 扫描最近多少个 run：卡死 / 待入队这类判断只需要看近期，runs/ 里可能有几百个历史目录 */
 const SCAN_LIMIT = 100;
 
-/** 单 run 默认上限：与 DEFAULT_CONFIG.maxRuntimeMs 同值，面板只用来算「上限 N 分钟」 */
-const DEFAULT_MAX_RUNTIME_MS = 20 * 60_000;
-
-/** 待处理四来源：正在跑 / 已判卡死 / 队列待批 / 评审通过但还没入队 */
-export type PendingKind = "running" | "approval" | "stale" | "reviewed";
-
-export interface PendingItem {
-  runId: string;
-  kind: PendingKind;
-  skill: string;
-  at: number | null;
-  /** 展开后的纯文本（渲染层负责转义） */
-  detail: string;
-}
-
-export interface DoneItem {
-  runId: string;
-  status: string;
-  /** queue = 采纳队列（有层级与详情）；run = 只有 run.json 的终态（比如 rejected 从未入队） */
-  source: "queue" | "run";
-  level: string;
-  skill: string;
-  at: number | null;
-  detail: string;
-}
-
 export interface WebSummary {
   reviewing: number;
   stale: number;
@@ -89,193 +63,6 @@ export interface WebStateDeps {
   maxRuntimeMs?: number;
 }
 
-function defaultAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0); // 信号 0 只探测存在性，不真发信号
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** 把毫秒压成「Xm Ys」：面板上人只关心量级，不关心毫秒 */
-function duration(ms: number): string {
-  const total = Math.max(0, Math.floor(ms / 1000));
-  return `${Math.floor(total / 60)}m ${total % 60}s`;
-}
-
-/**
- * 「正在跑」那一条：光看 `复盘 1` 这个数字不知道是谁、跑到哪、要不要杀，
- * 所以把阶段 / 进程 / 最近输出 / 看日志的命令四行摊开（用户 2026-11-08：「复盘中我也想看到状态呢」）。
- */
-function runningItem(
-  run: RunSummary,
-  evolutionDir: string,
-  now: number,
-  alive: (pid: number) => boolean,
-  maxRuntimeMs: number,
-): PendingItem | null {
-  if (run.status !== "dispatched" || run.pid === null || !alive(run.pid)) return null;
-  const reviewing = run.supervisorPid !== null && alive(run.supervisorPid);
-  const logPath = path.join(evolutionDir, "runs", run.runId, CHILD_LOG);
-  let mtime: number | null = null;
-  try {
-    mtime = fs.statSync(logPath).mtimeMs; // 拿不到就是还没写过日志
-  } catch {
-    mtime = null;
-  }
-  const tail = readLogTail(logPath, 1);
-  const lastLine = tail.length > 0 ? tail[tail.length - 1]!.trim() : "";
-  const progressLine =
-    mtime === null
-      ? "最近输出：（还没有输出）"
-      : `最近输出：${Math.max(0, Math.round((now - mtime) / 1000))}s 前 · 末行：${lastLine.length > 0 ? lastLine : "（还没有输出）"}`;
-  return {
-    runId: run.runId,
-    kind: "running",
-    skill: run.proposal?.skill ?? "",
-    at: run.dispatchedAt,
-    detail: [
-      `阶段：${reviewing ? "评审中" : "复盘产出中"}`,
-      `进程：pid ${run.pid} · 已跑 ${duration(now - (run.dispatchedAt ?? now))}（上限 ${Math.round(maxRuntimeMs / 60_000)} 分钟）`,
-      progressLine,
-      `日志：tail -f .pi/evolution/runs/${run.runId}/${CHILD_LOG}`,
-    ].join("\n"),
-  };
-}
-
-/** 四类条目的展示优先级：正在跑最上头，然后卡死、待批、待入队 */
-const PENDING_RANK: Record<PendingKind, number> = { running: 0, stale: 1, approval: 2, reviewed: 3 };
-
-function buildPending(
-  items: readonly QueueItem[],
-  runs: readonly RunSummary[],
-  evolutionDir: string,
-  deps: WebStateDeps = {},
-): PendingItem[] {
-  const now = deps.now ?? Date.now();
-  const alive = deps.alive ?? defaultAlive;
-  const maxRuntimeMs = deps.maxRuntimeMs ?? DEFAULT_MAX_RUNTIME_MS;
-  const pending: PendingItem[] = [];
-  // ⓪ 正在跑的：有活 pid 就是「进行中」，先列出来（它不是等批也不是失败）
-  const running = new Set<string>();
-  for (const run of runs) {
-    const item = runningItem(run, evolutionDir, now, alive, maxRuntimeMs);
-    if (!item) continue;
-    running.add(run.runId);
-    pending.push(item);
-  }
-  // ① 队列里待人批的（approval 级；auto 级不需要人，出现 pending 只是还没轮到执行）
-  for (const item of items) {
-    if (item.status !== "pending" || item.level !== "approval") continue;
-    pending.push({
-      runId: item.runId,
-      kind: "approval",
-      skill: item.skill,
-      at: asNumber(item.createdAt),
-      detail: [
-        "层级：approval（必须人批，auto 不会替你执行）",
-        `目标：${item.targets.join("、") || "（未写 targets）"}`,
-        item.detail ? `备注：${item.detail}` : "",
-        `操作：去「待审批」页（?view=approvals）直接点批准 / 拒绝，也可以在这里回 TUI 敲 /skill-evolve approve ${item.runId}`,
-      ]
-        .filter((line) => line.length > 0)
-        .join("\n"),
-    });
-  }
-  // ② 已判定卡死的 run：它是「失败」而不是「等批」，单独一类，别混进待批数字里。
-  //    这里必须包含「判据命中、run.json 还没落盘」的那一批：顶部 summary.stale 用的是
-  //    collectPanelState 的同一口径，少一类就会出现「头顶说卡死 5、列表只有 3 条」。
-  for (const run of runs) {
-    if (running.has(run.runId)) continue; // 同一个 run 不能既「进行中」又「卡死」
-    const persisted = run.status === "stale";
-    if (!persisted && !classifyStale(run, now).stale) continue;
-    const error = readRunError(path.join(evolutionDir, "runs", run.runId));
-    const tail = error?.childLogTail ?? [];
-    const lastLine = tail.length > 0 ? tail[tail.length - 1]!.trim() : "";
-    pending.push({
-      runId: run.runId,
-      kind: "stale",
-      skill: run.proposal?.skill ?? "",
-      at: error?.at ?? run.dispatchedAt,
-      detail: [
-        `原因：${error?.reason === "timeout" ? "超时（子进程还活着但超过单 run 上限）" : "子进程已退出"}`,
-        lastLine.length > 0 ? `日志末行：${lastLine}` : "日志末行：（子进程没留下任何输出）",
-        `排查：cat ${path.join(evolutionDir, "runs", run.runId, "run-error.json")}`,
-        "不会自动重跑：需要重新复盘就 /skill-evolve run",
-      ].join("\n"),
-    });
-  }
-  // ④ 子进程已产出结论、评审还没跑的：不是失败（子进程本来就该退出），属于「等下一轮接上」
-  for (const run of runs) {
-    if (run.status !== "analyzed" && run.status !== "proposed") continue;
-    pending.push({
-      runId: run.runId,
-      kind: "reviewed",
-      skill: run.proposal?.skill ?? "",
-      at: run.dispatchedAt,
-      detail: [
-        `状态：已出结论（${run.status}），评审还没跑`,
-        "会自动接上：下次 settle 或 session_start 继续；想立即接上就 /skill-evolve run",
-        `证据：cat ${path.join(evolutionDir, "runs", run.runId, "01-findings.json")}`,
-      ].join("\n"),
-    });
-  }
-  // ③ 评审通过但还没进队列（入队发生在 settle / session_start，中间可能还没轮到）
-  const queued = new Set(items.map((item) => item.runId));
-  for (const run of runs) {
-    if (run.status !== "reviewed" || queued.has(run.runId)) continue;
-    pending.push({
-      runId: run.runId,
-      kind: "reviewed",
-      skill: run.proposal?.skill ?? "",
-      at: run.dispatchedAt,
-      detail: [
-        `评审：${asText(run.review?.verdict, "（未写 verdict）")} · 建议动作 ${asText(run.review?.action, "无")}`,
-        "状态：评审已通过，尚未入队（settle / session_start 会自动补）",
-        `兜底：/skill-evolve approve ${run.runId}`,
-      ].join("\n"),
-    });
-  }
-  return pending.sort((a, b) => PENDING_RANK[a.kind] - PENDING_RANK[b.kind] || (b.at ?? 0) - (a.at ?? 0));
-}
-
-/**
- * 「已处理」收的终态：回滚 / 失败 / 否决 / 被取代。
- * **不含 applied** —— 采纳有自己的页（见 ./applied.ts），两边都收就等于两个 tab 都算一遍。
- */
-const DONE_STATUSES = new Set(["rolled-back", "failed", "rejected", "superseded"]);
-
-function buildDone(items: readonly QueueItem[], runs: readonly RunSummary[]): DoneItem[] {
-  const byRun = new Map<string, DoneItem>();
-  for (const run of runs) {
-    if (!DONE_STATUSES.has(run.status)) continue;
-    byRun.set(run.runId, {
-      runId: run.runId,
-      status: run.status,
-      source: "run",
-      level: asText(run.review?.action, "-"),
-      skill: run.proposal?.skill ?? "",
-      at: run.dispatchedAt,
-      detail: run.review?.verdict ? `评审：${run.review.verdict}` : "",
-    });
-  }
-  // 队列记录覆盖同 runId：它有层级（auto/approval）与失败详情，比 run.json 只有状态有用
-  for (const item of items) {
-    if (!DONE_STATUSES.has(item.status)) continue;
-    byRun.set(item.runId, {
-      runId: item.runId,
-      status: item.status,
-      source: "queue",
-      level: item.level,
-      skill: item.skill,
-      at: asNumber(item.createdAt),
-      detail: item.detail ?? "",
-    });
-  }
-  return [...byRun.values()].sort((a, b) => (b.at ?? 0) - (a.at ?? 0)).slice(0, DONE_LIMIT);
-}
-
 export function collectWebState(input: { evolutionDir: string } & WebStateDeps): WebState {
   const { evolutionDir, ...deps } = input;
   const items = readQueue(evolutionDir);
@@ -285,7 +72,7 @@ export function collectWebState(input: { evolutionDir: string } & WebStateDeps):
     pending: buildPending(items, runs, evolutionDir, deps),
     approvals: buildApprovals(evolutionDir, items),
     applied: buildApplied(items, evolutionDir),
-    done: buildDone(items, runs),
+    done: buildDone(items, runs, evolutionDir),
     reports: buildReports(evolutionDir, runs),
     summary: {
       reviewing: panel.reviewing,

package/extensions/skill-evolve/lib/web/done.ts

@@ -0,0 +1,65 @@
+/**
+ * 「已处理」视图的数据：回滚 / 失败 / 否决 / 被取代这四种终态。
+ *
+ * 为什么不和「已采纳」混：采纳有自己的页（见 ./applied.ts），两边都收就等于两个 tab 各算一遍。
+ * 队列记录会覆盖同一个 runId 的 run.json 版本：它有层级（auto/approval）与失败详情，比只有状态有用。
+ */
+import type { QueueItem } from "../queue.ts";
+import type { RunSummary } from "../runs.ts";
+import { asNumber, asText } from "./json-read.ts";
+import { sessionForRun, sessionIndex, sessionOfRun, type SessionRef } from "./run-session.ts";
+
+/** 已处理列表上限：网页是「翻最近发生了什么」，不是审计日志（审计看 runs/ 目录本身） */
+export const DONE_LIMIT = 50;
+
+export interface DoneItem {
+  runId: string;
+  status: string;
+  /** queue = 采纳队列（有层级与详情）；run = 只有 run.json 的终态（比如 rejected 从未入队） */
+  source: "queue" | "run";
+  /** 会话信息：行上「会话」列要用（缺 = NO_SESSION） */
+  session: SessionRef;
+  level: string;
+  skill: string;
+  at: number | null;
+  detail: string;
+}
+
+/**
+ * 「已处理」收的终态：回滚 / 失败 / 否决 / 被取代。
+ * **不含 applied** —— 采纳有自己的页（见 ./applied.ts），两边都收就等于两个 tab 都算一遍。
+ */
+const DONE_STATUSES = new Set(["rolled-back", "failed", "rejected", "superseded"]);
+
+export function buildDone(items: readonly QueueItem[], runs: readonly RunSummary[], evolutionDir: string): DoneItem[] {
+  const byRun = new Map<string, DoneItem>();
+  const sessions = sessionIndex(runs);
+  for (const run of runs) {
+    if (!DONE_STATUSES.has(run.status)) continue;
+    byRun.set(run.runId, {
+      runId: run.runId,
+      status: run.status,
+      source: "run",
+      session: sessionOfRun(run),
+      level: asText(run.review?.action, "-"),
+      skill: run.proposal?.skill ?? "",
+      at: run.dispatchedAt,
+      detail: run.review?.verdict ? `评审：${run.review.verdict}` : "",
+    });
+  }
+  // 队列记录覆盖同 runId：它有层级（auto/approval）与失败详情，比 run.json 只有状态有用
+  for (const item of items) {
+    if (!DONE_STATUSES.has(item.status)) continue;
+    byRun.set(item.runId, {
+      runId: item.runId,
+      status: item.status,
+      source: "queue",
+      session: sessionForRun(item.runId, sessions, evolutionDir),
+      level: item.level,
+      skill: item.skill,
+      at: asNumber(item.createdAt),
+      detail: item.detail ?? "",
+    });
+  }
+  return [...byRun.values()].sort((a, b) => (b.at ?? 0) - (a.at ?? 0)).slice(0, DONE_LIMIT);
+}

package/extensions/skill-evolve/lib/web/filter.ts

@@ -174,12 +174,12 @@ export function parseView(raw: string | null): WebView {
 }
 
 /**
- * 面板上的全部页面：五个列表页 + 技能管理 + 两个详情页。
+ * 面板上的全部页面：五个列表页 + 技能管理 + 三个详情页。
  *
- * 详情页（run / skill）与技能管理页**需要额外参数**（runId / name / days），所以它们不能进 `VIEW_ORDER`,
- * 也不能靠 `parseView` 认 —— 这是两件事，两个函数各自负责一件事。
+ * 详情页（run / skill / session）与技能管理页**需要额外参数**（runId / name / days / sessionId），
+ * 所以它们不能进 `VIEW_ORDER`, 也不能靠 `parseView` 认 —— 这是两件事，两个函数各自负责一件事。
  */
-export const PANEL_VIEWS = [...WEB_VIEWS, "skills", "skill", "run"] as const;
+export const PANEL_VIEWS = [...WEB_VIEWS, "skills", "skill", "run", "session"] as const;
 export type PanelView = (typeof PANEL_VIEWS)[number];
 
 /** `?view=` → 全页面名；只认白名单，其余（含 null、`../`）回落待处理页 */

package/extensions/skill-evolve/lib/web/list-query.ts

@@ -0,0 +1,43 @@
+/**
+ * 列表页的三个**显式开关** query：`live`（自动刷新）、`open`（分组是否展开）、`only`（会话页只看对话）。
+ *
+ * 为什么与 filter.ts 分开：筛选决定「哪些条目出现」，这三个开关决定「同一批条目怎么呈现/何时重载」。
+ * 混进 `ListFilter` 会让 `paginate` / `buildViewPage` 每处都得带着两个不相干的字段。
+ *
+ * 为什么全走 URL 而不是 JS：面板零 JS。用户点过「收起分组」就该在这次刷新后仍然收着 ——
+ * 只有 URL 能记住这件事（服务端读它并显式回写链接），localStorage 之类都不在这个面板的可用手段里。
+ */
+import { pageHref, type ListFilter } from "./filter.ts";
+import type { WebView } from "./data.ts";
+
+export interface ListExtras {
+  /** 5 秒整页自动刷新：只在待处理页生效（其它页数据不会自己变，重载只会丢展开态） */
+  live: boolean;
+  /** 分组默认展开；`none` 是用户点了「全部收起」 */
+  open: "all" | "none";
+  /** 会话页只看对话（user 消息 + 助手纯文本），工具调用压成一行 */
+  only: "user" | null;
+}
+
+export const DEFAULT_EXTRAS: ListExtras = { live: false, open: "all", only: null };
+
+/**
+ * 解析三个开关。**按页面白名单放行**：`live=1` 在已采纳页没有意义，
+ * 照单全收会让「?view=done&live=1」也被 5 秒重载一次，用户会以为面板抽风。
+ */
+export function parseListExtras(params: URLSearchParams, view: WebView | "session"): ListExtras {
+  return {
+    live: view === "pending" && params.get("live") === "1",
+    open: params.get("open") === "none" ? "none" : "all",
+    only: view === "session" && params.get("only") === "user" ? "user" : null,
+  };
+}
+
+/** 翻页 / 刷新 / 收起分组共用的链接拼装：筛选参数由 pageHref 负责，这里只追加三个开关 */
+export function listHref(view: WebView, filter: ListFilter, page: number, extras: ListExtras): string {
+  const base = pageHref(view, filter, page);
+  const params = new URLSearchParams(base.slice(base.indexOf("?") + 1));
+  if (extras.live) params.set("live", "1");
+  if (extras.open === "none") params.set("open", "none");
+  return `/?${params.toString()}`;
+}

package/extensions/skill-evolve/lib/web/markdown-lite.ts

@@ -0,0 +1,95 @@
+/**
+ * Markdown-lite：会话正文里那一小撮「模型天天写、原样输出却很难看」的语法。
+ *
+ * 为什么只做这几个（用户 2026-11-08：「Markdown 原样输出满屏 `**加粗**`」）：
+ * pi 的助手回复几乎每段都带 `**粗体**`、`` `路径` ``、`- ` 列表、``` 代码块、`[文字](url)`，
+ * 直接 `<pre>` 输出等于把符号也念给人听。但面板不需要完整 Markdown 实现
+ * （表格、脚注、嵌套列表一律不做），行数少、行为可预测比「支持得多」重要。
+ *
+ * **XSS 纪律**：先 `escapeHtml` 再替换语法，替换只插自己写的标签，用户文本永远进不了标签内部；
+ * `[文字](url)` 只保留文字、整段丢弃 URL —— 否则 `[x](javascript:alert(1))` 就是一个可点的洞。
+ */
+import { escapeHtml } from "./text.ts";
+
+/** 围栏代码块：开口行可带语言名（不渲染高亮，只要别把它当正文） */
+const FENCE = /```[^\n]*\n([\s\S]*?)```/g;
+
+/** 占位符用的控制字符：正文转义后不可能出现，所以不会被内容伪造 */
+const SLOT = "\u0000";
+
+/** 行内语法：先抠出代码块占位，再处理粗体 / 行内代码 / 链接（顺序不能反，否则代码块里的 `*` 会被当粗体） */
+function inline(escaped: string, blocks: string[]): string {
+  const withSlots = escaped.replace(FENCE, (_all, code: string) => {
+    blocks.push(`<pre class="code"><code>${code.replace(/\n$/, "")}</code></pre>`);
+    return `${SLOT}${blocks.length - 1}${SLOT}`;
+  });
+  return withSlots
+    .replace(/`([^`\n]+)`/g, "<code>$1</code>")
+    .replace(/\*\*([^*\n]+)\*\*/g, "<strong>$1</strong>")
+    .replace(/\[([^\]\n]+)\]\((?:[^()\s]|\([^()\s]*\))*\)/g, "$1");
+}
+
+/** 把段落里残留的代码块占位换回真区块（代码块夹在句子中间时不会独占一段） */
+function restore(text: string, blocks: string[]): string {
+  return text.replace(new RegExp(`${SLOT}(\\d+)${SLOT}`, "g"), (_all, index: string) => blocks[Number(index)] ?? "");
+}
+
+/**
+ * 文字与代码块混在一段：按占位符切开，文字段各自包 `<p>`。
+ * 不能直接把 `<pre>` 塞进 `<p>`（浏览器会把 `<p>` 提前闭合，后面的文字被踢出正文流）。
+ */
+function mixed(lines: string[], blocks: string[]): string {
+  const out: string[] = [];
+  let buffer: string[] = [];
+  const flush = (): void => {
+    const text = buffer.join("\n").trim();
+    if (text.length > 0) out.push(`<p>${text.replace(/\n/g, "<br>")}</p>`);
+    buffer = [];
+  };
+  for (const line of lines) {
+    line.split(new RegExp(`${SLOT}(\\d+)${SLOT}`)).forEach((part, index) => {
+      if (index % 2 === 1) {
+        flush();
+        out.push(blocks[Number(part)] ?? "");
+      } else if (part.length > 0) {
+        buffer.push(part);
+      }
+    });
+  }
+  flush();
+  return out.join("\n");
+}
+
+/** 一个段落：代码块占位 / 标题 / 列表 / 普通段落（普通段落里的换行保留成 `<br>`） */
+function block(text: string, blocks: string[]): string {
+  const slot = new RegExp(`^${SLOT}(\\d+)${SLOT}$`).exec(text);
+  if (slot !== null) return blocks[Number(slot[1])] ?? "";
+  const heading = /^(#{1,2}) (.*)$/.exec(text);
+  if (heading !== null) {
+    const level = heading[1] === "#" ? 3 : 4;
+    return `<h${level} class="md-h">${restore(heading[2], blocks)}</h${level}>`;
+  }
+  const lines = text.split("\n");
+  if (lines.every((line) => line.startsWith("- "))) {
+    return `<ul class="md-ul">${lines.map((line) => `<li>${restore(line.slice(2), blocks)}</li>`).join("")}</ul>`;
+  }
+  if (text.includes(SLOT)) return mixed(lines, blocks);
+  return `<p>${lines.join("<br>")}</p>`;
+}
+
+/**
+ * 正文 → HTML。空文本给空串（调用方据此判断「这条没有正文，别画空块」），
+ * 其余按空行分段，每段单独判定类型。
+ */
+export function renderMarkdownLite(raw: string): string {
+  if (raw.trim().length === 0) return "";
+  const blocks: string[] = [];
+  const text = inline(escapeHtml(raw), blocks);
+  return text
+    .split(/\n{2,}/)
+    .map((part) => part.replace(/^\n+|\n+$/g, ""))
+    .filter((part) => part.length > 0)
+    .map((part) => block(part, blocks))
+    .filter((part) => part.length > 0)
+    .join("\n");
+}