@baique/pi-web-sky 0.1.42 → 0.1.44

package/lib/board-reconcile.ts

@@ -15,6 +15,7 @@
 import { getBoard, listAllBoards } from "./board-store";
 import { listTaskSessionIds } from "./task-store";
 import { listCards, listLinks } from "./task-card-store";
+import { getDb } from "./sqlite-db";
 
 // ---- yjs maps 类型 + mutateBoard（由 server.mjs 通过 globalThis 注入，避免 Next 打包 node:sqlite）----
 interface BoardMaps {
@@ -113,20 +114,20 @@ function overlapsSessionCards(nodes: DocNode[], x: number, y: number, width: num
 }
 
 /**
- * 任务执行会话卡落点：锚定任务卡右侧（y 与任务卡齐平），右侧被占则回退 findFreeSpot。
- * 任务卡节点已存在才锚定（补齐顺序保证先补任务卡再补会话卡）。
+ * 派生卡落点：锚定锚点节点右侧（y 与锚点齐平），右侧被占则回退 findFreeSpot。
+ * 锚点为任务卡（exec 执行会话卡）或源会话卡（fork 会话卡），补齐顺序保证先补锚点。
  */
-function findSpotNearTaskCard(
+function findSpotNearAnchor(
   nodes: DocNode[],
-  taskNode: DocNode | undefined,
+  anchorNode: DocNode | undefined,
   width: number,
   height: number,
 ): { x: number; y: number } {
-  if (taskNode?.position) {
+  if (anchorNode?.position) {
     const STEP = 24;
-    const taskW = taskNode.style?.width ?? TASK_CARD_W;
-    const x = taskNode.position.x + taskW + STEP;
-    const y = taskNode.position.y;
+    const anchorW = anchorNode.style?.width ?? TASK_CARD_W;
+    const x = anchorNode.position.x + anchorW + STEP;
+    const y = anchorNode.position.y;
     if (!overlapsSessionCards(nodes, x, y, width, height)) return { x, y };
   }
   return findFreeSpot(nodes, width, height);
@@ -153,6 +154,15 @@ export async function reconcileBoard(boardId: string): Promise<void> {
   const allSessionIds = new Set<string>();
   if (isTaskBoard) for (const sid of listTaskSessionIds(board.taskId!)) allSessionIds.add(sid);
   for (const c of cards) if (c.sessionId) allSessionIds.add(c.sessionId);
+  // fork 会话派生：fork（parent_id 非空）会话的源会话归属本任务 → 本任务看板补 fork 卡。
+  // fork 会话自身不继承 task_id，需经源会话归属定位；普通看板 board.taskId 为空天然不参与。
+  const forkBySid = new Map<string, string>(); // forkSid -> parentSid
+  if (isTaskBoard) {
+    for (const { sessionId, parentId } of listTaskForkedSessions(board.taskId!)) {
+      allSessionIds.add(sessionId);
+      forkBySid.set(sessionId, parentId);
+    }
+  }
 
   await mutateBoard(boardId, (maps) => {
     const nodesMap = maps.nodes;
@@ -226,8 +236,12 @@ export async function reconcileBoard(boardId: string): Promise<void> {
         // 执行会话卡无条件补：会话是业务派生的独立展示（真实会话的存在性），
         // 不依赖宿主任务卡节点在不在画布——任务卡是画布管理，执行会话卡是业务派生，
         // 两者解耦。任务卡不在时落点回退 findFreeSpot（findSpotNearTaskCard 内部处理）。
-        const taskNode = card ? remaining.find((n) => n?.id === `task-${card.id}`) : undefined;
-        const spot = findSpotNearTaskCard(remaining, taskNode, SESSION_CARD_W, SESSION_CARD_H);
+        const parentSid = forkBySid.get(sid);
+        // 锚点：fork 会话卡锚定源会话卡右侧；执行会话卡锚定宿主任务卡右侧；无锚点回退 4 列布局
+        const anchor = parentSid
+          ? remaining.find((n) => n?.id === `session-${parentSid}`)
+          : card ? remaining.find((n) => n?.id === `task-${card.id}`) : undefined;
+        const spot = findSpotNearAnchor(remaining, anchor, SESSION_CARD_W, SESSION_CARD_H);
         nodesMap.set(id, {
           id,
           type: "session-card",
@@ -301,7 +315,37 @@ export async function reconcileBoard(boardId: string): Promise<void> {
       });
     }
 
-    // ---- 3) 依赖线：task_card_links → 建线（缺补多删）----
+    // ---- 3) fork 线：源会话卡 → fork 会话卡（forkLink，同 exec 蓝虚线）----
+    const existingForkEdges = new Map<string, string>(); // "src->tgt" -> edgeId
+    for (const e of Array.from(edgesMap.values())) {
+      if (!e.data?.forkLink) continue;
+      if (e.source && e.target) existingForkEdges.set(`${e.source}->${e.target}`, e.id);
+    }
+    const wantForkEdges = new Set<string>();
+    for (const [sid, parentSid] of forkBySid) {
+      const srcId = `session-${parentSid}`;
+      const tgtId = `session-${sid}`;
+      // 两端节点在画布才连线（补卡循环已补 fork 卡；源卡归属任务恒存在/本轮补）
+      if (!sessionShapes.has(parentSid) || !sessionShapes.has(sid)) continue;
+      const key = `${srcId}->${tgtId}`;
+      wantForkEdges.add(key);
+      if (!existingForkEdges.has(key)) {
+        edgesMap.set(`fork-${parentSid}-${sid}`, {
+          id: `fork-${parentSid}-${sid}`,
+          source: srcId,
+          target: tgtId,
+          type: "default",
+          data: { forkLink: true, parentId: parentSid, sessionId: sid },
+          markerEnd: { type: "arrowclosed" },
+          style: { strokeWidth: 1.5, stroke: "#3184f8", strokeDasharray: "6 4" },
+        });
+      }
+    }
+    for (const [key, edgeId] of existingForkEdges) {
+      if (!wantForkEdges.has(key)) edgesMap.delete(edgeId);
+    }
+
+    // ---- 4) 依赖线：task_card_links → 建线（缺补多删）----
     const existingLinks = new Map(); // "<from>-><to>:<kind>" -> edgeId
     for (const e of Array.from(edgesMap.values())) {
       if (!e.data?.taskLink) continue;
@@ -339,6 +383,36 @@ export async function reconcileBoard(boardId: string): Promise<void> {
   });
 }
 
+/** 源会话归属指定任务的 fork 会话（fork 关系 = session_meta.parent_id → 源会话 id）。
+ *  仅任务看板补 fork 卡：fork 卡是任务派生元素，经源会话的归属定位到任务看板。 */
+function listTaskForkedSessions(taskId: string): Array<{ sessionId: string; parentId: string }> {
+  return getDb()
+    .prepare(
+      `SELECT f.session_id AS sessionId, f.parent_id AS parentId
+       FROM session_meta f
+       JOIN session_meta s ON s.session_id = f.parent_id
+       WHERE f.parent_id IS NOT NULL AND s.task_id = ?`,
+    )
+    .all(taskId) as Array<{ sessionId: string; parentId: string }>;
+}
+
+/**
+ * fork 后精准触发：源会话归属任务 → reconcile 该任务看板（fork 卡即时出现）。
+ * 源会话不归属任何任务（普通看板）→ 无操作。单板 reconcile，毫秒级；
+ * 失败不阻塞 fork，由 10s 定时兜底。
+ */
+export async function reconcileForkBoard(sourceSessionId: string): Promise<void> {
+  const row = getDb()
+    .prepare("SELECT task_id AS taskId FROM session_meta WHERE session_id = ? AND task_id IS NOT NULL")
+    .get(sourceSessionId) as { taskId: string } | undefined;
+  if (!row?.taskId) return;
+  const boardRow = getDb()
+    .prepare("SELECT id FROM boards WHERE task_id = ?")
+    .get(row.taskId) as { id: string } | undefined;
+  if (!boardRow?.id) return;
+  await reconcileBoard(boardRow.id);
+}
+
 /**
  * 从所有 RF 看板的 yjs 文档中删除指定会话的会话卡（含占位卡）并级联删边。
  *

package/lib/card-emoji.test.mjs

@@ -7,13 +7,13 @@ const { DEFAULT_EMOJI, RANDOM_EMOJIS, randomEmoji, resolveEmoji } = await jiti.i
 
 test("类别默认：会话/任务/便笺固定初始值", () => {
   assert.equal(DEFAULT_EMOJI.session, "💬");
-  assert.equal(DEFAULT_EMOJI.task, "✅");
+  assert.equal(DEFAULT_EMOJI.task, "🚩");
   assert.equal(DEFAULT_EMOJI.note, "📝");
 });
 
 test("resolveEmoji：用户设置优先于类别默认", () => {
   assert.equal(resolveEmoji("session", "🐱"), "🐱");
-  assert.equal(resolveEmoji("task", undefined, "idle"), "✅");
+  assert.equal(resolveEmoji("task", undefined, "idle"), "🚩");
   assert.equal(resolveEmoji("note", "", null), "📝");
 });
 

package/lib/rpc-manager.ts

@@ -16,6 +16,7 @@ import { cacheSessionPath, invalidateSessionListCache } from "./session-reader";
 import { projectIdentityKey } from "./project-identity";
 import { resolveProject } from "./worktree";
 import { ensureSessionMetaRow } from "./task-store";
+import { reconcileForkBoard } from "./board-reconcile";
 import { getProjectTrustStatus, projectTrustReloadOptions } from "./project-trust";
 import { persistExplicitStartupPreferences } from "./startup-preferences";
 import type { SlashCommandInfo } from "@earendil-works/pi-coding-agent";
@@ -566,6 +567,16 @@ export class AgentSessionWrapper {
           const forkedPath = sourceManager.createBranchedSession(entry.parentId);
           if (!forkedPath) throw new Error("Failed to create forked session");
           newSessionFile = forkedPath;
+          // SDK 惰性落盘契约：fork 点之前无 assistant 消息时不写文件（flushed=false），
+          // 只返回路径字符串。若不强制落盘，后续 open 不存在文件会 newSession 生成新 id，
+          // meta 行指向不存在的文件——列表/看板卡片读不到，30s 扫描器删行 → “会话不存在”。
+          if (!existsSync(newSessionFile)) {
+            const content = [sourceManager.getHeader(), ...sourceManager.getEntries()]
+              .map((entry) => JSON.stringify(entry))
+              .join("\n") + "\n";
+            writeFileSync(newSessionFile, content, { encoding: "utf8", flag: "wx" });
+            (sourceManager as unknown as { flushed: boolean }).flushed = true;
+          }
         }
 
         const newSessionId = SessionManager.open(newSessionFile, sessionDir).getSessionId();
@@ -587,6 +598,10 @@ export class AgentSessionWrapper {
             projectKey: projectIdentityKey(project?.projectRoot ?? cwd ?? ""),
             parentId: sourceSessionId,
           });
+          // fork 卡即时入板：源会话归属任务 → 精准 reconcile 该任务看板。
+          // await 保证卡先落 yjs 再返回（前端响应到达时卡已存在，无并发写窗口）；
+          // 失败不阻塞 fork，10s 定时兜底。
+          await reconcileForkBoard(sourceSessionId);
         } catch {
           // 建行失败不阻塞 fork：扫描器下一轮兜底补行。
         }

package/lib/session-index-scanner.test.mjs

@@ -69,23 +69,49 @@ test("runSessionIndexScan：幂等（重复扫描不重复建行）", async () =
   }
 });
 
-test("runSessionIndexScan：mtime 变化只刷 modified，不重读", async () => {
+test("runSessionIndexScan：mtime 变化刷 modified + 回填 first_message（文件是内容事实源）", async () => {
   freshDb();
   const { root, projDir } = makeRoot();
   try {
+    // 模拟 persistNewSessionFile 建行：文件尚无消息 → first_message NULL
     const file = join(projDir, "2026-01-01T00-00-00-000Z_aaa.jsonl");
-    writeFileSync(file, sessionFileLines("aaa", "/home/u/project/alpha"));
+    writeFileSync(file, [
+      `{"type":"session","version":3,"id":"aaa","timestamp":"2026-01-01T00:00:00.000Z","cwd":"/home/u/project/alpha"}`,
+    ].join("\n") + "\n");
     await runSessionIndexScan(root);
+    assert.equal(getDb().prepare("SELECT first_message FROM session_meta WHERE session_id='aaa'").get().first_message, null, "无消息 → NULL");
     const before = getDb().prepare("SELECT modified FROM session_meta WHERE session_id='aaa'").get().modified;
 
-    // 追加内容 → mtime 变
+    // 用户发首条消息 → 文件 mtime 变
     await new Promise((r) => setTimeout(r, 10));
-    writeFileSync(file, sessionFileLines("aaa", "/home/u/project/alpha", "hello") + '{"type":"message","id":"a1","parentId":"u1","message":{"role":"assistant","content":"hi"}}\n');
+    writeFileSync(file, sessionFileLines("aaa", "/home/u/project/alpha", "你好项目") + '{"type":"message","id":"a1","parentId":"u1","message":{"role":"assistant","content":"hi"}}\n');
     const summary = await runSessionIndexScan(root);
     assert.equal(summary.inserted, 0);
     assert.equal(summary.updated, 1);
     const after = getDb().prepare("SELECT modified FROM session_meta WHERE session_id='aaa'").get().modified;
     assert.ok(after > before, "mtime 刷新");
+    const row = getDb().prepare("SELECT first_message FROM session_meta WHERE session_id='aaa'").get();
+    assert.equal(row.first_message, "你好项目", "mtime 分支回填 first_message");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("runSessionIndexScan：first_message 历史欠账（NULL 且 mtime 未变）→ 补跑回填", async () => {
+  freshDb();
+  const { root, projDir } = makeRoot();
+  try {
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_aaa.jsonl");
+    writeFileSync(file, sessionFileLines("aaa", "/home/u/project/alpha", "历史首条"));
+    await runSessionIndexScan(root);
+    // 模拟老行欠账：文件有消息但 first_message 被清成 NULL（persist 建行冻结场景）
+    getDb().prepare("UPDATE session_meta SET first_message = NULL WHERE session_id='aaa'").run();
+
+    const summary = await runSessionIndexScan(root);
+    assert.equal(summary.inserted, 0);
+    assert.equal(summary.updated, 1, "NULL 行补跑计入 updated");
+    const row = getDb().prepare("SELECT first_message FROM session_meta WHERE session_id='aaa'").get();
+    assert.equal(row.first_message, "历史首条", "mtime 未变也回填");
   } finally {
     rmSync(root, { recursive: true, force: true });
   }

package/lib/session-index-scanner.ts

@@ -56,13 +56,14 @@ export async function runSessionIndexScan(
   const summary: SessionIndexScanSummary = { scanned: diskFiles.length, inserted: 0, updated: 0, deleted: 0 };
 
   const db = getDb();
-  const selectAll = db.prepare("SELECT session_id, modified, path, parent_id FROM session_meta").all() as Array<{
+  const selectAll = db.prepare("SELECT session_id, modified, path, parent_id, first_message FROM session_meta").all() as Array<{
     session_id: string;
     modified: number | null;
     path: string | null;
     parent_id: string | null;
+    first_message: string | null;
   }>;
-  const dbRows = new Map(selectAll.map((r) => [r.session_id, { modified: r.modified, path: r.path, parent_id: r.parent_id }]));
+  const dbRows = new Map(selectAll.map((r) => [r.session_id, { modified: r.modified, path: r.path, parent_id: r.parent_id, first_message: r.first_message }]));
 
   const seenOnDisk = new Set<string>();
 
@@ -88,6 +89,7 @@ export async function runSessionIndexScan(
   );
   const updateModifiedStmt = db.prepare("UPDATE session_meta SET modified = ? WHERE session_id = ?");
   const updateParentStmt = db.prepare("UPDATE session_meta SET parent_id = ? WHERE session_id = ?");
+  const updateFirstMessageStmt = db.prepare("UPDATE session_meta SET first_message = ? WHERE session_id = ?");
   const deleteStmt = db.prepare("DELETE FROM session_meta WHERE session_id = ?");
 
   // 读 header + resolve project + upsert（新文件或老行补全索引列共用）。
@@ -116,6 +118,26 @@ export async function runSessionIndexScan(
     );
   };
 
+  // 从磁盘读 head 并收敛派生列（parent_id 重挂 + first_message 回填）。
+  // first_message 是内容派生列：文件写入了首条消息，索引必须跟随——
+  // 否则 persist 建行的会话（first_message 恒 NULL）标题永远冻结。
+  // 返回是否更新了 first_message（供 NULL 欠账补跑计数）。
+  const reconcileFromHead = (file: { path: string; id: string }, dbRow: { parent_id: string | null; first_message: string | null }): boolean => {
+    const head = scanOneSessionHead(file.path);
+    if (!head) return false;
+    const parentId = head.parentSessionPath
+      ? (pathToId.get(sessionPathKey(head.parentSessionPath)) ?? null)
+      : null;
+    if (parentId !== dbRow.parent_id) {
+      updateParentStmt.run(parentId, file.id);
+    }
+    if (head.firstMessage && head.firstMessage !== dbRow.first_message) {
+      updateFirstMessageStmt.run(head.firstMessage, file.id);
+      return true;
+    }
+    return false;
+  };
+
   for (const file of diskFiles) {
     seenOnDisk.add(file.id);
     const dbRow = dbRows.get(file.id);
@@ -125,21 +147,18 @@ export async function runSessionIndexScan(
       await upsertFromDisk(file);
       summary.inserted += 1;
     } else if (dbRow.modified === null || dbRow.modified !== file.modified.getTime()) {
-      // mtime 变化：刷新排序键；同时校验 parent 链——删除会话级联重挂/外部
-      // 重挂会改 header.parentSession 但行内 parent_id 不会自己变。读 header
-      // 首行（与 buildTaskSessionIndex 同成本）比对，不一致则更新：磁盘
-      // header 是父链唯一权威，任何来源的重挂都在这里收敛。
-      const head = scanOneSessionHead(file.path);
-      if (head) {
-        const parentId = head.parentSessionPath
-          ? (pathToId.get(sessionPathKey(head.parentSessionPath)) ?? null)
-          : null;
-        if (parentId !== dbRow.parent_id) {
-          updateParentStmt.run(parentId, file.id);
-        }
-      }
+      // mtime 变化：刷新排序键；同时收敛派生列——parent 链（删除会话级联
+      // 重挂/外部重挂会改 header.parentSession）与 first_message（内容写入
+      // 后标题必须跟随）。磁盘 header 是父链唯一权威，文件头是标题事实源。
+      reconcileFromHead(file, dbRow);
       updateModifiedStmt.run(file.modified.getTime(), file.id);
       summary.updated += 1;
+    } else if (!dbRow.first_message) {
+      // first_message 欠账补跑：persist 建行的老会话（first_message 恒 NULL）
+      // 在 mtime 已同步后仍需回填一次；文件已有首条消息则写入，否则保持 NULL。
+      if (reconcileFromHead(file, dbRow)) {
+        summary.updated += 1;
+      }
     }
   }
 

package/lib/session-reader.project.test.mjs

@@ -118,3 +118,89 @@ test("loadSessionSummariesByIds：按 id 点查摘要（title/lastReply/自定
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+test("loadTaskSessionsPageWithIndex：任务列表标题与聊天同源（session_meta，不依赖文件存在）", async () => {
+  freshDb();
+  markIndexReady();
+  // 文件都不存在（磁盘扫描快照外/已删）：标题必须仍能从 session_meta 读出，
+  // 与聊天列表 loadProjectSessions 同源（旧实现 scanOneSessionFile 读文件 → 全跳过）。
+  seedSession({ id: "a", cwd: "/home/u/p", projectKey: "/home/u/p", taskId: "task-1", firstMessage: "任务首条", path: "/no/such/a.jsonl", modified: 300 });
+  seedSession({ id: "b", cwd: "/home/u/p", projectKey: "/home/u/p", taskId: "task-1", firstMessage: "另一条", path: "/no/such/b.jsonl", modified: 200 });
+  // 非任务会话 → 不返回
+  seedSession({ id: "c", cwd: "/home/u/p", projectKey: "/home/u/p", firstMessage: "游离", path: "/no/such/c.jsonl", modified: 100 });
+
+  const { loadTaskSessionsPageWithIndex } = await jiti.import("./session-reader.ts");
+  const index = {
+    metaById: new Map([
+      ["a", { path: "/no/such/a.jsonl", id: "a", modified: new Date(300) }],
+      ["b", { path: "/no/such/b.jsonl", id: "b", modified: new Date(200) }],
+    ]),
+    childrenOf: new Map(),
+  };
+  const res = await loadTaskSessionsPageWithIndex("task-1", index, 0, 5);
+  assert.equal(res.sessions.length, 2, "文件不存在但 meta 有行 → 仍返回（与聊天列表同源）");
+  assert.equal(res.sessions[0].id, "a");
+  assert.equal(res.sessions[0].firstMessage, "任务首条", "标题来自 session_meta.first_message");
+  assert.equal(res.sessions[1].firstMessage, "另一条");
+  assert.equal(res.sessions[0].name, undefined);
+});
+
+test("loadProjectSessions：first_message 空且文件有首条消息 → lazy 读文件补标题并写回 meta", async () => {
+  freshDb();
+  markIndexReady();
+  const root = mkdtempSync(join(tmpdir(), "pi-lazy-"));
+  const projDir = join(root, "--home-u-p--");
+  mkdirSync(projDir, { recursive: true });
+  try {
+    const cwd = "/home/u/p";
+    // 有消息但 meta 未同步（persist 建行冻结场景）→ lazy 应补
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_a.jsonl");
+    writeFileSync(file, [
+      `{"type":"session","version":3,"id":"a","timestamp":"2026-01-01T00:00:00.000Z","cwd":"${cwd}"}`,
+      '{"type":"message","id":"u1","parentId":null,"message":{"role":"user","content":"lazy 首条"}}',
+    ].join("\n") + "\n");
+    seedSession({ id: "a", cwd, projectKey: cwd, path: file, firstMessage: null });
+    // 真空会话：文件无消息 → 保持 no messages
+    const emptyFile = join(projDir, "2026-01-02T00-00-00-000Z_b.jsonl");
+    writeFileSync(emptyFile, [
+      `{"type":"session","version":3,"id":"b","timestamp":"2026-01-02T00:00:00.000Z","cwd":"${cwd}"}`,
+    ].join("\n") + "\n");
+    seedSession({ id: "b", cwd, projectKey: cwd, path: emptyFile, firstMessage: null });
+
+    const { loadProjectSessions } = await jiti.import("./session-reader.ts");
+    const sessions = await loadProjectSessions(cwd);
+    const byId = Object.fromEntries(sessions.map((s) => [s.id, s]));
+    assert.equal(byId.a.firstMessage, "lazy 首条", "lazy 读文件补标题");
+    assert.equal(byId.b.firstMessage, "(no messages)", "真空会话保持 no messages");
+    const row = getDb().prepare("SELECT first_message FROM session_meta WHERE session_id='a'").get();
+    assert.equal(row.first_message, "lazy 首条", "lazy 补读后写回 meta");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("loadSessionDetailsFromMeta：任务列表同样 lazy 补标题并写回", async () => {
+  freshDb();
+  markIndexReady();
+  const root = mkdtempSync(join(tmpdir(), "pi-lazy-task-"));
+  const projDir = join(root, "--home-u-p--");
+  mkdirSync(projDir, { recursive: true });
+  try {
+    const cwd = "/home/u/p";
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_a.jsonl");
+    writeFileSync(file, [
+      `{"type":"session","version":3,"id":"a","timestamp":"2026-01-01T00:00:00.000Z","cwd":"${cwd}"}`,
+      '{"type":"message","id":"u1","parentId":null,"message":{"role":"user","content":"任务 lazy 首条"}}',
+    ].join("\n") + "\n");
+    seedSession({ id: "a", cwd, projectKey: cwd, path: file, firstMessage: null, taskId: "task-1" });
+
+    const { loadSessionDetailsFromMeta } = await jiti.import("./session-reader.ts");
+    const sessions = await loadSessionDetailsFromMeta(["a"]);
+    assert.equal(sessions.length, 1);
+    assert.equal(sessions[0].firstMessage, "任务 lazy 首条", "任务列表 lazy 补标题");
+    const row = getDb().prepare("SELECT first_message FROM session_meta WHERE session_id='a'").get();
+    assert.equal(row.first_message, "任务 lazy 首条", "写回 meta");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/lib/session-reader.ts

@@ -14,12 +14,81 @@ import { normalizeToolCalls } from "./normalize";
 import { projectIdentityKey } from "./project-identity";
 import { sessionPathKey } from "./session-path";
 import { resolveProject, type ProjectInfo } from "./worktree";
-import { scanSessionFiles, scanSessionFileMeta, scanOneSessionFile, sessionScanner } from "./session-scanner";
+import { scanSessionFileMeta, scanOneSessionFile, scanOneSessionHead, sessionScanner } from "./session-scanner";
 import { ensureSessionIndexReady } from "./session-index-scanner";
 import type { TurnIndexItem } from "./api-types";
 
 export { getAgentDir };
 
+type SessionMetaRow = Record<string, unknown>;
+
+/** 单个 session_meta 行 → SessionInfo（聊天列表与任务列表共用的唯一映射）。 */
+function mapSessionMetaRow(r: SessionMetaRow): SessionInfo {
+  return {
+    path: (r.path as string) ?? "",
+    id: r.session_id as string,
+    cwd: (r.cwd as string) ?? "",
+    name: (r.title as string | null) ?? undefined,
+    created: new Date((r.created as number) ?? 0).toISOString(),
+    modified: new Date((r.modified as number) ?? 0).toISOString(),
+    messageCount: 0,
+    firstMessage: (r.first_message as string | null) ?? "(no messages)",
+    parentSessionId: (r.parent_id as string | null) ?? undefined,
+    pinned: Boolean((r.pinned as number) ?? 0),
+  };
+}
+
+/** 按 id 集合查 session_meta 映射 SessionInfo（返回顺序与入参一致，无行 id 跳过）。
+ *  任务列表详情与聊天列表 loadProjectSessions 完全同源——标题/首条消息不再依赖
+ *  读文件（旧 readSessionDetails → scanOneSessionFile），统一由 session_meta 供给。 */
+export async function loadSessionDetailsFromMeta(ids: string[]): Promise<SessionInfo[]> {
+  if (ids.length === 0) return [];
+  let rows: Array<Record<string, unknown>>;
+  try {
+    rows = getDb()
+      .prepare(
+        `SELECT session_id, path, cwd, title, first_message, parent_id, created, modified, pinned
+         FROM session_meta WHERE session_id IN (${ids.map(() => "?").join(",")})`,
+      )
+      .all(...ids) as Array<Record<string, unknown>>;
+  } catch {
+    return [];
+  }
+  const byId = new Map(rows.map((r) => [r.session_id as string, r]));
+  const sessions: SessionInfo[] = [];
+  for (const id of ids) {
+    const row = byId.get(id);
+    if (row) sessions.push(mapSessionMetaRow(row));
+  }
+  return fillFirstMessageFromFile(sessions);
+}
+
+/**
+ * lazy 回填：列表读取时对 first_message 为空的会话读文件头补真实首条消息
+ * （文件是内容事实源），并批量写回 session_meta（后台收敛，下次免读文件）。
+ * 真·空会话（文件无消息）保持 NULL → 显示 no messages。
+ * 列表（聊天/任务/全量）共用同一逻辑，保证各处标题一致。
+ */
+function fillFirstMessageFromFile(sessions: SessionInfo[]): SessionInfo[] {
+  const pending = sessions.filter((s) => s.firstMessage === "(no messages)" && s.path);
+  if (pending.length === 0) return sessions;
+  const updateStmt = getDb().prepare("UPDATE session_meta SET first_message = ? WHERE session_id = ?");
+  return sessions.map((s) => {
+    if (s.firstMessage !== "(no messages)" || !s.path) return s;
+    let firstMessage = s.firstMessage;
+    try {
+      const head = scanOneSessionHead(s.path);
+      if (head?.firstMessage) {
+        firstMessage = head.firstMessage;
+        updateStmt.run(firstMessage, s.id);
+      }
+    } catch {
+      // 文件不可读（丢失/权限）→ 保持 no messages
+    }
+    return firstMessage === s.firstMessage ? s : { ...s, firstMessage };
+  });
+}
+
 /**
  * 当前项目聊天区会话（列表重构 v2 主读取路径）。
  *
@@ -45,18 +114,7 @@ export async function loadProjectSessions(projectKey: string): Promise<SessionIn
     return [];
   }
 
-  const sessions: SessionInfo[] = rows.map((r) => ({
-    path: (r.path as string) ?? "",
-    id: r.session_id as string,
-    cwd: (r.cwd as string) ?? "",
-    name: (r.title as string | null) ?? undefined,
-    created: new Date((r.created as number) ?? 0).toISOString(),
-    modified: new Date((r.modified as number) ?? 0).toISOString(),
-    messageCount: 0,
-    firstMessage: (r.first_message as string | null) ?? "(no messages)",
-    parentSessionId: (r.parent_id as string | null) ?? undefined,
-    pinned: Boolean((r.pinned as number) ?? 0),
-  }));
+  const sessions = fillFirstMessageFromFile(rows.map(mapSessionMetaRow));
   return attachSessionProjectInfo(sessions);
 }
 
@@ -78,18 +136,7 @@ export async function loadAllSessionIndex(): Promise<SessionInfo[]> {
     return [];
   }
 
-  const sessions: SessionInfo[] = rows.map((r) => ({
-    path: (r.path as string) ?? "",
-    id: r.session_id as string,
-    cwd: (r.cwd as string) ?? "",
-    name: (r.title as string | null) ?? undefined,
-    created: new Date((r.created as number) ?? 0).toISOString(),
-    modified: new Date((r.modified as number) ?? 0).toISOString(),
-    messageCount: 0,
-    firstMessage: (r.first_message as string | null) ?? "(no messages)",
-    parentSessionId: (r.parent_id as string | null) ?? undefined,
-    pinned: Boolean((r.pinned as number) ?? 0),
-  }));
+  const sessions = fillFirstMessageFromFile(rows.map(mapSessionMetaRow));
   return attachSessionProjectInfo(sessions);
 }
 
@@ -166,33 +213,6 @@ async function loadAllSessions(): Promise<SessionInfo[]> {
   return attachSessionProjectInfo(sessions);
 }
 
-/** 阶段二：批量读详情（只读需要的子集）。返回顺序与入参一致。 */
-async function readSessionDetails(metas: Array<{ path: string; id: string; modified: Date }>): Promise<SessionInfo[]> {
-  const pathToId = new Map<string, string>();
-  for (const m of metas) pathToId.set(sessionPathKey(m.path), m.id);
-  const sessions: SessionInfo[] = [];
-  for (const meta of metas) {
-    const scanned = scanOneSessionFile(meta.path);
-    if (!scanned) continue;
-    cacheSessionPath(scanned.id, scanned.path);
-    sessions.push({
-      path: scanned.path,
-      id: scanned.id,
-      cwd: scanned.cwd,
-      name: scanned.name,
-      created: scanned.created.toISOString(),
-      modified: scanned.modified.toISOString(),
-      messageCount: 0,
-      firstMessage: scanned.firstMessage || "(no messages)",
-      lastReply: scanned.lastReply || "",
-      parentSessionId: scanned.parentSessionPath ? pathToId.get(sessionPathKey(scanned.parentSessionPath)) : undefined,
-      transient: false,
-    });
-  }
-  return sessions;
-}
-
-
 /** 任务会话详情按需分页（侧栏任务区）。
  *
  *  服务端分流：任务下的会话详情由 /api/tasks 直接下发，前端不再用
@@ -283,8 +303,9 @@ export async function loadTaskSessionsPageWithIndex(
   for (const rid of pageRootIds) {
     for (const id of collectSubtree(rid)) wantedIds.add(id);
   }
-  const orderedMetas = [...wantedIds].map((id) => metaById.get(id)).filter((m): m is NonNullable<typeof m> => Boolean(m));
-  const sessions = await attachSessionProjectInfo(await readSessionDetails(orderedMetas));
+  // 详情走 session_meta（与聊天列表 loadProjectSessions 同源）——标题/首条消息
+  // 由索引供给，不再读文件；不存在/未入索引的 id 自然跳过。
+  const sessions = await attachSessionProjectInfo(await loadSessionDetailsFromMeta([...wantedIds]));
 
   // sessionTotal：任务下全部根 + 子树节点数（删除确认文案）。
   const allIds = new Set<string>();

package/lib/task-store.ts

@@ -33,7 +33,7 @@ const now = () => Date.now();
  */
 function invalidateSessionListCache(): void {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     require("./session-reader").invalidateSessionListCache();
   } catch {
     // 循环加载/不可用时忽略——下一次 force 刷新会重建缓存

package/lib/worktree.test.mjs

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -48,3 +48,19 @@ test("main and linked worktrees share one canonical project root", async (t) =>
   assert.ok(listedLinked);
   assert.equal(findCurrentWorktreePath(worktrees, `${linked}${path.sep}`), listedLinked.path);
 });
+
+test("resolveCwdOrProjectRoot：已删除 worktree 目录回退主项目根；存在目录原样", async (t) => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "pi-web-wt-rm-"));
+  t.after(() => rm(tempRoot, { recursive: true, force: true }));
+
+  const repo = path.join(tempRoot, "repo");
+  await execFileAsync("git", ["init", repo]);
+  // addWorktree 约定：worktree 落在 <repoRoot>-worktrees/<branch> 下
+  const removed = path.join(`${repo}-worktrees`, "feature-test");
+  await mkdir(removed, { recursive: true });
+  await rm(removed, { recursive: true, force: true }); // 模拟 worktree 目录已删除
+
+  const { resolveCwdOrProjectRoot } = await loadSubject();
+  assert.equal(await resolveCwdOrProjectRoot(removed), await realpath(repo), "已删 worktree 回退主根");
+  assert.equal(await resolveCwdOrProjectRoot(repo), repo, "存在目录原样");
+});

package/lib/worktree.ts

@@ -49,6 +49,15 @@ export function invalidateProjectCache(): void {
   globalThis.__piProjectCache?.clear();
 }
 
+/** cwd 指向已删除的 worktree（目录不存在）时回退到主项目根；目录存在则原样返回。
+ *  会话 cwd 落盘即锁定，worktree 目录被删后，模型/信任/git/分支操作应继续按主
+ *  checkout 可用（让用户能切回主分支），而不是 4xx 把页面卡死。 */
+export async function resolveCwdOrProjectRoot(cwd: string): Promise<string> {
+  if (existsSync(cwd)) return cwd;
+  const project = await resolveProject(cwd);
+  return project.projectRoot || cwd;
+}
+
 async function git(cwd: string, args: string[]): Promise<string> {
   const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
     timeout: 10_000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baique/pi-web-sky",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Web UI for the pi coding agent — Sky skin edition (fork of @agegr/pi-web / earendil-labs pi-web, MIT)",
   "homepage": "https://github.com/baique/pi-web-sky#readme",
   "repository": {