@baique/pi-web-sky 0.1.55 → 0.1.57

package/lib/task-store.activity.test.mjs

@@ -0,0 +1,141 @@
+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 {
+  LAST_REPLY_MAX,
+  fillFirstMessageIfEmpty,
+  recordSessionOutcome,
+  touchSessionActivity,
+} = await jiti.import("./task-store.ts");
+
+function freshDb() {
+  const db = new DatabaseSync(":memory:");
+  setDbForTesting(db);
+  return db;
+}
+
+/** 造一条「扫描器/创建链路建立」的完整行：写函数只允许改自己那一列。 */
+function seedRow(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, 100, 200, NULL)`,
+  ).run(sessionId, `/s/${sessionId}.jsonl`);
+}
+
+const rowOf = (db, sessionId) =>
+  db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionId);
+const count = (db) => db.prepare("SELECT COUNT(*) AS c FROM session_meta").get().c;
+
+test("touchSessionActivity 只刷 modified，不建行（无行时静默 no-op）", () => {
+  const db = freshDb();
+  seedRow(db, "s1");
+
+  touchSessionActivity("s1", 5000);
+
+  const row = rowOf(db, "s1");
+  assert.equal(row.modified, 5000);
+  // 其它列一律不动：活跃时间不是归属、不是上次改写时间、也不是内容。
+  assert.equal(row.updated, 111);
+  assert.equal(row.last_reply, null);
+  assert.equal(row.first_message, null);
+  assert.equal(row.path, "/s/s1.jsonl");
+  assert.equal(row.pinned, 0);
+
+  // 缺省参数 = 当前时间（事件链路不需要自己算时间戳）
+  const before = Date.now();
+  touchSessionActivity("s1");
+  assert.ok(rowOf(db, "s1").modified >= before);
+
+  // 库里没有这条会话 → 只影响 0 行，绝不因事件建局部行（V4 缺陷的回归锁）
+  touchSessionActivity("no-such-session", 9999);
+  assert.equal(count(db), 1);
+});
+
+test("recordSessionOutcome 写 last_reply + modified，超 4000 字符截断", () => {
+  const db = freshDb();
+  seedRow(db, "s2");
+
+  recordSessionOutcome("s2", { lastReply: "最后一条回复", at: 7000 });
+
+  let row = rowOf(db, "s2");
+  assert.equal(row.last_reply, "最后一条回复");
+  assert.equal(row.modified, 7000);
+  assert.equal(row.updated, 111, "结果落库不当作一次归属改写");
+
+  const long = "x".repeat(LAST_REPLY_MAX + 100);
+  recordSessionOutcome("s2", { lastReply: long, at: 8000 });
+  row = rowOf(db, "s2");
+  assert.equal(row.last_reply.length, LAST_REPLY_MAX);
+  assert.equal(row.last_reply, long.slice(0, LAST_REPLY_MAX));
+  assert.equal(row.modified, 8000);
+});
+
+test("recordSessionOutcome 空文本不清库：只刷 modified，保留上一条回复", () => {
+  const db = freshDb();
+  seedRow(db, "s3");
+  recordSessionOutcome("s3", { lastReply: "上一条回复", at: 1000 });
+
+  // 刚发出就被取消 / 整轮只有工具调用：不许把 last_reply 写成空串
+  recordSessionOutcome("s3", { lastReply: "", at: 9000 });
+  let row = rowOf(db, "s3");
+  assert.equal(row.last_reply, "上一条回复");
+  assert.equal(row.modified, 9000);
+
+  recordSessionOutcome("s3", { lastReply: "   \n\t ", at: 9500 });
+  row = rowOf(db, "s3");
+  assert.equal(row.last_reply, "上一条回复", "纯空白同样不算一条消息");
+
+  // 从没存过回复的行：空文本保持 NULL（而不是被写成 "")
+  seedRow(db, "s3b");
+  recordSessionOutcome("s3b", { lastReply: "", at: 9600 });
+  assert.equal(rowOf(db, "s3b").last_reply, null);
+
+  // 无行 → 0 行，不建行
+  recordSessionOutcome("no-such-session", { lastReply: "x", at: 1 });
+  assert.equal(count(db), 2);
+});
+
+test("fillFirstMessageIfEmpty 只在为空时写入（已有 first_message 不被覆盖）", () => {
+  const db = freshDb();
+  seedRow(db, "s4");
+
+  fillFirstMessageIfEmpty("s4", "第一条用户消息");
+  assert.equal(rowOf(db, "s4").first_message, "第一条用户消息");
+
+  fillFirstMessageIfEmpty("s4", "后来的消息");
+  assert.equal(rowOf(db, "s4").first_message, "第一条用户消息", "首条消息只落一次");
+  assert.equal(rowOf(db, "s4").modified, 200, "回填首条消息不动活跃时间");
+
+  // '' 视为空（老行可能被写成空串）→ 允许回填
+  db.prepare("UPDATE session_meta SET first_message = '' WHERE session_id = 's4'").run();
+  fillFirstMessageIfEmpty("s4", "补上");
+  assert.equal(rowOf(db, "s4").first_message, "补上");
+
+  // 空白首条消息不写（避免把空串当成内容）
+  seedRow(db, "s5");
+  fillFirstMessageIfEmpty("s5", "  ");
+  assert.equal(rowOf(db, "s5").first_message, null);
+
+  // 无行 → 0 行，不建行
+  fillFirstMessageIfEmpty("no-such-session", "x");
+  assert.equal(count(db), 2);
+});
+
+test("三个写函数一律只 UPDATE：库里没行时不留任何新行", () => {
+  const db = freshDb();
+
+  touchSessionActivity("ghost", 1);
+  recordSessionOutcome("ghost", { lastReply: "回复", at: 2 });
+  fillFirstMessageIfEmpty("ghost", "首条");
+
+  assert.equal(count(db), 0);
+});

package/lib/task-store.meta-row.test.mjs

@@ -1,8 +1,18 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
 import { DatabaseSync } from "node:sqlite";
 import { createJiti } from "jiti";
 
+// getAgentDir() 每次调用都读环境变量 → 指向临时树，测试绝不碰 ~/.pi/agent。
+// sessions 子目录先建好：无行会话补行时会按 id 在这里找文件，miss 不回落扫开发机真实目录。
+const agentDir = mkdtempSync(join(tmpdir(), "pi-web-meta-row-"));
+mkdirSync(join(agentDir, "sessions"), { recursive: true });
+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 { getDb, setDbForTesting } = await jiti.import("./sqlite-db.ts");
 const { ensureSessionMetaRow, assignSessionToTask, setSessionTitle, unassignSession, createTask } = await jiti.import("./task-store.ts");
@@ -34,7 +44,7 @@ test("ensureSessionMetaRow 建全列索引行（新建会话落盘即建行）",
   assert.ok(row.modified > 0);
 });
 
-test("ensureSessionMetaRow 后 assignSessionToTask 只补归属、不破坏索引列", () => {
+test("ensureSessionMetaRow 后 assignSessionToTask 只补归属、不破坏索引列", async () => {
   const db = freshDb();
   ensureSessionMetaRow("sess-2", {
     path: "/p2/sessions/sess-2.jsonl",
@@ -42,27 +52,37 @@ test("ensureSessionMetaRow 后 assignSessionToTask 只补归属、不破坏索
     projectKey: "p2",
   });
   const task = createTask("p2", "t");
-  assert.equal(assignSessionToTask("sess-2", task.id), true);
+  assert.equal(await assignSessionToTask("sess-2", task.id), true);
   const row = db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get("sess-2");
   assert.equal(row.task_id, task.id);
   assert.equal(row.path, "/p2/sessions/sess-2.jsonl");
   assert.equal(row.project_key, "p2");
 });
 
-test("ensureSessionMetaRow 后 setSessionTitle 只补标题、不破坏索引列", () => {
+test("ensureSessionMetaRow 后 setSessionTitle 只补标题、不破坏索引列", async () => {
   const db = freshDb();
   ensureSessionMetaRow("sess-3", {
     path: "/p3/sessions/sess-3.jsonl",
     cwd: "/p3",
     projectKey: "p3",
   });
-  setSessionTitle("sess-3", "新标题");
+  await setSessionTitle("sess-3", "新标题");
   const row = db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get("sess-3");
   assert.equal(row.title, "新标题");
   assert.equal(row.path, "/p3/sessions/sess-3.jsonl");
   assert.equal(row.project_key, "p3");
 });
 
+test("ensureSessionMetaRow 写全 13 列（last_reply 显式 NULL，不依赖建表默认值）", () => {
+  const db = freshDb();
+  ensureSessionMetaRow("sess-13", { path: "/p13/x.jsonl", cwd: "/p13", projectKey: "p13" });
+  const columns = db.prepare("PRAGMA table_info(session_meta)").all();
+  assert.equal(columns.length, 13, "session_meta 契约是 13 列（v12）");
+  const row = db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get("sess-13");
+  assert.equal(Object.keys(row).length, 13, "行值对象覆盖全部列");
+  assert.equal(row.last_reply, null);
+});
+
 test("unassignSession 删行后 ensureSessionMetaRow 可重建（幂等）", () => {
   const db = freshDb();
   ensureSessionMetaRow("sess-4", { path: "/p4/x.jsonl", cwd: "/p4", projectKey: "p4" });

package/lib/task-store.partial-row.test.mjs

@@ -0,0 +1,198 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
+import { DatabaseSync } from "node:sqlite";
+import { createJiti } from "jiti";
+
+// getAgentDir() 每次调用都读环境变量 → 指向临时树，测试绝不碰 ~/.pi/agent。
+const agentDir = mkdtempSync(join(tmpdir(), "pi-web-partial-row-"));
+const sessionsDir = join(agentDir, "sessions");
+mkdirSync(sessionsDir, { recursive: true });
+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 { getDb, setDbForTesting } = await jiti.import("./sqlite-db.ts");
+const store = await jiti.import("./task-store.ts");
+
+/** 造一个真实会话文件：文件名带 id（按名可解析）、header.id 与之一致（header 权威）。
+ *  parentPath 非空时写 header.parentSession（父链只在磁盘上时用）。 */
+function writeSession(project, id, parentPath) {
+  const dir = join(sessionsDir, project);
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, `2026-09-18T00-00-00_${id}.jsonl`);
+  writeFileSync(
+    file,
+    `${JSON.stringify({ type: "session", id, timestamp: "2026-09-18T00:00:00.000Z", cwd: join("/w", project), ...(parentPath ? { parentSession: parentPath } : {}) })}\n`,
+  );
+  return file;
+}
+
+function freshDb() {
+  const db = new DatabaseSync(":memory:");
+  setDbForTesting(db);
+  return db;
+}
+
+function rowFor(sessionId) {
+  return getDb().prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionId);
+}
+
+/** 全列断言：缺 path/project_key/created 的局部行会在聊天区被 project_key 过滤掉、
+ *  在任务区显示 1970 —— 正是本任务要根除的形态。 */
+function assertFullRow(sessionId, filePath) {
+  const row = rowFor(sessionId);
+  assert.ok(row, `${sessionId} 必须建行`);
+  assert.equal(row.path, filePath);
+  assert.equal(row.cwd, "/w/alpha");
+  assert.ok(row.project_key, "project_key 不能为空（否则被聊天区 project_key 过滤踢掉）");
+  assert.ok(row.created > 0, "created 必须来自文件，不能是 0（1970）");
+  assert.ok(row.modified > 0, "modified 必须来自文件");
+  return row;
+}
+
+/** 断言 miss 场景的可见性时静音 console.error（测试输出保持干净），仍校验调用次数。 */
+function captureConsoleError(t) {
+  const original = console.error;
+  const calls = [];
+  console.error = (...args) => {
+    calls.push(args.map(String).join(" "));
+  };
+  t.after(() => {
+    console.error = original;
+  });
+  return calls;
+}
+
+test("setSessionTitle 对无行会话建全列行（不再是只有 title 的局部行）", async () => {
+  freshDb();
+  const file = writeSession("alpha", "sess-title");
+
+  await store.setSessionTitle("sess-title", "新名字");
+
+  const row = assertFullRow("sess-title", file);
+  assert.equal(row.title, "新名字");
+  assert.equal(row.task_id, null);
+  assert.equal(row.pinned, 0);
+});
+
+test("setSessionPinned 对无行会话建全列行（不再是只有 pinned 的局部行）", async () => {
+  freshDb();
+  const file = writeSession("alpha", "sess-pin");
+
+  await store.setSessionPinned("sess-pin", true);
+
+  const row = assertFullRow("sess-pin", file);
+  assert.equal(row.pinned, 1);
+  assert.equal(row.task_id, null);
+});
+
+test("assignSessionToTask 对无行会话先建全列行再写归属", async () => {
+  freshDb();
+  const file = writeSession("alpha", "sess-assign");
+  const task = store.createTask("alpha-proj", "任务");
+
+  assert.equal(await store.assignSessionToTask("sess-assign", task.id), true);
+
+  const row = assertFullRow("sess-assign", file);
+  assert.equal(row.task_id, task.id, "归属与本轮建行同一次写入完成");
+});
+
+test("assignSessionSubtreeToTask 对无行会话同样先建全列行（子树归属不静默写 0 行）", async () => {
+  freshDb();
+  const file = writeSession("alpha", "sess-subtree");
+  const task = store.createTask("alpha-proj", "任务");
+
+  assert.equal(await store.assignSessionSubtreeToTask("sess-subtree", task.id), true);
+
+  const row = assertFullRow("sess-subtree", file);
+  assert.equal(row.task_id, task.id);
+});
+
+test("已有行时不看文件：库里行在 → 改名/置顶照常写入（不因文件丢失而丢写）", async () => {
+  const db = freshDb();
+  db.prepare(
+    "INSERT INTO session_meta (session_id, task_id, updated, pinned, path, cwd, project_key, created, modified) VALUES (?, NULL, ?, 0, ?, ?, ?, ?, ?)",
+  ).run("sess-row-only", Date.now(), "/gone/sess-row-only.jsonl", "/w/alpha", "/w/alpha", 1, 2);
+
+  await store.setSessionTitle("sess-row-only", "改名");
+  await store.setSessionPinned("sess-row-only", true);
+
+  const row = rowFor("sess-row-only");
+  assert.equal(row.title, "改名");
+  assert.equal(row.pinned, 1);
+  assert.equal(row.path, "/gone/sess-row-only.jsonl", "既有索引列不被覆盖");
+  assert.equal(row.project_key, "/w/alpha");
+});
+
+test("库里没行、磁盘也没文件 → 不写缺列局部行，报错可见", async (t) => {
+  const db = freshDb();
+  const logs = captureConsoleError(t);
+
+  await store.setSessionTitle("sess-ghost", "幽灵改名");
+  await store.setSessionPinned("sess-ghost", true);
+
+  assert.equal(db.prepare("SELECT COUNT(*) c FROM session_meta").get().c, 0, "绝不退回插局部行");
+  assert.equal(logs.length, 2, "两次写库各报一次错（失败可见，不静默）");
+  for (const line of logs) assert.match(line, /sess-ghost/);
+});
+
+// ── 补行时的 parent_id（归属守卫的可见性）────────────────────────────────────
+// 守卫（hasForeignTaskAncestor）只看库内 parent_id：库里还没行的会话，父链只在磁盘
+// header 里——补行时不写父，跨任务祖先对守卫就是盲区（无行会话会被当成顶层行放行）。
+
+test("无行会话补行时写 parent_id：磁盘父属别的任务 → 归属被拒绝（与「有行」路径同结论）", async (t) => {
+  const db = freshDb();
+  const logs = captureConsoleError(t);
+  const parentFile = writeSession("alpha", "guard-parent");
+  const other = store.createTask("alpha-proj", "别的任务");
+  db.prepare(
+    "INSERT INTO session_meta (session_id, task_id, updated, pinned, path, cwd, project_key, parent_id, created, modified) VALUES ('guard-parent', ?, 1, 0, ?, '/w/alpha', '/w/alpha', NULL, 1, 1)",
+  ).run(other.id, parentFile);
+  // 子会话：磁盘上有父指针，库里**没有行**（正是守卫此前看不见的那一类）。
+  const childFile = writeSession("alpha", "guard-child", parentFile);
+  const target = store.createTask("alpha-proj", "目标任务");
+
+  const assigned = await store.assignSessionSubtreeToTask("guard-child", target.id);
+
+  assert.equal(assigned, false, "祖先在别的任务 → 拒绝（返回 false 而不是静默归属）");
+  assert.equal(store.taskForSession("guard-child"), null, "拒绝 → 不写归属");
+  assert.equal(store.taskForSession("guard-parent"), other.id, "祖先归属不动");
+  assert.ok(
+    logs.some((line) => /祖先属于其它任务/.test(line)),
+    "拒绝可见（console.error）",
+  );
+  const row = rowFor("guard-child");
+  assert.ok(row, "补行照常完成（列齐全）");
+  assert.equal(row.path, childFile);
+  assert.equal(row.parent_id, "guard-parent", "补行时由磁盘 header.parentSession 反查写入父 id");
+});
+
+test("无行会话补行写 parent_id 的正向面：磁盘父属同一任务 → 归属成功且父链保持", async () => {
+  const db = freshDb();
+  const parentFile = writeSession("alpha", "same-parent");
+  const task = store.createTask("alpha-proj", "同一个任务");
+  db.prepare(
+    "INSERT INTO session_meta (session_id, task_id, updated, pinned, path, cwd, project_key, parent_id, created, modified) VALUES ('same-parent', ?, 1, 0, ?, '/w/alpha', '/w/alpha', NULL, 1, 1)",
+  ).run(task.id, parentFile);
+  writeSession("alpha", "same-child", parentFile);
+
+  assert.equal(await store.assignSessionSubtreeToTask("same-child", task.id), true);
+  const row = rowFor("same-child");
+  assert.equal(row.parent_id, "same-parent");
+  assert.equal(row.task_id, task.id, "同任务祖先不构成冲突");
+});
+
+test("无行会话的父反查不到（父行未建/父文件已消失）→ parent_id 留空，不被当成冲突", async () => {
+  const db = freshDb();
+  writeSession("alpha", "orphan-child", join(sessionsDir, "alpha", "2026-09-18T00-00-00_gone.jsonl"));
+  const task = store.createTask("alpha-proj", "任务");
+
+  assert.equal(await store.assignSessionSubtreeToTask("orphan-child", task.id), true);
+  const row = rowFor("orphan-child");
+  assert.equal(row.parent_id, null, "反查不到 → undefined（不写悬空指针）");
+  assert.equal(row.task_id, task.id);
+  assert.equal(db.prepare("SELECT COUNT(*) c FROM session_meta").get().c, 1);
+});

package/lib/task-store.subtree.test.mjs

@@ -0,0 +1,172 @@
+import test, { after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createJiti } from "jiti";
+
+// getAgentDir() 每次调用都读环境变量 → 指向临时树，测试绝不碰 ~/.pi/agent。
+// sessions 子目录先建好：无行会话补行时会按 id 在这里找文件，miss 不回落扫开发机真实目录。
+const agentDir = mkdtempSync(join(tmpdir(), "pi-web-subtree-"));
+mkdirSync(join(agentDir, "sessions"), { recursive: true });
+process.env.PI_CODING_AGENT_DIR = agentDir;
+after(() => rmSync(agentDir, { recursive: true, force: true }));
+
+const jiti = createJiti(import.meta.url, { interopDefault: true, moduleCache: false, alias: { "@": process.cwd() } });
+const { setDbForTesting } = await jiti.import("./sqlite-db.ts");
+const store = await jiti.import("./task-store.ts");
+
+function freshDb() {
+  const db = new DatabaseSync(":memory:");
+  setDbForTesting(db);
+  return db;
+}
+// 造一个「任务 T + 根 A + 子树 A<-B<-C」的库内结构
+function seedTree(db) {
+  const task = store.createTask("/p", "T");
+  const row = (id, taskId, parentId) => db.prepare(
+    "INSERT INTO session_meta (session_id, task_id, updated, pinned, path, cwd, project_key, created, modified, parent_id) VALUES (?,?,?,0,?,?,?,?,?,?)",
+  ).run(id, taskId, Date.now(), `/s/${id}.jsonl`, "/p", "/p", Date.now(), Date.now(), parentId);
+  row("A", null, null); row("B", null, "A"); row("C", null, "B");
+  return task;
+}
+
+test("listDescendantIds 按 parent_id 递归（不含自身，含多层）", () => {
+  const db = freshDb(); seedTree(db);
+  assert.deepEqual(store.listDescendantIds("A").sort(), ["B", "C"]);
+  assert.deepEqual(store.listDescendantIds("C"), []);
+});
+
+test("agent/new 之外的归属：assignSessionSubtreeToTask 连带子树", async () => {
+  const db = freshDb(); const task = seedTree(db);
+  assert.equal(await store.assignSessionSubtreeToTask("A", task.id), true);
+  const ids = db.prepare("SELECT session_id, task_id FROM session_meta ORDER BY session_id").all();
+  assert.deepEqual(ids.map((r) => [r.session_id, r.task_id]), [["A", task.id], ["B", task.id], ["C", task.id]]);
+});
+
+test("归属守卫：祖先属于别的任务 → 拒绝且不写任何行（子树/单节点入口一致）", async () => {
+  const db = freshDb(); const task = seedTree(db);
+  const other = store.createTask("/p", "Other");
+  // A 属于另一个任务 → C 的祖先链（C←B←A）上有非空且 ≠ 目标任务的 task_id
+  db.prepare("UPDATE session_meta SET task_id = ? WHERE session_id = 'A'").run(other.id);
+  const snapshot = () => db.prepare("SELECT session_id, task_id, updated FROM session_meta ORDER BY session_id").all()
+    .map((r) => [r.session_id, r.task_id, r.updated]);
+  const before = snapshot();
+  const errors = [];
+  const original = console.error;
+  console.error = (...args) => errors.push(args.map(String).join(" "));
+  try {
+    assert.equal(await store.assignSessionSubtreeToTask("C", task.id), false, "子树入口拒绝");
+    assert.equal(await store.assignSessionToTask("C", task.id), false, "单节点入口拒绝");
+  } finally {
+    console.error = original;
+  }
+  assert.deepEqual(snapshot(), before, "不写任何行（归属与 updated 都不变）");
+  assert.equal(errors.length, 2, "拒绝必须 console.error 可见");
+  assert.deepEqual(
+    errors.map((e) => (/子树归属被拒绝/.test(e) ? "subtree" : "single")),
+    ["subtree", "single"],
+    "子树入口与单节点入口各自给出可见日志",
+  );
+  // 悬空祖先（行已不在库）不算冲突：C 就是根
+  db.prepare("DELETE FROM session_meta WHERE session_id = 'A'").run();
+  assert.equal(await store.assignSessionSubtreeToTask("C", task.id), true, "祖先行已不存在 → 允许（C 是根）");
+  assert.equal(store.taskForSession("C"), task.id);
+});
+
+test("归属守卫：祖先只是聊天区会话（task_id NULL）→ 正常归属", async () => {
+  const db = freshDb(); const task = seedTree(db);
+  assert.equal(await store.assignSessionSubtreeToTask("C", task.id), true, "聊天区祖先不拦");
+  assert.equal(store.taskForSession("C"), task.id);
+  assert.equal(store.taskForSession("A"), null, "只归属自身 + 子树，祖先不动");
+  assert.equal(store.taskForSession("B"), null);
+});
+
+test("归属守卫：祖先就在同一任务 → 正常（幂等，不误拦）", async () => {
+  const db = freshDb(); const task = seedTree(db);
+  db.prepare("UPDATE session_meta SET task_id = ? WHERE session_id IN ('A','B')").run(task.id);
+  assert.equal(await store.assignSessionSubtreeToTask("C", task.id), true, "祖先同任务");
+  assert.equal(store.taskForSession("C"), task.id);
+  assert.equal(await store.assignSessionToTask("B", task.id), true, "重复归属幂等");
+  assert.equal(store.taskForSession("B"), task.id);
+});
+
+test("reparentSessionChildren：子行 parent_id 同请求改写为祖父（或 NULL）", () => {
+  const db = freshDb(); seedTree(db);
+  store.reparentSessionChildren("B", "A");
+  assert.equal(db.prepare("SELECT parent_id FROM session_meta WHERE session_id='C'").get().parent_id, "A", "子行接到祖父");
+  store.reparentSessionChildren("A", null);
+  assert.equal(db.prepare("SELECT parent_id FROM session_meta WHERE session_id='B'").get().parent_id, null, "祖父拿不到 → NULL");
+});
+
+test("updateTask 的 sessionIds 全量替换按子树闭包展开", () => {
+  const db = freshDb(); const task = seedTree(db);
+  store.updateTask(task.id, { sessionIds: ["A"] });          // 只给根，服务端要连带子树
+  assert.equal(store.taskForSession("B"), task.id);
+  store.updateTask(task.id, { sessionIds: [] });              // 清空 → 整棵子树回到聊天区
+  assert.equal(store.taskForSession("A"), null);
+  assert.equal(store.taskForSession("C"), null);
+});
+
+test("移出带子树的父会话：前端提交剩余成员列表（含子 id）也整树离开", () => {
+  const db = freshDb(); const task = seedTree(db);
+  store.updateTask(task.id, { sessionIds: ["A"] });          // A/B/C 全在任务
+  assert.equal(store.taskForSession("C"), task.id);
+  // 前端拖出父 A 时提交的是「剩余成员列表」（flat sessionIds 去掉 A，仍含子 id）
+  store.updateTask(task.id, { sessionIds: ["B", "C"] });
+  assert.equal(store.taskForSession("A"), null, "父离开任务");
+  assert.equal(store.taskForSession("B"), null, "B 的祖先 A 不在成员集合里 → B 一起离开");
+  assert.equal(store.taskForSession("C"), null, "C 跟随 B 一起离开（多层）");
+});
+
+test("祖先行已不存在（断链）时不剪：子会话仍可留在任务里当根", async () => {
+  const db = freshDb(); const task = seedTree(db);
+  await store.assignSessionSubtreeToTask("A", task.id);
+  // A 已被删（B 的 parent_id 悬空）——此窗口内不得把 B/C 踢出任务（它们就是本任务的根）
+  db.prepare("DELETE FROM session_meta WHERE session_id = 'A'").run();
+  store.updateTask(task.id, { sessionIds: ["B", "C"] });
+  assert.equal(store.taskForSession("B"), task.id);
+  assert.equal(store.taskForSession("C"), task.id);
+});
+
+test("子会话不能单独移出：祖先仍是成员时子会话保持在任务内", () => {
+  const db = freshDb(); const task = seedTree(db);
+  store.updateTask(task.id, { sessionIds: ["A"] });          // A/B/C 全在任务
+  // 前端拖出子会话 B 时提交的是 「flat 剩余成员列表」= filter(≠B) = ["A", "C"]（含祖先 A），
+  // 闭包再把 B 纳入 → 成员集合不变。这是有意的不变量：子会话不能被单独移出任务。
+  store.updateTask(task.id, { sessionIds: ["A", "C"] });
+  assert.equal(store.taskForSession("A"), task.id, "祖先仍在任务");
+  assert.equal(store.taskForSession("B"), task.id, "B 不能单飞（否则聊天区出现孤儿根）");
+  assert.equal(store.taskForSession("C"), task.id);
+});
+
+test("ensureSessionMetaRow 传 taskId 时落归属，不传时保持 NULL", () => {
+  freshDb();
+  store.ensureSessionMetaRow("X", { path: "/s/X.jsonl", cwd: "/p", projectKey: "/p", taskId: "T1" });
+  assert.equal(store.taskForSession("X"), "T1");
+  store.ensureSessionMetaRow("Y", { path: "/s/Y.jsonl", cwd: "/p", projectKey: "/p" });
+  assert.equal(store.taskForSession("Y"), null);
+});
+
+test("ensureSessionMetaRow 冲突路径不覆盖已有归属（第二次传别的 taskId 仍保留首个）", () => {
+  const db = freshDb();
+  store.ensureSessionMetaRow("X", { path: "/s/X.jsonl", cwd: "/p", projectKey: "/p", taskId: "T1" });
+  store.ensureSessionMetaRow("X", { path: "/s/X2.jsonl", cwd: "/p2", projectKey: "/p2", taskId: "T2" });
+  assert.equal(store.taskForSession("X"), "T1", "归属各自管：upsert 不覆盖");
+  assert.equal(
+    db.prepare("SELECT path FROM session_meta WHERE session_id = 'X'").get().path,
+    "/s/X2.jsonl",
+    "索引列照常刷新",
+  );
+});
+
+test("ensureSessionMetaRow：不传 firstMessage 的 upsert 不擦已有首条消息（COALESCE）", () => {
+  const db = freshDb();
+  store.ensureSessionMetaRow("F", { path: "/s/F.jsonl", cwd: "/p", projectKey: "/p", firstMessage: "首条消息" });
+  // 同 id 再 upsert（如 fork/重新落盘）但不带 firstMessage：旧写法会把首条消息擦成 NULL
+  store.ensureSessionMetaRow("F", { path: "/s/F2.jsonl", cwd: "/p", projectKey: "/p" });
+  const row = db.prepare("SELECT first_message, path FROM session_meta WHERE session_id = 'F'").get();
+  assert.equal(row.first_message, "首条消息", "已有首条消息保留");
+  assert.equal(row.path, "/s/F2.jsonl", "索引列照常刷新");
+});