@baique/pi-web-sky 0.1.55 → 0.1.57

package/lib/pin-store.ts

@@ -0,0 +1,85 @@
+"use client";
+
+import { useSyncExternalStore } from "react";
+
+export interface PinnedMessageItem {
+  id: string;
+  /** 快照内容（markdown 文本）——钉卡只渲染内容，与消息气泡/会话解耦 */
+  content: string;
+  x: number;
+  y: number;
+  w: number;
+  /** 高度：undefined = 初始随内容自适应；缩放/resize 后变为固定值 */
+  h?: number;
+}
+
+type Listener = () => void;
+
+/**
+ * 全局钉 store：pins 存活在模块级（与任何会话组件无关）。
+ * 跨会话/看板切换保留；刷新页面不持久化（内存态，符合设计）。
+ */
+let pins: PinnedMessageItem[] = [];
+const listeners = new Set<Listener>();
+
+function emit() {
+  for (const l of listeners) l();
+}
+
+function subscribe(listener: Listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function getSnapshot() {
+  return pins;
+}
+
+let pinCount = 0;
+
+/** 钉住内容：卡片出现在鼠标下方，多张级联偏移，clamp 视口内 */
+export function pin(content: string, clientX: number, clientY: number) {
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  const w = Math.min(340, Math.max(240, vw - 40));
+  const offset = (pinCount % 8) * 22;
+  pinCount += 1;
+  const item: PinnedMessageItem = {
+    id: `pin-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+    content,
+    x: Math.min(Math.max(0, clientX + offset), Math.max(0, vw - w - 4)),
+    y: Math.min(Math.max(0, clientY + 14 + offset), Math.max(0, vh - 48)),
+    w,
+  };
+  pins = [...pins, item];
+  emit();
+}
+
+export function closePin(id: string) {
+  pins = pins.filter((p) => p.id !== id);
+  emit();
+}
+
+export function movePin(id: string, patch: Partial<Pick<PinnedMessageItem, "x" | "y" | "w" | "h">>) {
+  pins = pins.map((p) => (p.id === id ? { ...p, ...patch } : p));
+  emit();
+}
+
+/** 激活置顶：把卡片移到数组末尾（zIndex 最高） */
+export function activatePin(id: string) {
+  if (pins.length <= 1) return;
+  const idx = pins.findIndex((p) => p.id === id);
+  if (idx === -1 || idx === pins.length - 1) return;
+  const next = [...pins];
+  const [item] = next.splice(idx, 1);
+  next.push(item);
+  pins = next;
+  emit();
+}
+
+/** 订阅 pins 快照（组件用） */
+export function usePins(): PinnedMessageItem[] {
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}

package/lib/powershell-settings.ts

@@ -0,0 +1,106 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import lockfile from "proper-lockfile";
+
+const DEFAULT_TOOLS = ["read", "bash", "edit", "write"];
+const SHELL_TOOLS = new Set(["bash", "powershell"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isPowerShellToolEnabled(
+  defaultTools: readonly string[] | undefined,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  return platform === "win32"
+    && defaultTools?.includes("powershell") === true
+    && !defaultTools.includes("bash");
+}
+
+export function replaceShellTool(
+  toolNames: readonly string[],
+  usePowerShell: boolean,
+): string[] {
+  const shell = usePowerShell ? "powershell" : "bash";
+  const result: string[] = [];
+  for (const name of toolNames) {
+    const next = SHELL_TOOLS.has(name) ? shell : name;
+    if (!result.includes(next)) result.push(next);
+  }
+  return result;
+}
+
+export function resolveShellTools(
+  toolNames: readonly string[],
+  defaultTools: readonly string[] | undefined,
+  platform: NodeJS.Platform = process.platform,
+): string[] {
+  return replaceShellTool(toolNames, isPowerShellToolEnabled(defaultTools, platform));
+}
+
+export function getPowerShellSettingsPath(agentDir = getAgentDir()): string {
+  return join(agentDir, "settings.json");
+}
+
+function parseSettings(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+  if (!isRecord(parsed)) throw new Error("Invalid settings.json: expected an object");
+  return parsed;
+}
+
+function configuredTools(settings: Record<string, unknown>): string[] | undefined {
+  if (settings.defaultTools === undefined) return undefined;
+  if (
+    !Array.isArray(settings.defaultTools)
+    || settings.defaultTools.some((name) => typeof name !== "string")
+  ) {
+    throw new Error("Invalid settings.json: defaultTools must be an array of strings");
+  }
+  return settings.defaultTools as string[];
+}
+
+export async function readPowerShellToolEnabled(
+  settingsPath = getPowerShellSettingsPath(),
+  platform: NodeJS.Platform = process.platform,
+): Promise<boolean> {
+  if (!existsSync(settingsPath)) return false;
+  const release = await lockfile.lock(settingsPath, { realpath: false, retries: 10 });
+  try {
+    return isPowerShellToolEnabled(configuredTools(parseSettings(settingsPath)), platform);
+  } finally {
+    await release();
+  }
+}
+
+export async function writePowerShellToolEnabled(
+  enabled: boolean,
+  settingsPath = getPowerShellSettingsPath(),
+  platform: NodeJS.Platform = process.platform,
+): Promise<boolean> {
+  if (platform !== "win32") throw new Error("PowerShell tool settings are only available on Windows");
+
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  try {
+    writeFileSync(settingsPath, "{}", { flag: "wx", mode: 0o600 });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+  }
+  const release = await lockfile.lock(settingsPath, { realpath: false, retries: 10 });
+  try {
+    const settings = parseSettings(settingsPath);
+    const currentTools = configuredTools(settings) ?? DEFAULT_TOOLS;
+    const nextTools = replaceShellTool(currentTools, enabled);
+    if (!currentTools.some((name) => SHELL_TOOLS.has(name))) {
+      nextTools.push(enabled ? "powershell" : "bash");
+    }
+    settings.defaultTools = nextTools;
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    chmodSync(settingsPath, 0o600);
+  } finally {
+    await release();
+  }
+  return enabled;
+}

package/lib/quoted-selection.ts

@@ -0,0 +1,4 @@
+export function buildQuotedSelection(text: string, intro: string, question: string): string {
+  const quote = text.trim().split("\n").map((line) => `> ${line}`).join("\n");
+  return `${intro}\n\n${quote}\n\n${question}`;
+}

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);
+});