@baique/pi-web-sky 0.1.60 → 0.1.61

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":17112532,"timestamp":23154317271,"id":14,"parentId":1,"tags":{},"startTime":1789988434698,"traceId":"c2ff66a5e4c7d328"},{"name":"run-typescript","duration":7106132,"timestamp":23171432664,"id":821,"parentId":1,"tags":{},"startTime":1789988451813,"traceId":"c2ff66a5e4c7d328"},{"name":"static-check","duration":4315677,"timestamp":23178556343,"id":824,"parentId":1,"tags":{},"startTime":1789988458937,"traceId":"c2ff66a5e4c7d328"},{"name":"static-generation","duration":4932951,"timestamp":23183121940,"id":980,"parentId":1,"tags":{},"startTime":1789988463502,"traceId":"c2ff66a5e4c7d328"},{"name":"collect-build-traces","duration":31653292,"timestamp":23182874446,"id":977,"parentId":1,"tags":{},"startTime":1789988463255,"traceId":"c2ff66a5e4c7d328"},{"name":"telemetry-flush","duration":38,"timestamp":23214530709,"id":989,"parentId":1,"tags":{},"startTime":1789988494910,"traceId":"c2ff66a5e4c7d328"},{"name":"next-build","duration":60439935,"timestamp":23154090818,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1789988434472,"traceId":"c2ff66a5e4c7d328"}]
+[{"name":"run-webpack","duration":14533465,"timestamp":272072983657,"id":14,"parentId":1,"tags":{},"startTime":1790237349471,"traceId":"80188c259035d77e"},{"name":"run-typescript","duration":13931446,"timestamp":272087518906,"id":824,"parentId":1,"tags":{},"startTime":1790237364006,"traceId":"80188c259035d77e"},{"name":"static-check","duration":3363686,"timestamp":272101465709,"id":827,"parentId":1,"tags":{},"startTime":1790237377953,"traceId":"80188c259035d77e"},{"name":"static-generation","duration":4133250,"timestamp":272105054082,"id":983,"parentId":1,"tags":{},"startTime":1790237381541,"traceId":"80188c259035d77e"},{"name":"collect-build-traces","duration":30667433,"timestamp":272104831548,"id":980,"parentId":1,"tags":{},"startTime":1790237381319,"traceId":"80188c259035d77e"},{"name":"telemetry-flush","duration":38,"timestamp":272135501894,"id":992,"parentId":1,"tags":{},"startTime":1790237411989,"traceId":"80188c259035d77e"},{"name":"next-build","duration":62752361,"timestamp":272072749578,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1790237349237,"traceId":"80188c259035d77e"}]

package/lib/board-types.ts

@@ -40,6 +40,12 @@ export interface RunningSnapshot {
    * 带 ?boardId=&cardIds=：返回这批可见卡的**全量**状态（含 failed/done/not_started），供画布徽章用。
    */
   taskCards: TaskCardRunningState[];
+  /**
+   * 会话列表代次（服务端任何影响列表的写入都自增）。
+   * 前端比对代次：变了就重拉列表——标题/首条消息/最后回复/外部新建会话不必等
+   * 下次本地动作或刷新页面。见 lib/session-list-signal.ts。
+   */
+  listGeneration: number;
 }
 
 /** 任务卡状态（running 快照透传的画布可见卡状态；DB 是唯一真相源，此为展示镜像） */

package/lib/rpc-manager.title.test.mjs

@@ -150,3 +150,131 @@ test("空名字仍然报错（既有校验不变），不碰 pi 也不碰库", a
   assert.deepEqual(nameCalls, []);
   assert.equal(rowOf(db, "sess-name").title, null);
 });
