@baique/pi-web-sky 0.1.56 → 0.1.57

package/lib/rpc-manager.ts

@@ -21,9 +21,18 @@ import { resolveShellTools } from "./powershell-settings";
 import { CHAT_ONLY_RESOURCE_LOADER_OPTIONS } from "./chat-only";
 import { cacheSessionPath, invalidateSessionListCache, resolveSessionPath } from "./session-reader";
 import { indexSessionFileNow } from "./session-index-scanner";
+import { createSessionActivityTracker, type AgentLikeMessage } from "./session-activity";
+import { FIRST_MESSAGE_PREVIEW_LENGTH } from "./session-scanner";
 import { projectIdentityKey } from "./project-identity";
 import { resolveProject } from "./worktree";
-import { ensureSessionMetaRow } from "./task-store";
+import {
+  ensureSessionMetaRow,
+  fillFirstMessageIfEmpty,
+  recordSessionOutcome,
+  setSessionTitle,
+  taskForSession,
+  touchSessionActivity,
+} from "./task-store";
 import { reconcileForkBoard } from "./board-reconcile";
 import { getProjectTrustStatus, projectTrustReloadOptions } from "./project-trust";
 import { persistExplicitStartupPreferences } from "./startup-preferences";
@@ -215,6 +224,8 @@ export class AgentSessionWrapper {
   private _alive = true;
   /** 最近一次 agent_start 的时间（看板“运行时长”用）；0 = 未知 */
   private lastAgentStart = 0;
+  /** 会话活跃事件 → 落库（last_reply / modified）；按 wrapper 实例持有防并发串台 */
+  private readonly activityTracker = createSessionActivityTracker();
   private readonly exactSystemPrompt?: () => string;
   private readonly chatOnly: boolean;
 
@@ -276,11 +287,42 @@ export class AgentSessionWrapper {
         invalidateSessionListCache();
       }
       if (IDLE_RESET_EVENT_TYPES.has(event.type)) this.resetIdleTimer();
+      // 会话活跃落库（last_reply / modified）。包在 try/catch 里：库是旁路索引，
+      // 写失败必须可见（console.error），但绝不能打断上面几件事与事件分发。
+      try {
+        this.persistSessionActivity(event);
+      } catch (error) {
+        console.error(
+          `[pi-web] 会话活跃写库失败（${event.type}）:`,
+          error instanceof Error ? error.message : String(error),
+        );
+      }
       this.emit(event);
     });
     this.resetIdleTimer();
   }
 
