@baique/pi-web-sky 0.1.56 → 0.1.57

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":21788610,"timestamp":112598116018,"id":14,"parentId":1,"tags":{},"startTime":1789635999467,"traceId":"8ab6295b2022b209"},{"name":"run-typescript","duration":17416676,"timestamp":112619906570,"id":1026,"parentId":1,"tags":{},"startTime":1789636021257,"traceId":"8ab6295b2022b209"},{"name":"static-check","duration":4973335,"timestamp":112637338702,"id":1029,"parentId":1,"tags":{},"startTime":1789636038689,"traceId":"8ab6295b2022b209"},{"name":"static-generation","duration":5601140,"timestamp":112642593780,"id":1185,"parentId":1,"tags":{},"startTime":1789636043944,"traceId":"8ab6295b2022b209"},{"name":"collect-build-traces","duration":33050130,"timestamp":112642314747,"id":1182,"parentId":1,"tags":{},"startTime":1789636043665,"traceId":"8ab6295b2022b209"},{"name":"telemetry-flush","duration":48,"timestamp":112675367892,"id":1194,"parentId":1,"tags":{},"startTime":1789636076718,"traceId":"8ab6295b2022b209"},{"name":"next-build","duration":77526811,"timestamp":112597841136,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1789635999192,"traceId":"8ab6295b2022b209"}]
+[{"name":"run-webpack","duration":13746815,"timestamp":79464376514,"id":14,"parentId":1,"tags":{},"startTime":1789788276790,"traceId":"4f060d2e7ba61083"},{"name":"run-typescript","duration":11766992,"timestamp":79478124864,"id":877,"parentId":1,"tags":{},"startTime":1789788290539,"traceId":"4f060d2e7ba61083"},{"name":"static-check","duration":2683425,"timestamp":79489906025,"id":880,"parentId":1,"tags":{},"startTime":1789788302320,"traceId":"4f060d2e7ba61083"},{"name":"static-generation","duration":4026810,"timestamp":79492772500,"id":1036,"parentId":1,"tags":{},"startTime":1789788305186,"traceId":"4f060d2e7ba61083"},{"name":"collect-build-traces","duration":24886444,"timestamp":79492591686,"id":1033,"parentId":1,"tags":{},"startTime":1789788305005,"traceId":"4f060d2e7ba61083"},{"name":"telemetry-flush","duration":36,"timestamp":79517480961,"id":1045,"parentId":1,"tags":{},"startTime":1789788329894,"traceId":"4f060d2e7ba61083"},{"name":"next-build","duration":53289106,"timestamp":79464191897,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1789788276606,"traceId":"4f060d2e7ba61083"}]

package/lib/board-reconcile.test.mjs

@@ -1,17 +1,35 @@
-import { test, beforeEach, afterEach } from "node:test";
+import { test, beforeEach, afterEach, after } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { createJiti } from "jiti";
 
+// 隔离：归属写入现在会对「库里无行」的会话解析会话文件，临时 agentDir 保证
+// 测试绝不扫开发机真实的 ~/.pi/agent/sessions。
+const agentDir = mkdtempSync(join(tmpdir(), "pi-web-board-reconcile-"));
+process.env.PI_CODING_AGENT_DIR = agentDir;
+after(() => rmSync(agentDir, { recursive: true, force: true }));
+
 const jiti = createJiti(import.meta.url, { interopDefault: true, moduleCache: false });
 const { setDbForTesting, getDb } = await jiti.import("./sqlite-db.ts");
 const { createTask } = await jiti.import("./task-store.ts");
 const { getOrCreateTaskBoard } = await jiti.import("./board-store.ts");
 const { createCard, updateCard } = await jiti.import("./task-card-store.ts");
-const { assignSessionToTask } = await jiti.import("./task-store.ts");
 
 const PROJECT = "proj-reconcile";
 