+
+/** 假 inner：prompt 提交的接受/拒绝由调用方控制（SDK 通过 preflightResult 同步 ack）。
+ *  `entries` 模拟 transcript 已有内容（判定「是不是真首条」靠它）。 */
+function makePromptWrapper(sessionId, { preflight = "accept", entries = [] } = {}) {
+  const inner = {
+    sessionId,
+    isBashRunning: false,
+    isStreaming: false,
+    isCompacting: false,
+    extensionRunner: {},
+    sessionManager: { getCwd: () => "/tmp", getEntries: () => entries },
+    agent: { state: {} },
+    subscribe() {
+      return () => {};
+    },
+    dispose() {},
+    prompt(_message, options) {
+      if (preflight === "reject") return Promise.reject(new Error("prompt rejected"));
+      options.preflightResult(true);
+      return Promise.resolve();
+    },
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  wrapper.start();
+  return wrapper;
+}
+
+test("首条用户消息在 prompt 被接受时即落库：标题不必等整轮跑完", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-title");
+  const wrapper = makePromptWrapper("sess-title");
+  t.after(() => wrapper.destroy());
+  const generationBefore = globalThis.__piSessionListGeneration ?? 0;
+
+  await wrapper.send({ type: "prompt", message: "  会话标题为什么不及时  " });
+
+  assert.equal(rowOf(db, "sess-title").first_message, "会话标题为什么不及时", "trim 后入库");
+  assert.ok(
+    (globalThis.__piSessionListGeneration ?? 0) > generationBefore,
+    "同一次写库推列表代次：正在看侧栏的客户端 ≤2.5s 内重拉，标题立刻可见",
+  );
+});
+
+test("首条用户消息截断到 300 字符（与扫描器同一上限）", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-title");
+  const wrapper = makePromptWrapper("sess-title");
+  t.after(() => wrapper.destroy());
+
+  await wrapper.send({ type: "prompt", message: "长".repeat(500) });
+
+  assert.equal(rowOf(db, "sess-title").first_message.length, 300);
+});
+
+test("prompt 没被接受（preflight 拒绝）：不写 first_message", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-title");
+  const wrapper = makePromptWrapper("sess-title", { preflight: "reject" });
+  t.after(() => wrapper.destroy());
+
+  await assert.rejects(() => wrapper.send({ type: "prompt", message: "会被拒绝的提交" }), /prompt rejected/);
+  assert.equal(rowOf(db, "sess-title").first_message, null);
+});
+
+test("prompt 分支接线：await preflight 之后才写 first_message（拒绝的提交不留标题）", async () => {
+  const source = await readFile(new URL("./rpc-manager.ts", import.meta.url), "utf8");
+  const caseSource = caseSourceOf(source, "prompt");
+
+  assert.match(caseSource, /await preflight;[\s\S]*?fillFirstMessageIfEmpty\(/);
+  assert.match(caseSource, /command\.message[\s\S]*?slice\(0, FIRST_MESSAGE_PREVIEW_LENGTH\)/);
+  assert.match(caseSource, /try \{[\s\S]*?fillFirstMessageIfEmpty\([\s\S]*?catch \(error\)/, "库写失败不得冒泡（否则路由把已接受的 prompt 报成 prompt_rejected）");
+});
+
+test("transcript 里已有用户消息（老会话）：prompt 不写 first_message（不把最新消息写成首条）", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-title");
+  // 模拟 CLI 建的老会话：transcript 有历史，但 first_message 还空着（扫描器拿不到）
+  const wrapper = makePromptWrapper("sess-title", {
+    entries: [{ type: "message", message: { role: "user", content: [{ type: "text", text: "历史里的真首条消息" }] } }],
+  });
+  t.after(() => wrapper.destroy());
+  const generationBefore = globalThis.__piSessionListGeneration ?? 0;
+
+  await wrapper.send({ type: "prompt", message: "这是这条会话里最新的一句" });
+
+  assert.equal(rowOf(db, "sess-title").first_message, null, "留给 agent_settled/扫描器按真首条回填");
+  assert.equal(globalThis.__piSessionListGeneration ?? 0, generationBefore, "没写库就不推代次");
+});
+
+test("空的 message（图片-only 等）：不写库、不推代次", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-title");
+  const wrapper = makePromptWrapper("sess-title");
+  t.after(() => wrapper.destroy());
+  const generationBefore = globalThis.__piSessionListGeneration ?? 0;
+
+  await wrapper.send({ type: "prompt", message: "   ", images: [] });
+
+  assert.equal(rowOf(db, "sess-title").first_message, null);
+  assert.equal(globalThis.__piSessionListGeneration ?? 0, generationBefore);
+});
+
+test("写库失败不拖累 send：命令照常成功响应（库是旁路索引）", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-title");
+  const wrapper = makePromptWrapper("sess-title");
+  const errors = [];
+  const original = console.error;
+  t.after(() => {
+    wrapper.destroy();
+    console.error = original;
+    globalThis.__piWebDb = db;
+  });
+  console.error = (...args) => errors.push(args.map(String).join(" "));
+  // 让库写入抛错：stub 掉全局库句柄（真库仍在 db 变量里，未被触碰）
+  globalThis.__piWebDb = {
+    prepare() {
+      throw new Error("database is locked");
+    },
+  };
+
+  const result = await wrapper.send({ type: "prompt", message: "阻塞的库也不能让 prompt 变失败" });
+
+  assert.equal(result, null, "send 正常返回：路由才会写 promptAccepted=true（否则客户端回填草稿、诱导重发）");
+  assert.equal(errors.length, 1, "写库失败必须可见");
+  assert.match(errors[0], /\[pi-web\] 首条消息写库失败/);
+  assert.match(errors[0], /database is locked/);
+});