+  /**
+   * 事件 → session_meta 写入（只 UPDATE；行由创建/扫描链路建立）：
+   *   · agent_start   → modified 前移（运行中会话浮顶）
+   *   · message_end   → 本轮最后一条 assistant 文本（缓存，不落库）
+   *   · agent_settled → last_reply + modified（一轮循环真正结束；用户取消走同一路径）
+   * 用 agent_settled 而非 agent_end：后者一轮里可能多次（重试/compaction/queue 续跑）。
+   */
+  private persistSessionActivity(event: AgentEvent): void {
+    const effect = this.activityTracker.handle(event as { type: string; message?: AgentLikeMessage });
+    if (!effect) return;
+    const sessionId = this.inner.sessionId;
+    if (!sessionId) return;
+    if (effect.kind === "touch") {
+      touchSessionActivity(sessionId);
+      return;
+    }
+    recordSessionOutcome(sessionId, effect);
+    // 首条用户消息此刻已在内存 entries 里（不读文件，读取路径零扫盘）。
+    fillFirstMessageIfEmpty(sessionId, firstUserMessageOf(this.inner.sessionManager.getEntries()));
+  }
+
   setForceEmptySystemPrompt(force: boolean): void {
     this.forceEmptySystemPrompt = force;
     this.applyForcedEmptySystemPrompt();
@@ -630,8 +672,10 @@ export class AgentSessionWrapper {
         const newSessionId = SessionManager.open(forkedPath, sessionDir).getSessionId();
         cacheSessionPath(newSessionId, forkedPath);
         invalidateSessionListCache();
-        // 立即进 session_meta 索引（否则要等 30s 后台扫描才出现在会话列表）
-        await indexSessionFileNow(forkedPath, sessionManager.getSessionId());
+        // 立即进 session_meta 索引（否则要等 30s 后台扫描才出现在会话列表）；
+        // 归属继承：引用分支与源会话同任务（否则只会在聊天区当孤儿根出现）。
+        const sourceSessionId = sessionManager.getSessionId();
+        await indexSessionFileNow(forkedPath, sourceSessionId, taskForSession(sourceSessionId));
         return { cancelled: false, newSessionId };
       }
 
@@ -694,6 +738,7 @@ export class AgentSessionWrapper {
         // resolveProject 的 await 不能发生在 registry 还挂着已 fork wrapper 的窗口里；
         // 建行只用局部变量（cwd/newSessionFile/sourceSessionId），不依赖 wrapper。
         const cwd = sessionManager.getCwd();
+        const sourceTaskId = taskForSession(sourceSessionId); // 归属继承：fork 子会话与父同任务
         await this.shutdown();
         try {
           const project = await resolveProject(cwd ?? "");
@@ -702,13 +747,28 @@ export class AgentSessionWrapper {
             cwd: cwd ?? "",
             projectKey: projectIdentityKey(project?.projectRoot ?? cwd ?? ""),
             parentId: sourceSessionId,
+            taskId: sourceTaskId, // 建行即带归属，否则子会话先以临时会话落在聊天区（V1）
           });
+        } catch (error) {
+          // 不阻塞 fork（文件已经在了，pi 侧已成功），但必须可见：静默失败会让子会话
+          // 以「无归属临时会话」出现在聊天区（也是本次要修的 V1 病灶）；扫描器的归属
+          // 收敛是第二道网，不能当成唯一防线。
+          console.error(
+            `[pi-web] fork 建行失败 session=${newSessionId}:`,
+            error instanceof Error ? error.message : String(error),
+          );
+        }
+        try {
           // fork 卡即时入板：源会话归属任务 → 精准 reconcile 该任务看板。
           // await 保证卡先落 yjs 再返回（前端响应到达时卡已存在，无并发写窗口）；
-          // 失败不阻塞 fork，10s 定时兜底。
+          // 失败不阻塞 fork，10s 定时兜底。单独一个 try：与建行失败分开报错，避免
+          // 入板失败被误报成「建行失败」。
           await reconcileForkBoard(sourceSessionId);
-        } catch {
-          // 建行失败不阻塞 fork：扫描器下一轮兜底补行。
+        } catch (error) {
+          console.error(
+            `[pi-web] fork 入板失败 source=${sourceSessionId}:`,
+            error instanceof Error ? error.message : String(error),
+          );
         }
         return { cancelled: false, newSessionId };
       }
@@ -748,6 +808,15 @@ export class AgentSessionWrapper {
         const name = (command.name as string | undefined)?.trim();
         if (!name) throw new Error("Session name cannot be empty");
         this.inner.setSessionName(name);
+        // 列表索引同步：pi 侧改名成功即写 session_meta.title（前端侧栏/看板卡
+        // 改名走这条 RPC，不落库则刷新后退回旧标题）。失败处理与路由层同源但
+        // 语义有别：这里只记日志、不抛——RPC 已经改了文件名，抛错对调用方没有
+        // 可恢复动作，还会断掉命令响应/事件流。
+        try {
+          await setSessionTitle(this.inner.sessionId, name);
+        } catch (error) {
+          console.error("[pi-web] 会话标题写库失败:", error);
+        }
         invalidateSessionListCache();
         return null;
       }
@@ -1576,8 +1645,13 @@ async function persistNewSessionFile(manager: SessionManager, sessionId: string)
       // 与扫描器同源归一化（Windows 大小写折叠等），防新建会话 project_key 与列表查询键不一致
       projectKey: projectIdentityKey(project?.projectRoot ?? cwd ?? ""),
     });
-  } catch {
-    // 建行失败不阻塞开会话：扫描器下一轮兜底补行。
+  } catch (error) {
+    // 建行失败不阻塞开会话（文件已落盘，运行时列表由 runtime union 覆盖），但必须可见：
+    // 静默会让该会话最多 30s 不在列表/任务区（扫描器会补行，但不能当成唯一防线）。
+    console.error(
+      `[pi-web] 新会话建行失败 session=${sessionId}:`,
+      error instanceof Error ? error.message : String(error),
+    );
   }
 }
 
