@baique/pi-web-sky 0.1.55 → 0.1.57

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/路径缓存/列表缓存/任务元数据/画布引用），不重挂子树。 */

package/lib/session-family.test.mjs

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const { getSessionFamily, listSessionFamilies } = await createJiti(import.meta.url).import("./session-family.ts");
+
+function session(id, modified, relation) {
+  return {
+    path: `/tmp/${id}.jsonl`,
+    id,
+    cwd: "/tmp",
+    created: modified,
+    modified,
+    messageCount: 1,
+    firstMessage: id,
+    ...(relation ? { relation } : {}),
+  };
+}
+
+test("groups nested subagents under their main session and uses family activity for sorting", () => {
+  const main = session("main", "2026-01-01T00:00:00.000Z");
+  const child = session("child", "2026-01-04T00:00:00.000Z", {
+    kind: "subagent", parentSessionId: "main", profile: "explore", description: "Explore", status: "completed",
+  });
+  const grandchild = session("grandchild", "2026-01-03T00:00:00.000Z", {
+    kind: "subagent", parentSessionId: "child", profile: "review", description: "Review", status: "running",
+  });
+  const newerRoot = session("newer-root", "2026-01-02T00:00:00.000Z");
+
+  const families = listSessionFamilies([main, child, grandchild, newerRoot]);
+  assert.deepEqual(families.map((family) => family.root.id), ["main", "newer-root"]);
+  assert.deepEqual(families[0].subagents.map((item) => item.id), ["child", "grandchild"]);
+  assert.equal(getSessionFamily([main, child, grandchild], "grandchild")?.root.id, "main");
+});
+
+test("does not promote orphaned or cyclic subagent metadata into the main session list", () => {
+  const orphan = session("orphan", "2026-01-03T00:00:00.000Z", {
+    kind: "subagent", parentSessionId: "missing", profile: "explore", description: "Explore", status: "interrupted",
+  });
+  const a = session("a", "2026-01-01T00:00:00.000Z", {
+    kind: "subagent", parentSessionId: "b", profile: "a", description: "A", status: "interrupted",
+  });
+  const b = session("b", "2026-01-02T00:00:00.000Z", {
+    kind: "subagent", parentSessionId: "a", profile: "b", description: "B", status: "interrupted",
+  });
+
+  assert.deepEqual(listSessionFamilies([orphan, a, b]), []);
+  assert.equal(getSessionFamily([orphan, a, b], "orphan"), null);
+});

package/lib/session-family.ts

@@ -0,0 +1,80 @@
+import type { SessionInfo } from "./types";
+
+export interface SessionFamily {
+  root: SessionInfo;
+  subagents: SessionInfo[];
+  latestModified: string;
+}
+
+function resolveFamilyRoots(sessions: readonly SessionInfo[]): Map<string, string | null> {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+  const roots = new Map<string, string | null>();
+
+  for (const session of sessions) {
+    if (roots.has(session.id)) continue;
+
+    const path: string[] = [];
+    const visited = new Set<string>();
+    let currentId = session.id;
+    let rootId: string | null = null;
+
+    while (true) {
+      if (roots.has(currentId)) {
+        rootId = roots.get(currentId) ?? null;
+        break;
+      }
+      if (visited.has(currentId)) break;
+
+      visited.add(currentId);
+      path.push(currentId);
+      const current = byId.get(currentId);
+      if (!current) break;
+      if (current.relation?.kind !== "subagent") {
+        rootId = current.id;
+        break;
+      }
+      currentId = current.relation.parentSessionId;
+    }
+
+    for (const id of path) roots.set(id, rootId);
+  }
+
+  return roots;
+}
+
+/** Groups visible main/fork sessions with every persisted subagent descendant. */
+export function listSessionFamilies(sessions: readonly SessionInfo[]): SessionFamily[] {
+  const rootsBySessionId = resolveFamilyRoots(sessions);
+  const families = new Map<string, SessionFamily>();
+
+  for (const session of sessions) {
+    if (session.relation?.kind === "subagent") continue;
+    families.set(session.id, {
+      root: session,
+      subagents: [],
+      latestModified: session.modified,
+    });
+  }
+
+  for (const session of sessions) {
+    if (session.relation?.kind !== "subagent") continue;
+    const rootId = rootsBySessionId.get(session.id);
+    const family = rootId ? families.get(rootId) : undefined;
+    if (!family) continue;
+    family.subagents.push(session);
+    if (session.modified > family.latestModified) family.latestModified = session.modified;
+  }
+
+  return [...families.values()].sort((a, b) => b.latestModified.localeCompare(a.latestModified));
+}
+
+export function getSessionFamily(
+  sessions: readonly SessionInfo[],
+  sessionId: string | null | undefined,
+): SessionFamily | null {
+  if (!sessionId) return null;
+  return listSessionFamilies(sessions).find((family) => (
+    family.root.id === sessionId
+    || family.subagents.some((session) => session.id === sessionId)
+  )) ?? null;
+}