package/lib/rpc-manager.ts

@@ -333,6 +333,8 @@ export class AgentSessionWrapper {
     }
     recordSessionOutcome(sessionId, effect);
     // 首条用户消息此刻已在内存 entries 里（不读文件，读取路径零扫盘）。
+    // 正常链路上它更早就写好了（prompt 一被接受就写，见 send 的 prompt 分支）；
+    // 这里兑底扩展/外部注入的首条用户消息（那一轮的起点不是 RPC prompt）。
     fillFirstMessageIfEmpty(sessionId, firstUserMessageOf(this.inner.sessionManager.getEntries()));
   }
 
@@ -613,6 +615,29 @@ export class AgentSessionWrapper {
           });
 
           await preflight;
+          // 首条用户消息：prompt 一被接受就落库，**不等整轮跑完**。标题/列表的默认
+          // 展示就是「用户发送的第一句话」（title || first_message），只在 agent_settled
+          // 写的话，长首轮（几分钟~几十分钟）期间刷新页面/换客户端/看板卡上标题一直空着
+          // （-> "(no messages)"）。也不能指望 agent_start：实测那一刻用户消息还没进
+          // 内存 entries（拿不到文本）。
+          // 只在「transcript 里还没有用户消息」时写（= 这才是真首条）：已有历史的会话
+          // （CLI 建的、first_message 还空着）走 agent_settled/扫描器按真实首条回填，
+          // prompt 路径写「这一条最新消息」会被 fill-empty 钉死成永久错值。
+          const promptText = typeof command.message === "string" ? command.message.trim() : "";
+          const sessionId = this.inner.sessionId;
+          if (promptText && sessionId && !firstUserMessageOf(this.inner.sessionManager.getEntries())) {
+            try {
+              fillFirstMessageIfEmpty(sessionId, promptText.slice(0, FIRST_MESSAGE_PREVIEW_LENGTH));
+            } catch (error) {
+              // 库写失败绝不能冒泡：send() 抛出会让路由把「已经接受的 prompt」报成
+              // prompt_rejected（客户端回填草稿、诱导重发，而 agent 其实在跑）。
+              // 这条写只是旁路索引，失败记账即可（同 persistSessionActivity 口径）。
+              console.error(
+                `[pi-web] 首条消息写库失败 session=${sessionId}:`,
+                error instanceof Error ? error.message : String(error),
+              );
+            }
+          }
           return null;
         } finally {
           releaseAdmission();

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

@@ -69,6 +69,31 @@ test("runSessionIndexScan：幂等（重复扫描不重复建行）", async () =
   }
 });
 