@@ -1595,6 +1669,19 @@ function runtimeMessageText(entry: SessionMessageEntry): string {
     .join(" ");
 }
 
+/**
+ * 内存 entries 里首条用户消息的简述（截断与扫描器同一上限）。
+ * 会话活跃事件落库时用它回填 first_message——读取路径不再读文件。
+ */
+function firstUserMessageOf(entries: unknown[]): string {
+  for (const entry of entries as SessionMessageEntry[]) {
+    if (entry?.type !== "message" || entry.message?.role !== "user") continue;
+    const text = runtimeMessageText(entry).trim();
+    if (text) return text.slice(0, FIRST_MESSAGE_PREVIEW_LENGTH);
+  }
+  return "";
+}
+
 function runtimeMessageActivityMs(entry: SessionMessageEntry): number | undefined {
   if (entry.message.role !== "user" && entry.message.role !== "assistant") return undefined;
   if (typeof entry.message.timestamp === "number") return entry.message.timestamp;

package/lib/session-activity.test.mjs

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+  alias: { "@": process.cwd() },
+});
+const { createSessionActivityTracker, lastAssistantText } = await jiti.import("./session-activity.ts");
+
+const assistant = (text, ts, stopReason = "stop") => ({
+  role: "assistant",
+  timestamp: ts,
+  stopReason,
+  content: [{ type: "text", text }],
+});
+
+/** 依次喂事件，返回所有非 null 效果（真实调用方的用法：一轮事件流按序处理）。 */
+function run(events) {
+  const tracker = createSessionActivityTracker();
+  const effects = [];
+  for (const event of events) {
+    const effect = tracker.handle(event);
+    if (effect) effects.push(effect);
+  }
+  return effects;
+}
+
+test("agent_start → touch（只刷活跃时间，浮动到列表顶部）", () => {
+  assert.deepEqual(run([{ type: "agent_start" }]), [{ kind: "touch" }]);
+});
+
+test("单条 message_end 不落 outcome（不是循环最后一条）", () => {
+  assert.deepEqual(run([{ type: "message_end", message: assistant("中间回复", 1000) }]), []);
+});
+
+test("agent_settled → outcome（带最后一条 assistant 文本与时间戳）", () => {
+  const effects = run([
+    { type: "message_end", message: assistant("第一条", 1000) },
+    { type: "message_end", message: { role: "user", content: "再问" } },
+    { type: "message_end", message: assistant("最后一条回复", 2000) },
+    { type: "agent_settled" },
+  ]);
+  assert.deepEqual(effects, [{ kind: "outcome", lastReply: "最后一条回复", at: 2000 }]);
+});
+
+test("用户取消（stopReason=aborted）同样落 outcome", () => {
+  const effects = run([
+    { type: "message_end", message: assistant("被打断的半截回复", 3000, "aborted") },
+    { type: "agent_settled" },
+  ]);
+  assert.deepEqual(effects, [{ kind: "outcome", lastReply: "被打断的半截回复", at: 3000 }]);
+});
+
+test("本轮没采到任何文本 → 只 touch（空文本不清库）", () => {
+  // 刚发出就被取消 / 整轮只有工具调用：agent_settled 不得产出 lastReply:""，
+  // 否则调用方会把已存的最后一条回复清空。
+  assert.deepEqual(run([{ type: "agent_start" }, { type: "agent_settled" }]), [
+    { kind: "touch" },
+    { kind: "touch" },
+  ]);
+  assert.deepEqual(
+    run([
+      { type: "message_end", message: { role: "assistant", timestamp: 1, content: [{ type: "toolCall", name: "bash" }] } },
+      { type: "message_end", message: { role: "assistant", timestamp: 2, content: [{ type: "thinking", thinking: "想一想" }] } },
+      { type: "message_end", message: { role: "assistant", timestamp: 3, content: [{ type: "text", text: "   " }] } },
+      { type: "agent_settled" },
+    ]),
+    [{ kind: "touch" }],
+  );
+});
+
+test("settle 后 pending 归零：第二段 settle（无新消息）只 touch", () => {
+  const tracker = createSessionActivityTracker();
+  tracker.handle({ type: "message_end", message: assistant("回复", 1000) });
+  assert.deepEqual(tracker.handle({ type: "agent_settled" }), {
+    kind: "outcome",
+    lastReply: "回复",
+    at: 1000,
+  });
+  assert.deepEqual(tracker.handle({ type: "agent_settled" }), { kind: "touch" });
+});
+
+test("tracker 按实例持有状态：并发会话不串台", () => {
+  const a = createSessionActivityTracker();
+  const b = createSessionActivityTracker();
+  a.handle({ type: "message_end", message: assistant("A 的回复", 1000) });
+  b.handle({ type: "message_end", message: assistant("B 的回复", 2000) });
+  assert.deepEqual(b.handle({ type: "agent_settled" }), {
+    kind: "outcome",
+    lastReply: "B 的回复",
+    at: 2000,
+  });
+  assert.deepEqual(a.handle({ type: "agent_settled" }), {
+    kind: "outcome",
+    lastReply: "A 的回复",
+    at: 1000,
+  });
+});
+
+test("无关事件（tool_execution_end 等）不产生效果，也不破坏 pending", () => {
+  const effects = run([
+    { type: "message_end", message: assistant("回复", 1000) },
+    { type: "tool_execution_start", toolName: "bash" },
+    { type: "queue_update", steering: [] },
+    { type: "agent_settled" },
+  ]);
+  assert.deepEqual(effects, [{ kind: "outcome", lastReply: "回复", at: 1000 }]);
+});
+
+test("lastAssistantText：只取 text 块，thinking/toolCall 忽略", () => {
+  assert.equal(
+    lastAssistantText({
+      role: "assistant",
+      content: [{ type: "thinking", thinking: "x" }, { type: "text", text: "a" }, { type: "text", text: "b" }],
+    }),
+    "a\nb",
+  );
+  assert.equal(lastAssistantText({ role: "assistant", content: "plain" }), "plain");
+  assert.equal(lastAssistantText({ role: "assistant" }), "");
+  assert.equal(lastAssistantText({ role: "assistant", content: [{ type: "text", text: "  " }] }), "");
+});