+/** 库里已有该会话的行且已归属本任务（生产链路：行由创建链路/扫描器建、归属由
+ *  assignSessionToTask 写；reconcile 只消费「行 + 归属」，这里一次插齐）。 */
+function seedAssignedSession(sid, taskId) {
+  const ts = Date.now();
+  getDb().prepare(
+    "INSERT INTO session_meta (session_id, task_id, updated, pinned, path, cwd, project_key, created, modified) " +
+      "VALUES (?, ?, ?, 0, ?, ?, ?, ?, ?)",
+  ).run(sid, taskId, ts, `/sessions/proj/${sid}.jsonl`, "/proj", PROJECT, ts, ts);
+}
+
 // 注入 mutateBoard mock：捕获每次事务调用（读入当前 Y 状态，执行 transaction 后
 // 记录对 nodes/edges 的增删，模拟服务端权威写）。
 function installYjsMock() {
@@ -79,9 +97,9 @@ test("窗口期 reconcile 不补同 sid 占位卡（新建会话指定 ID 场景
   const board = getOrCreateTaskBoard(task.id, PROJECT, "任务A"); // board.id = task.id
   assert.ok(board.taskId);
 
-  // 服务端已落库（assignSessionToTask 在 /api/agent/new 中先于前端转正执行）
+  // 服务端已落库（行由创建链路建，归属在 /api/agent/new 中先于前端转正写入）
   const sid = "abc-123";
-  assignSessionToTask(sid, task.id);
+  seedAssignedSession(sid, task.id);
 
   // 画布已存在「新建中占位卡」：cwd 非空 + sessionId = 即将创建/刚创建的会话 UUID
   mockState.nodeSets.set("user-card-1", cardNode("user-card-1", sid, { cwd: "/proj", expanded: true }));
@@ -99,7 +117,7 @@ test("无占位卡时业务表会话正常补卡（回归，不误伤）", async
   const task = createTask(PROJECT, "任务B");
   const board = getOrCreateTaskBoard(task.id, PROJECT, "任务B");
   const sid = "reg-session-1";
-  assignSessionToTask(sid, task.id);
+  seedAssignedSession(sid, task.id);
 
   const { reconcileBoard } = await jiti.import("./board-reconcile.ts");
   await reconcileBoard(board.id);
@@ -119,11 +137,11 @@ test("占位卡不影响其他会话补卡（6461a61 语义保留）", async ()
 
   // 一个业务表真实会话 + 任务卡执行会话
   const realSid = "real-session";
-  assignSessionToTask(realSid, task.id);
+  seedAssignedSession(realSid, task.id);
   const execSid = "exec-session";
   const card = createCard({ boardId: board.id, projectKey: PROJECT, name: "子任务" });
   updateCard(card.id, { sessionId: execSid });
-  assignSessionToTask(execSid, task.id);
+  seedAssignedSession(execSid, task.id);
 
   const { reconcileBoard } = await jiti.import("./board-reconcile.ts");
   await reconcileBoard(board.id);
@@ -315,7 +333,7 @@ test("拖入任务看板的会话：无 session_meta 归属 → 判孤儿删；
 
   // 拖入的会话已写 session_meta（先归属后落卡）→ 存活；画布已有该卡 → 不补第二张
   const assignedSid = "drag-with-meta";
-  assignSessionToTask(assignedSid, task.id);
+  seedAssignedSession(assignedSid, task.id);
   mockState.nodeSets.set("drag-card2", cardNode("drag-card2", assignedSid, { taskId: task.id }));
   await reconcileBoard(board.id);
   assert.ok(mockState.nodeSets.has("drag-card2"), "有 session_meta 归属的拖入卡存活");

package/lib/board-reconcile.ts

@@ -175,7 +175,9 @@ export async function reconcileBoard(boardId: string, force = false): Promise<vo
   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 为空天然不参与。
+  // fork 会话建行时已继承源会话的 task_id（T1），这里仍按「源会话归属」定位，
+  // 是为了兼容存量行（扫描器收敛前的父在任务/子为空的脏行）与跨任务拖入的过渡态；
+  // 普通看板 board.taskId 为空天然不参与。
   const forkBySid = new Map<string, string>(); // forkSid -> parentSid
   if (isTaskBoard) {
     for (const { sessionId, parentId } of listTaskForkedSessions(board.taskId!)) {

package/lib/board-store.test.mjs

@@ -47,9 +47,9 @@ test("schema version reaches latest with board tables", () => {
     .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'boards'")
     .all();
   assert.equal(boards.length, 1);
-  assert.equal(SCHEMA_VERSION, 11);
+  assert.equal(SCHEMA_VERSION, 12); // v12: session_meta.last_reply
   const row = db.prepare("PRAGMA user_version").get();
-  assert.equal(row.user_version, 11);
+  assert.equal(row.user_version, SCHEMA_VERSION);
   // v5 迁移：boards.task_id 列存在
   const cols = db.prepare("PRAGMA table_info(boards)").all().map((c) => c.name);
   assert.ok(cols.includes("task_id"));

package/lib/ime-guard.test.mjs

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./ime-guard.ts");
+}
+
+test("plain key events are not IME-busy", async () => {
+  const { createIMECompositionState, isIMEBusy } = await loadSubject();
+  const state = createIMECompositionState();
+
+  assert.equal(isIMEBusy(state, { isComposing: false, keyCode: 13 }), false);
+  assert.equal(isIMEBusy(state, {}), false);
+  assert.equal(isIMEBusy(state, null), false);
+});
+
+test("composition session marks every keydown as IME-busy", async () => {
+  const { createIMECompositionState, markCompositionStart, markCompositionEnd, isIMEBusy } = await loadSubject();
+  const state = createIMECompositionState();
+
+  markCompositionStart(state);
+  assert.equal(state.composing, true);
+  // 组合期间即使事件没带信号（老输入法）也要让开
+  assert.equal(isIMEBusy(state, { isComposing: false, keyCode: 13 }), true);
+
+  markCompositionEnd(state, 1_000);
+  assert.equal(state.composing, false);
+});
+
+test("isComposing and keyCode 229 are both honoured outside a tracked session", async () => {
+  const { createIMECompositionState, isIMEBusy } = await loadSubject();
+  const state = createIMECompositionState();
+
+  assert.equal(isIMEBusy(state, { isComposing: true, keyCode: 13 }), true);
+  assert.equal(isIMEBusy(state, { keyCode: 229 }), true);
+});
+
+test("keys right after compositionend are IME-busy (Safari / Sogou ordering)", async () => {
+  const { createIMECompositionState, markCompositionStart, markCompositionEnd, isIMEBusy, IME_GRACE_MS } = await loadSubject();
+  const state = createIMECompositionState();
+
+  markCompositionStart(state);
+  // Safari 反序：compositionend 先到，随后那次 keydown 的 isComposing 已是 false
+  markCompositionEnd(state, 5_000);
+
+  assert.equal(isIMEBusy(state, { isComposing: false, keyCode: 13 }, 5_000), true);
+  assert.equal(isIMEBusy(state, { isComposing: false, keyCode: 13 }, 5_000 + IME_GRACE_MS - 1), true);
+
+  // 宽限窗外恢复正常
+  assert.equal(isIMEBusy(state, { isComposing: false, keyCode: 13 }, 5_000 + IME_GRACE_MS), false);
+  assert.equal(isIMEBusy(state, { isComposing: false, keyCode: 13 }, 5_000 + IME_GRACE_MS + 1), false);
+});

package/lib/ime-guard.ts

@@ -0,0 +1,54 @@
+/**
+ * 输入法（IME）组合态判定。
+ *
+ * Enter / Escape / 方向键等业务快捷键在处理前必须先过 `isIMEBusy()`，
+ * 否则中文/日文/韩文输入法「回车确认候选」「Esc 取消候选」会被当成业务提交或业务取消。
+ *
+ * 四个信号缺一不可（靠前的先短路）：
+ *  1. `composing` —— 由 compositionstart / compositionend 自己维护，最可靠；
+ *  2. `event.isComposing` —— 标准属性；
+ *  3. `event.keyCode === 229` —— 老 WebKit 与部分输入法不上报 isComposing；
+ *  4. `endedAt` 宽限窗 —— Safari（以及部分搜狗场景）先发 compositionend 再发 keydown，
+ *     那次 keydown 的 isComposing 已经是 false，只看属性必然误判成「用户主动按了 Enter」。
+ */
+
+/** compositionend 之后仍把按键让给输入法的宽限窗口（ms）。 */
+export const IME_GRACE_MS = 100;
+
+export type IMECompositionState = {
+  /** 是否处于组合中（compositionstart 之后、compositionend 之前） */
+  composing: boolean;
+  /** 最近一次 compositionend 的时间戳；0 = 从未组合过 */
+  endedAt: number;
+};
+
+export function createIMECompositionState(): IMECompositionState {
+  return { composing: false, endedAt: 0 };
+}
+
+export function markCompositionStart(state: IMECompositionState): void {
+  state.composing = true;
+}
+
+export function markCompositionEnd(state: IMECompositionState, now: number = Date.now()): void {
+  state.composing = false;
+  state.endedAt = now;
+}
+
+/** keydown 上取得到的 IME 信号（KeyboardEvent 的结构子集，方便测试）。 */
+export type IMEKeyEvent = {
+  isComposing?: boolean;
+  keyCode?: number;
+};
+
+/** 这次按键是否属于输入法：true → 业务逻辑让开，交给输入法上屏/取消候选。 */
+export function isIMEBusy(
+  state: IMECompositionState,
+  event: IMEKeyEvent | null | undefined,
+  now: number = Date.now(),
+): boolean {
+  if (state.composing) return true;
+  if (event?.isComposing === true) return true;
+  if (event?.keyCode === 229) return true;
+  return now - state.endedAt < IME_GRACE_MS;
+}

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

@@ -0,0 +1,223 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { DatabaseSync } from "node:sqlite";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+  alias: { "@": process.cwd() },
+});
+const { setDbForTesting } = await jiti.import("./sqlite-db.ts");
+const { AgentSessionWrapper } = await jiti.import("./rpc-manager.ts");
+
+/** 事件链路的行为测试：真 wrapper + 真库（:memory:）+ 假 SDK 会话。 */
+function freshDb() {
+  const db = new DatabaseSync(":memory:");
+  setDbForTesting(db);
+  return db;
+}
+
+function seedSession(db, sessionId) {
+  db.prepare(
+    `INSERT INTO session_meta
+       (session_id, task_id, updated, pinned, path, cwd, project_key, title, first_message, parent_id, created, modified, last_reply)
+     VALUES (?, NULL, 111, 0, ?, '/p', 'proj', NULL, NULL, NULL, 100, 200, NULL)`,
+  ).run(sessionId, `/s/${sessionId}.jsonl`);
+}
+
+const rowOf = (db, sessionId) =>
+  db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionId);
+
+const assistant = (text, ts, stopReason = "stop") => ({
+  type: "message_end",
+  message: { role: "assistant", timestamp: ts, stopReason, content: [{ type: "text", text }] },
+});
+
+/** 假 AgentSessionLike：只实现事件订阅 + wrapper 读到的几处。 */
+function makeWrapper(sessionId, entries = []) {
+  let emit = null;
+  const inner = {
+    sessionId,
+    isBashRunning: false,
+    isStreaming: false,
+    isCompacting: false,
+    extensionRunner: {},
+    sessionManager: { getCwd: () => "/tmp", getEntries: () => entries },
+    agent: { state: {} },
+    subscribe(listener) {
+      emit = listener;
+      return () => {
+        emit = null;
+      };
+    },
+    dispose() {},
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  wrapper.start();
+  return { wrapper, fire: (event) => emit(event) };
+}
+
+const userEntry = (text) => ({ type: "message", message: { role: "user", content: [{ type: "text", text }] } });
+
+test("agent_start → 刷 modified（活跃时间立刻前移），不碰 last_reply", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  const { wrapper, fire } = makeWrapper("sess-live");
+  t.after(() => wrapper.destroy());
+
+  const before = Date.now();
+  fire({ type: "agent_start" });
+
+  const row = rowOf(db, "sess-live");
+  assert.ok(row.modified >= before, "agent_start 立刻把活跃时间前移到当前");
+  assert.equal(row.last_reply, null);
+  assert.equal(row.updated, 111);
+  assert.ok(wrapper.lastAgentStartAt() >= before, "既有 agent_start 逻辑（缓存起始时间）保持原样");
+});
+
+test("一轮循环结束：message_end 缓存、agent_settled 落 last_reply + modified", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  const { wrapper, fire } = makeWrapper("sess-live");
+  t.after(() => wrapper.destroy());
+
+  fire({ type: "agent_start" });
+  fire(assistant("中间回复", 1000));
+  assert.equal(rowOf(db, "sess-live").last_reply, null, "单条 message_end 不落库（不是循环最后一条）");
+  fire(assistant("最后一条回复", 2000));
+  fire({ type: "agent_settled" });
+
+  const row = rowOf(db, "sess-live");
+  assert.equal(row.last_reply, "最后一条回复");
+  assert.equal(row.modified, 2000);
+});
+
+test("用户取消（stopReason=aborted）走同一条路径落库", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  const { wrapper, fire } = makeWrapper("sess-live");
+  t.after(() => wrapper.destroy());
+
+  fire(assistant("被打断的半截回复", 3000, "aborted"));
+  fire({ type: "agent_settled" });
+
+  assert.equal(rowOf(db, "sess-live").last_reply, "被打断的半截回复");
+});
+
+test("本轮没采到文本 → 保留库里的 last_reply，只刷 modified", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  db.prepare("UPDATE session_meta SET last_reply = '上一条回复' WHERE session_id = 'sess-live'").run();
+  const { wrapper, fire } = makeWrapper("sess-live");
+  t.after(() => wrapper.destroy());
+
+  fire({ type: "agent_start" });
+  fire({ type: "agent_settled" });
+
+  const row = rowOf(db, "sess-live");
+  assert.equal(row.last_reply, "上一条回复", "空文本不清库");
+  assert.ok(row.modified > 200);
+});
+
+test("首条用户消息在落库时回填（内存 entries，不读文件），只补一次", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  const entries = [userEntry("帮我写一个 e2e 测试"), { type: "message", message: { role: "assistant", content: [] } }];
+  const { wrapper, fire } = makeWrapper("sess-live", entries);
+  t.after(() => wrapper.destroy());
+
+  fire(assistant("好的", 1000));
+  fire({ type: "agent_settled" });
+  assert.equal(rowOf(db, "sess-live").first_message, "帮我写一个 e2e 测试");
+
+  entries[0] = userEntry("换了个说法");
+  fire(assistant("第二次回复", 2000));
+  fire({ type: "agent_settled" });
+  assert.equal(rowOf(db, "sess-live").first_message, "帮我写一个 e2e 测试", "首条消息不被后续覆盖");
+});
+
+test("首条用户消息截断到 300 字符（与扫描器同一上限）", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  const long = "长".repeat(500);
+  const { wrapper, fire } = makeWrapper("sess-live", [userEntry(long)]);
+  t.after(() => wrapper.destroy());
+
+  fire(assistant("回复", 1000));
+  fire({ type: "agent_settled" });
+
+  assert.equal(rowOf(db, "sess-live").first_message.length, 300);
+});
+
+test("并发会话各自记账，事件不串台", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-a");
+  seedSession(db, "sess-b");
+  const a = makeWrapper("sess-a");
+  const b = makeWrapper("sess-b");
+  t.after(() => {
+    a.wrapper.destroy();
+    b.wrapper.destroy();
+  });
+
+  a.fire(assistant("A 的回复", 1000));
+  b.fire(assistant("B 的回复", 2000));
+  b.fire({ type: "agent_settled" });
+  a.fire({ type: "agent_settled" });
+
+  assert.deepEqual(
+    [rowOf(db, "sess-a").last_reply, rowOf(db, "sess-b").last_reply],
+    ["A 的回复", "B 的回复"],
+  );
+});
+
+test("库里没有行时事件写库静默 no-op，且不影响既有事件流", (t) => {
+  const db = freshDb();
+  const { wrapper, fire } = makeWrapper("sess-unknown");
+  t.after(() => wrapper.destroy());
+  const events = [];
+  wrapper.onEvent((event) => events.push(event.type));
+
+  fire({ type: "agent_start" });
+  fire(assistant("回复", 1000));
+  fire({ type: "agent_settled" });
+
+  assert.equal(db.prepare("SELECT COUNT(*) AS c FROM session_meta").get().c, 0, "事件不建行");
+  assert.deepEqual(events, ["agent_start", "message_end", "agent_settled"]);
+});
+
+test("写库失败必须可见且不打断既有事件流", (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-live");
+  const { wrapper, fire } = makeWrapper("sess-live");
+  t.after(() => {
+    wrapper.destroy();
+    setDbForTesting(db);
+  });
+  const errors = [];
+  const original = console.error;
+  console.error = (...args) => errors.push(args.map(String).join(" "));
+  t.after(() => {
+    console.error = original;
+  });
+  const events = [];
+  wrapper.onEvent((event) => events.push(event.type));
+
+  // 让库写入抛错：stub 掉全局库句柄（真库仍在 db 变量里，未被触碰）
+  globalThis.__piWebDb = {
+    prepare() {
+      throw new Error("database is locked");
+    },
+  };
+
+  fire({ type: "agent_start" });
+  fire(assistant("回复", 1000));
+  fire({ type: "agent_settled" });
+
+  assert.equal(errors.length, 2, "agent_start / agent_settled 各报一次写库失败");
+  assert.match(errors.join("\n"), /会话活跃写库失败/);
+  assert.match(errors.join("\n"), /database is locked/);
+  assert.deepEqual(events, ["agent_start", "message_end", "agent_settled"], "写库失败不打断事件流");
+  assert.ok(wrapper.lastAgentStartAt() > 0, "既有回调逻辑（agent_start 缓存）不受影响");
+});