+test("runSessionIndexScan：列表代次只在本轮真变更时自增（有变更推一次，空轮不推）", async () => {
+  freshDb();
+  const { root, projDir } = makeRoot();
+  try {
+    const generation = () => globalThis.__piSessionListGeneration ?? 0;
+    const before = generation();
+
+    await runSessionIndexScan(root); // 磁盘空：无变更
+    assert.equal(generation(), before, "空轮不推代次（否则每 30s 白刷一次前端列表）");
+
+    writeFileSync(join(projDir, "2026-01-01T00-00-00-000Z_aaa.jsonl"), sessionFileLines("aaa", "/home/u/project/alpha"));
+    await runSessionIndexScan(root);
+    assert.equal(generation(), before + 1, "外部/CLI 新建的会话入索引 → 推一次（侧栏 ≤2.5s 就能看到它）");
+
+    const afterInsert = generation();
+    await runSessionIndexScan(root); // 再扫：幂等无变更
+    assert.equal(generation(), afterInsert, "幂等轮不推");
+
+    await indexSessionFileNow(join(projDir, "2026-01-01T00-00-00-000Z_aaa.jsonl"), null, null);
+    assert.equal(generation(), afterInsert + 1, "单文件立即索引 → 也推一次（fork/引用分支当场进列表）");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("runSessionIndexScan：mtime 变化刷 modified + 回填 first_message（文件是内容事实源）", async () => {
   freshDb();
   const { root, projDir } = makeRoot();

package/lib/session-index-scanner.ts

@@ -34,6 +34,7 @@ import { getDb } from "./sqlite-db";
 import { projectIdentityKey } from "./project-identity";
 import { sessionPathKey } from "./session-path";
 import { scanOneSessionHead, scanSessionFileMeta, readSessionTail, type SessionFileMeta } from "./session-scanner";
+import { markSessionListChanged } from "./session-list-signal";
 import { resolveProject } from "./worktree";
 
 /** 一轮扫描的变更摘要（日志/测试断言用）。 */
@@ -97,6 +98,8 @@ export async function indexSessionFileNow(
       head.created.getTime(),
       Date.now(),
     );
+  // 行已落库 → 列表可能变了（会话当场出现在列表/派生列被补上）。
+  markSessionListChanged();
 }
 
 /** 一轮全量扫描。`sessionsDir` 仅在测试注入（默认走 agentDir）。 */
@@ -319,6 +322,12 @@ export async function runSessionIndexScan(
     }
   }
 
+  // 本轮真改了什么 → 通知列表读者（外部/CLI 新建的会话、首条消息/最后回复回填、
+  // 删除都走这里；无变更不 mark，避免每 30s 空推一次前端重拉）。
+  if (summary.inserted > 0 || summary.updated > 0 || summary.deleted > 0) {
+    markSessionListChanged();
+  }
+
   return summary;
 }
 

package/lib/session-list-signal.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { interopDefault: true, moduleCache: false });
+const { markSessionListChanged, getSessionListGeneration } = await jiti.import("./session-list-signal.ts");
+
+const routeSource = await readFile(new URL("../app/api/agent/running/route.ts", import.meta.url), "utf8");
+const sidebarSource = await readFile(new URL("../components/SessionSidebar.tsx", import.meta.url), "utf8");
+const readerSource = await readFile(new URL("./session-reader.ts", import.meta.url), "utf8");
+const sessionsRouteSource = await readFile(new URL("../app/api/sessions/route.ts", import.meta.url), "utf8");
+
+test("mark 自增代次，get 读同一处（globalThis：热重载后仍是同一个计数器）", () => {
+  const before = getSessionListGeneration();
+  markSessionListChanged();
+  markSessionListChanged();
+  assert.equal(getSessionListGeneration(), before + 2);
+  assert.equal(globalThis.__piSessionListGeneration, before + 2);
+});
+
+test("接线：写路径 invalidateSessionListCache 委托 mark（改名/pin/新建/事件写库都算列表变更）", () => {
+  assert.match(
+    readerSource,
+    /export function invalidateSessionListCache\(\): void \{\n  markSessionListChanged\(\);/,
+  );
+  assert.match(readerSource, /from "\.\/session-list-signal"/);
+});
+
+test("接线：running 快照把代次带给前端（侧栏本来就在轮询它，不新增请求）", () => {
+  assert.match(routeSource, /listGeneration: getSessionListGeneration\(\)/);
+  assert.match(routeSource, /from "@\/lib\/session-list-signal"/);
+});
+
+test("接线：侧栏轮询见代次变化就全量刷新；首个快照只做种子（挂载时已拉过列表，不空刷）", () => {
+  assert.match(
+    sidebarSource,
+    /if \(shouldRefreshForListGeneration\(listGenerationRef\.current, generation\)\) \{\n\s+onRefreshRef\.current\?\.\(\);/,
+  );
+  // 列表响应把自己的代次记下来（不靠轮询的「首个快照」去猜）。
+  assert.match(sidebarSource, /if \(typeof data\.listGeneration === "number"\) listGenerationRef\.current = data\.listGeneration;/);
+});
+
+test("接线：/api/sessions 两份列表响应都带上自己的代次（作为「我的列表对应哪个代次」的种子）", () => {
+  assert.match(sessionsRouteSource, /sessions: \[\.\.\.persisted, \.\.\.extraRuntime\],[\s\S]*?listGeneration: getSessionListGeneration\(\),/);
+  assert.match(
+    sessionsRouteSource,
+    /\{ sessions, runningSessionIds: getRunningRpcSessionIds\(\), listGeneration: getSessionListGeneration\(\) \}/,
+  );
+});

package/lib/session-list-signal.ts

@@ -0,0 +1,32 @@
+// ============================================================================
+// 会话列表「已变更」信号
+//
+// 谁需要知道：列表不再有服务端缓存（每次读取 = 一次单表查询），但**前端**的列表
+// 只在挂载/项目切换/本地动作（新建、删除、改名、拖拽）时重拉——服务端写进去的
+// 新标题、首条消息、最后回复、外部（CLI）新建的会话，都要等下一次重拉才现身。
+//
+// 机制：任何影响列表读取的写路径都 mark 一次（自增计数器），`/api/agent/running`
+// 的轮询把它带给前端（侧栏本来就每 2.5s 拉一次），前端见变化就重拉列表。
+//
+// **进程内计数器**（与库同进程的写入才可见）：同时跑多个 pi-web 实例、共用一个
+// `pi-web.db` 时，A 进程的写不会推给 B 进程的侧栏——B 只能靠自己的 30s 扫描器按
+// 文件 mtime 收敛。跨进程唯一可靠的事实源是库本身（真要做就是库里的代次行）。
+//
+// 单独成文件只为打断循环依赖：`session-reader` 已经 import 扫描器（ensureSessionIndexReady），
+// 扫描器不能再反向 import `session-reader` 的 invalidateSessionListCache。globalThis
+// 存活热重载（模块级变量不会）。
+// ============================================================================
+
+declare global {
+  var __piSessionListGeneration: number | undefined;
+}
+
+/** 列表内容已变（标题/首条消息/最后回复/排序/新建/删除）。写路径调用，幂等无副作用。 */
+export function markSessionListChanged(): void {
+  globalThis.__piSessionListGeneration = (globalThis.__piSessionListGeneration ?? 0) + 1;
+}
+
+/** 当前代次：前端比对「我上次看到的」与「这次拿到的」，不等即重拉列表。 */
+export function getSessionListGeneration(): number {
+  return globalThis.__piSessionListGeneration ?? 0;
+}

package/lib/session-reader.ts

@@ -16,6 +16,7 @@ import { projectIdentityKey } from "./project-identity";
 import { sessionPathKey } from "./session-path";
 import { resolveProject, type ProjectInfo } from "./worktree";
 import { scanOneSessionFile } from "./session-scanner";
+import { markSessionListChanged } from "./session-list-signal";
 import { ensureSessionIndexReady } from "./session-index-scanner";
 import type { TurnIndexItem } from "./api-types";
 
@@ -264,17 +265,15 @@ export async function loadTaskSessionsPage(
 declare global {
   var __piSessionPathCache: Map<string, string> | undefined;
   var __piPathToSessionIdCache: Map<string, string> | undefined;
-  var __piSessionListGeneration: number | undefined;
 }
 
 /** 写路径的「数据变了」信号：归属/pin/改名/新建/删除/事件都会调它。
  *
- *  列表已无缓存（读取 = 每次一次单表查询），所以目前**没有生产读者**：这里只保留
- *  generation 自增的既有行为（T1–T4b 的写路径与 auto-name / patch-write-failure 的
- *  断言都依赖调用本身）。若要连函数一起删，需要同时改掉全部调用方与那两处断言——
- *  属待清理项，本次不动。 */
+ *  计数器本体在 `session-list-signal`（扫描器也要 mark，不能反向 import 本模块）；
+ *  读者是 `/api/agent/running` 的 `listGeneration` —— 侧栏 2.5s 轮询见代次变化就
+ *  重拉列表，标题/首条消息/最后回复/外部新建会话因此能在几秒内现身。 */
 export function invalidateSessionListCache(): void {
-  globalThis.__piSessionListGeneration = (globalThis.__piSessionListGeneration ?? 0) + 1;
+  markSessionListChanged();
 }
 
 function getPathCache(): Map<string, string> {

package/lib/task-store.ts

@@ -613,14 +613,16 @@ export function recordSessionOutcome(sessionId: string, outcome: { lastReply: st
   invalidateSessionListCache();
 }
 
-/** 首条用户消息回填（读取路径不再读文件，改由事件补齐；只补空行）。 */
+/** 首条用户消息回填（读取路径不再读文件，改由事件补齐；只补空行）。
+ *  只在真的改了行时推列表代次：这个函数在一条会话的一生里会被调多次（每次 prompt 一次），
+ *  无变化的空推会让前端白刷一轮会话/任务/看板。「空轮不推」与扫描器同一口径。 */
 export function fillFirstMessageIfEmpty(sessionId: string, firstMessage: string): void {
   const text = firstMessage.trim();
   if (!text) return;
-  getDb()
+  const result = getDb()
     .prepare(
       "UPDATE session_meta SET first_message = ? WHERE session_id = ? AND (first_message IS NULL OR first_message = '')",
     )
     .run(text, sessionId);
-  invalidateSessionListCache();
+  if (Number(result.changes) > 0) invalidateSessionListCache();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baique/pi-web-sky",
-  "version": "0.1.60",
+  "version": "0.1.61",
   "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": {