package/lib/session-activity.ts

@@ -0,0 +1,77 @@
+// ============================================================================
+// 会话活跃事件 → 数据库写入意图（纯函数，无 IO）
+//
+// 背景：会话列表的「最后一条消息」「最后活跃时间」原先由 30s 扫描器从文件
+// mtime 反推（滞后 ≤30s，且发消息不刷库）。改为事件驱动：一轮循环真正结束
+// 时（agent_settled）把最后一条 assistant 文本与时间戳落库；用户取消走同一条
+// 路径（SDK 会为取消生成 stopReason="aborted" 的 assistant 消息，随后同样
+// 走 turn_end → agent_end → agent_settled）。
+//   · agent_start                → touch（活跃时间立刻前移，运行中会话浮顶）
+//   · message_end(assistant)     → 缓存本轮最后一条（不落库；一轮可能多条）
+//   · agent_settled              → outcome（落 last_reply + modified）
+// 两个边界：
+//   · agent_end 一轮里可能多次（重试/compaction/queue 续跑），所以不用它落库；
+//     message_end 也不是「循环结束」，单条不落库。
+//   · 本轮一条 assistant 文本都没采到（刚发出就被取消、整轮只有工具调用）时，
+//     agent_settled 退化为 touch —— **绝不用空文本覆盖已存的 last_reply**。
+// 状态必须**按 wrapper 实例**持有：多个会话并发跑时共享模块级变量会串台。
+// ============================================================================
+
+/** 事件里透传的 message（SDK 的 AgentMessage 的最小结构约定）。 */
+export interface AgentLikeMessage {
+  role?: string;
+  content?: unknown;
+  timestamp?: number;
+  stopReason?: string;
+}
+
+export type SessionActivityEffect =
+  | { kind: "touch" }
+  | { kind: "outcome"; lastReply: string; at: number };
+
+/** assistant 消息的纯文本（text 块拼接；无 text 返回 ""）。 */
+export function lastAssistantText(message: AgentLikeMessage): string {
+  const content = message.content;
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((block): block is { type?: string; text?: string } => Boolean(block) && typeof block === "object")
+    .filter((block) => block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text as string)
+    .join("\n")
+    .trim();
+}
+
+/** 每个 AgentSessionWrapper 持有一个 tracker，内部缓存「本轮最后一条 assistant」。 */
+export function createSessionActivityTracker(): {
+  handle(event: { type: string; message?: AgentLikeMessage }): SessionActivityEffect | null;
+} {
+  let pending: { lastReply: string; at: number } | null = null;
+  return {
+    handle(event) {
+      if (event.type === "agent_start") return { kind: "touch" };
+      if (event.type === "message_end") {
+        const message = event.message;
+        if (message?.role === "assistant") {
+          const text = lastAssistantText(message);
+          // 空文本（纯工具轮 / 半截回复）不覆盖已缓存的文本：本轮最后一条有内容的
+          // assistant 消息才是「最后一条消息」。
+          if (text) {
+            pending = {
+              lastReply: text,
+              at: typeof message.timestamp === "number" ? message.timestamp : Date.now(),
+            };
+          }
+        }
+        return null;
+      }
+      if (event.type === "agent_settled") {
+        const outcome = pending;
+        pending = null;
+        // 本轮没采到文本 → 只刷活跃时间，让调用方保留库里已有的 last_reply。
+        return outcome ? { kind: "outcome", ...outcome } : { kind: "touch" };
+      }
+      return null;
+    },
+  };
+}