package/lib/rpc-manager.test.mjs

@@ -137,3 +137,25 @@ test("reloading a session invalidates the models cache", async () => {
   assert.match(reloadSource, /await this\.inner\.reload\(\)/);
   assert.match(reloadSource, /this\.applyForcedEmptySystemPrompt\(\);\s*invalidateModelsCache\(\)/);
 });
+
+test("fork 建行失败不再静默（可见报错，不依赖扫描器兜底）", async () => {
+  const source = await readFile(new URL("./rpc-manager.ts", import.meta.url), "utf8");
+  const forkSource = source.slice(source.indexOf('case "fork"'), source.indexOf('case "navigate_tree"'));
+
+  assert.match(forkSource, /console\.error\(\s*`\[pi-web\] fork 建行失败 session=\$\{newSessionId\}/);
+  // 入板失败单独一条日志：不能被误报成「建行失败」。
+  assert.match(forkSource, /console\.error\(\s*`\[pi-web\] fork 入板失败 source=\$\{sourceSessionId\}/);
+  // 静默 catch 会让子会话以「无归属临时会话」出现在聊天区（V1 病灶）：fork 分支里不得再有裸 catch。
+  assert.doesNotMatch(forkSource, /catch \{/);
+});
+
+test("新会话建行失败也不再静默（失败可见，不依赖扫描器兜底）", async () => {
+  const source = await readFile(new URL("./rpc-manager.ts", import.meta.url), "utf8");
+  const persistSource = source.slice(
+    source.indexOf("async function persistNewSessionFile"),
+    source.indexOf("export function getRpcSession"),
+  );
+
+  assert.match(persistSource, /console\.error\(\s*`\[pi-web\] 新会话建行失败 session=\$\{sessionId\}/);
+  assert.doesNotMatch(persistSource, /catch \{/);
+});

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

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { DatabaseSync } from "node:sqlite";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+  alias: { "@": process.cwd() },
+});
+const { setDbForTesting } = await jiti.import("./sqlite-db.ts");
+const { AgentSessionWrapper } = await jiti.import("./rpc-manager.ts");
+
+/** set_session_name 命令（前端改名/看板卡改名）必须与路由层同语义落库：
+ *  pi 侧成功 → 同一次 send 内写 session_meta.title → 缓存失效；
+ *  写库失败 console.error 可见，但不抛断命令响应（RPC 已改文件名，抛错无可恢复动作）。
+ *  真 wrapper + 真库（:memory:）+ 假 SDK 会话（参照 rpc-manager.activity.test.mjs）。 */
+
+function freshDb() {
+  const db = new DatabaseSync(":memory:");
+  setDbForTesting(db);
+  return db;
+}
+
+/** 全列行（title 为 NULL：模拟还没改过名的老会话）。 */
+function seedSession(db, sessionId) {
+  db.prepare(
+    `INSERT INTO session_meta
+       (session_id, task_id, updated, pinned, path, cwd, project_key, title, first_message, parent_id, created, modified, last_reply)
+     VALUES (?, NULL, 111, 0, ?, '/p', 'proj', NULL, NULL, NULL, 100, 200, NULL)`,
+  ).run(sessionId, `/s/${sessionId}.jsonl`);
+}
+
+const rowOf = (db, sessionId) =>
+  db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionId);
+
+/** 取 `case "<name>"` 到下一个 case 之间的源码片段。
+ *  右边界用「下一个 case」的形状（不依赖某个具体 case 名存在）——别人把
+ *  get_session_stats 改名/删除也不会让切片静默退化成整文件；找不到边界直接报错。 */
+function caseSourceOf(source, name) {
+  const marker = `case "${name}"`;
+  const start = source.indexOf(marker);
+  assert.ok(start >= 0, `找不到 ${marker}`);
+  const rest = source.slice(start + marker.length);
+  const next = rest.slice(1).search(/\n      case "/);
+  assert.ok(next >= 0, `${marker} 之后找不到下一个 case（切片无法闭合）`);
+  return rest.slice(0, next + 1);
+}
+
+/** 假 AgentSessionLike：只实现 wrapper 用到的几处 + 记录 pi 侧改名调用。 */
+function makeWrapper(sessionId) {
+  const nameCalls = [];
+  const inner = {
+    sessionId,
+    isBashRunning: false,
+    isStreaming: false,
+    isCompacting: false,
+    extensionRunner: {},
+    sessionManager: { getCwd: () => "/tmp", getEntries: () => [] },
+    agent: { state: {} },
+    setSessionName(name) {
+      nameCalls.push(name);
+    },
+    subscribe() {
+      return () => {};
+    },
+    dispose() {},
+  };
+  const wrapper = new AgentSessionWrapper(inner);
+  wrapper.start();
+  return { wrapper, nameCalls };
+}
+
+/** 源码断言：命令分支确实接了库写，且失败处理形状正确。 */
+test("set_session_name 分支接线：pi 成功 → await setSessionTitle → 失败只记日志不抛", async () => {
+  const source = await readFile(new URL("./rpc-manager.ts", import.meta.url), "utf8");
+  const caseSource = caseSourceOf(source, "set_session_name");
+
+  assert.match(source, /import \{[^}]*\bsetSessionTitle\b[^}]*\} from "\.\/task-store";/s);
+  assert.ok(caseSource.includes("await setSessionTitle("), "库写必须 await（命令响应返回时库已落地）");
+  assert.match(caseSource, /setSessionTitle\(this\.inner\.sessionId, name\)/);
+  assert.ok(
+    caseSource.indexOf("this.inner.setSessionName(name)") < caseSource.indexOf("await setSessionTitle("),
+    "先 pi 侧改名成功、再写库（pi 失败时不该写库）",
+  );
+  assert.match(caseSource, /catch \(error\) \{[\s\S]*?console\.error\([\s\S]*?会话标题写库失败/);
+  assert.doesNotMatch(caseSource, /catch[\s\S]{0,400}?\bthrow\b/, "写库失败不得抛断命令响应/事件流");
+  assert.match(caseSource, /invalidateSessionListCache\(\);/);
+  assert.match(caseSource, /return null;/);
+});
+
+test("改名成功：同一次 send 内把 title 写库（不依赖扫描器/懒更新）", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-name");
+  const { wrapper, nameCalls } = makeWrapper("sess-name");
+  t.after(() => wrapper.destroy());
+
+  const before = Date.now();
+  const result = await wrapper.send({ type: "set_session_name", name: "  新标题  " });
+
+  assert.deepEqual(nameCalls, ["新标题"], "pi 侧收到 trim 后的名字（校验行为不变）");
+  assert.equal(result, null, "返回值保持原样");
+  const row = rowOf(db, "sess-name");
+  assert.equal(row.title, "新标题", "刷新侧栏/看板卡不再退回旧标题");
+  assert.ok(row.updated >= before, "写库顺带前移 updated");
+  assert.equal(row.task_id, null, "改名不碰归属");
+  assert.equal(row.path, "/s/sess-name.jsonl", "改名不碰索引列（只 UPDATE title/updated）");
+});
+
+test("写库失败：console.error 可见、不抛（命令响应与事件流都不被打断）", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-name");
+  const { wrapper, nameCalls } = makeWrapper("sess-name");
+  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: "set_session_name", name: "新标题" });
+
+  assert.equal(result, null, "RPC 命令照常返回成功响应（与路由层 500 语义不同：这里无可恢复动作）");
+  assert.deepEqual(nameCalls, ["新标题"], "pi 侧改名已生效");
+  assert.equal(errors.length, 1, "写库失败必须可见");
+  assert.match(errors[0], /\[pi-web\] 会话标题写库失败/);
+  assert.match(errors[0], /database is locked/);
+});
+
+test("空名字仍然报错（既有校验不变），不碰 pi 也不碰库", async (t) => {
+  const db = freshDb();
+  seedSession(db, "sess-name");
+  const { wrapper, nameCalls } = makeWrapper("sess-name");
+  t.after(() => wrapper.destroy());
+
+  await assert.rejects(
+    () => wrapper.send({ type: "set_session_name", name: "   " }),
+    /Session name cannot be empty/,
+  );
+  assert.deepEqual(nameCalls, []);
+  assert.equal(rowOf(db, "sess-name").title, null);
+});