package/lib/session-delete.test.mjs

@@ -1,53 +1,57 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import test from "node:test";
 import { createJiti } from "jiti";
+import { DatabaseSync } from "node:sqlite";
 
 const jiti = createJiti(import.meta.url, { interopDefault: true, moduleCache: false });
 const { collectSessionDescendants } = await jiti.import("./session-delete.ts");
-const { cacheSessionPath } = await jiti.import("./session-reader.ts");
-
-function sessionFile(dir, id, parentPath) {
-  const p = join(dir, `${Date.now()}_${id}.jsonl`);
-  const header = {
-    type: "session",
-    version: 3,
-    id,
-    timestamp: new Date().toISOString(),
-    cwd: dir,
-    ...(parentPath ? { parentSession: parentPath } : {}),
-  };
-  writeFileSync(p, JSON.stringify(header) + "\n");
-  return p;
+const { setDbForTesting, getDb } = await jiti.import("./sqlite-db.ts");
+
+function freshDb() {
+  setDbForTesting(new DatabaseSync(":memory:"));
+}
+
+/** 建一行会话索引。collectSessionDescendants 只读 session_meta.parent_id：
+ *  盘上有没有文件、文件在哪个目录都不影响（旧实现靠 readdirSync 平铺目录 + 读每个
+ *  文件 header 推父链，所以那时必须有文件且必须同目录——见下面「跨目录」用例）。 */
+function seed(id, parentId = null, path = `/nonexistent/${id}.jsonl`) {
+  getDb()
+    .prepare("INSERT INTO session_meta (session_id, task_id, updated, pinned, path, parent_id) VALUES (?, NULL, 1, 0, ?, ?)")
+    .run(id, path, parentId);
 }
 
-test("collectSessionDescendants walks the whole fork tree (multi-level)", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "pi-sd-"));
-  try {
-    const rootPath = sessionFile(dir, "root-id");
-    const child1Path = sessionFile(dir, "child1", rootPath);
-    sessionFile(dir, "child2", child1Path); // 两级分叉：child1 → child2
-    sessionFile(dir, "unrelated", undefined); // 无 parentSession 的无关会话
-    // 注入路径缓存，resolveSessionPath 命中后不触碰真实 sessions 目录。
-    cacheSessionPath("root-id", rootPath);
-
-    const ids = await collectSessionDescendants("root-id");
-    assert.deepEqual(ids.sort(), ["root-id", "child1", "child2"].sort());
-    assert.ok(!ids.includes("unrelated"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
+test("collectSessionDescendants walks the whole fork tree by DB parent_id (multi-level)", async () => {
+  freshDb();
+  seed("root-id");
+  seed("child1", "root-id");
+  seed("child2", "child1"); // 两级分叉：child1 → child2
+  seed("unrelated");
+
+  const ids = await collectSessionDescendants("root-id");
+  assert.deepEqual(ids.sort(), ["root-id", "child1", "child2"].sort());
+  assert.ok(!ids.includes("unrelated"));
 });
 
 test("collectSessionDescendants returns the root alone when there are no forks", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "pi-sd-"));
-  try {
-    const rootPath = sessionFile(dir, "root-alone");
-    cacheSessionPath("root-alone", rootPath);
-    assert.deepEqual(await collectSessionDescendants("root-alone"), ["root-alone"]);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
+  freshDb();
+  seed("root-alone");
+  assert.deepEqual(await collectSessionDescendants("root-alone"), ["root-alone"]);
+});
+
+test("collectSessionDescendants 跨目录：子目录里的 fork 也要一起删（旧实现只 readdir 平铺目录会漏）", async () => {
+  freshDb();
+  // 外部 pi 系工具的布局：`<proj>/<session>/forks/<ts>_<id>.jsonl`。库里 parent_id 已含
+  // 全部副本，所以父子的 path 在不同目录、甚至文件早就不在盘上，一样整棵返回。
+  seed("root", null, "/proj/2026-01-01T00-00-00Z_root.jsonl");
+  seed("fork1", "root", "/proj/2026-01-01T00-00-00Z_root/forks/2026-01-01T00-10-00-000Z_fork1.jsonl");
+  seed("fork2", "fork1", "/nonexistent/fork2.jsonl"); // 文件已不在盘上：库里仍要删
+
+  assert.deepEqual((await collectSessionDescendants("root")).sort(), ["fork1", "fork2", "root"]);
+});
+
+test("collectSessionDescendants 防环：脏 parent_id 环不会死循环", async () => {
+  freshDb();
+  seed("a", "b");
+  seed("b", "a");
+  assert.deepEqual((await collectSessionDescendants("a")).sort(), ["a", "b"]);
 });

package/lib/session-delete.ts

@@ -3,50 +3,24 @@
 // 与单个会话删除（app/api/sessions/[id] DELETE）不同：那里删一个节点并把
 // 子树级联重挂到父级；这里整棵树全部删除，不做重挂。
 
-import { readdirSync, unlinkSync } from "fs";
-import { dirname, join } from "path";
+import { unlinkSync } from "fs";
 import {
   invalidateSessionListCache,
   invalidateSessionPathCache,
-  readSessionHeader,
   resolveSessionPath,
 } from "./session-reader";
-import { sessionPathKey } from "./session-path";
 import { getRpcSession } from "./rpc-manager";
-import { unassignSession } from "./task-store";
+import { listDescendantIds, unassignSession } from "./task-store";
 import { removeSessionFromBoards } from "./board-store";
 import { removeSessionsFromYjsBoards } from "./board-reconcile";
 
-/** 递归收集一个会话的全部 fork 后代 id（含自身）。 */
+/** 递归收集一个会话的全部 fork 后代 id（含自身）。
+ *
+ *  父子链以 session_meta.parent_id 为唯一事实源：旧实现 readdirSync 平铺会话目录
+ *  + 读每个文件 header 推父链，既漏掉子目录里的 fork（`<session>/forks/…`），
+ *  也在每次删任务时把整个项目目录读一遍。库里的 parent_id 已含全部副本。 */
 export async function collectSessionDescendants(rootId: string): Promise<string[]> {
-  const rootPath = await resolveSessionPath(rootId);
-  if (!rootPath) return [rootId];
-  const dir = dirname(rootPath);
-  const keySet = new Set<string>([sessionPathKey(rootPath)]);
-  const ids = [rootId];
-  let files: string[];
-  try {
-    files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
-  } catch {
-    return [rootId];
-  }
-  // 迭代扫描：parentSession 指向已收集集合的 .jsonl 全部纳入（支持多级分叉）。
-  let added = true;
-  while (added) {
-    added = false;
-    for (const file of files) {
-      const p = join(dir, file);
-      const pk = sessionPathKey(p);
-      if (keySet.has(pk)) continue;
-      const header = readSessionHeader(p);
-      if (header?.parentSession && keySet.has(sessionPathKey(header.parentSession))) {
-        keySet.add(pk);
-        ids.push(header.id);
-        added = true;
-      }
-    }
-  }
-  return ids;
+  return [rootId, ...listDescendantIds(rootId)];
 }
 
 /** 删除单个会话文件（含 RPC/路径缓存/列表缓存/任务元数据/画布引用），不重挂子树。 */