@baique/pi-web-sky 0.1.56 → 0.1.57

package/lib/subagent-runtime.ts

@@ -38,6 +38,8 @@ import { resolveShellTools } from "./powershell-settings";
 import { isBuiltInSubagentsEnabled, readSubagentSettings } from "./subagent-settings";
 import { SubagentQueue } from "./subagent-queue";
 import { addWorktree, removeWorktree } from "./worktree";
+import { projectIdentityKey } from "./project-identity";
+import { ensureSessionMetaRow, taskForSession } from "./task-store";
 import { randomUUID } from "node:crypto";
 
 interface HostSession {
@@ -129,6 +131,32 @@ async function cleanupWorktree(
   }
 }
 
+/** 内置 subagent 出生即建行（父会话归属 + 任务归属，否则只会在聊天区当孤儿根出现）。
+ *  `title` **只**取 `description`（用户 2026-09-18 规则：描述有值即会话标题，展示优先于首条消息）；
+ *  空/全空白不写 title——既不写空串、也不拿 run 元数据里的 profile 显示名兜底（展示链是
+ *  `title || first_message`，拿 "Explore" 当标题会把被委派任务的原文挤掉，正是要修的病）。
+ *  `first_message` 是内容派生列，这里**不写**：留给扫描器/事件链路按真实首条用户消息回填，
+ *  否则「首条消息」会变成 describe 文案而不是被委派的任务。 */
+export function ensureSubagentSessionRow(sessionId: string, row: {
+  path: string;
+  cwd: string;
+  projectKey: string;
+  parentId: string;
+  taskId?: string | null;
+  /** Agent 工具传来的短描述（request.description）——有值即标题。 */
+  description: string;
+}): void {
+  const title = row.description.trim();
+  ensureSessionMetaRow(sessionId, {
+    path: row.path,
+    cwd: row.cwd,
+    projectKey: row.projectKey,
+    parentId: row.parentId,
+    taskId: row.taskId,
+    ...(title ? { title } : {}),
+  });
+}
+
 export function createSubagentController(
   dependencies: SubagentRuntimeDependencies,
 ): SubagentController {
@@ -258,6 +286,20 @@ export function createSubagentController(
         chatOnly,
       });
 
+      // 子代理会话与 fork 同规则：落库即带父会话归属（否则只会在聊天区当孤儿根出现）。
+      try {
+        ensureSubagentSessionRow(inner.sessionId, {
+          path: inner.sessionFile ?? "",
+          cwd: (isolatedWorktree ? childCwd : parent.cwd) ?? "",
+          projectKey: projectIdentityKey((isolatedWorktree ? childCwd : parent.cwd) ?? ""),
+          parentId: parentSessionId,
+          taskId: taskForSession(parentSessionId),
+          description: request.description,
+        });
+      } catch (e) {
+        console.error("[pi-web] subagent 会话建行失败:", e instanceof Error ? e.message : String(e));
+      }
+
       const initialRun: SubagentRunInfo = {
         sessionId: inner.sessionId,
         sessionPath: inner.sessionFile ?? sessionManager.getSessionFile() ?? "",

package/lib/subagent-session-title.test.mjs

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+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，也不跑真实 subagent。
+const agentDir = mkdtempSync(join(tmpdir(), "pi-web-subagent-title-"));
+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 { fillFirstMessageIfEmpty } = await jiti.import("./task-store.ts");
+const { ensureSubagentSessionRow } = await jiti.import("./subagent-runtime.ts");
+
+function freshDb() {
+  setDbForTesting(new DatabaseSync(":memory:"));
+  const db = getDb();
+  db.exec("PRAGMA foreign_keys = ON");
+  return db;
+}
+
+/** 内置 subagent 出生即建行，与 lib/subagent-runtime.ts start() 里同参数。
+ *  只收 request.description：run 元数据里的 profile 显示名**不是**标题来源。 */
+function buildRow(db, sessionId, { description, parentId = "parent-session" }) {
+  ensureSubagentSessionRow(sessionId, {
+    path: `/tmp/sessions/${sessionId}.jsonl`,
+    cwd: "/tmp",
+    projectKey: "proj",
+    parentId,
+    taskId: null,
+    description,
+  });
+  return db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionId);
+}
+
+test("description 有值即标题：建行时 title = trim 后的 description（不依赖首条消息兜底）", () => {
+  const db = freshDb();
+  const row = buildRow(db, "child-named", { description: "  Inspect parser  " });
+
+  assert.equal(row.title, "Inspect parser");
+  assert.equal(row.parent_id, "parent-session");
+});
+
+test("description 空白/空 → title 为 NULL（不写空串；profile 显示名也不许兜底成标题）", () => {
+  const db = freshDb();
+
+  // 空 description 的子代理，run 元数据里仍有 profile.displayName（"Explore"/"Plan" 之类）。
+  // 建行时只拿得到 request.description，标题必须是 NULL——展示回退到被委派任务的原文，
+  // 而不是显示 "Explore"。
+  for (const [sessionId, description] of [["child-blank", "   "], ["child-empty", ""], ["child-newline", " \n "]]) {
+    const row = buildRow(db, sessionId, { description });
+    assert.equal(row.title, null, `${sessionId} 不应写入空串/空白/profile 名标题`);
+  }
+});
+
+test("老兜底口已关闭：实参里就算带上元数据描述，空 description 的 title 仍为 NULL", () => {
+  const db = freshDb();
+  // 元数据描述（metadata.description = profile.displayName）曾是标题兜底来源，
+  // 现在建行函数不认这个字段——它不得从任何旁路挤进 title。
+  ensureSubagentSessionRow("child-extra", {
+    path: "/tmp/sessions/child-extra.jsonl",
+    cwd: "/tmp",
+    projectKey: "proj",
+    parentId: "parent-session",
+    taskId: null,
+    description: "   ",
+    fallbackDescription: "Explore",
+  });
+
+  const row = db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get("child-extra");
+  assert.equal(row.title, null, "profile 显示名不得变成子会话标题");
+});
+
+test("first_message 不再写 description：留 NULL，由真实首条用户消息回填", () => {
+  const db = freshDb();
+  const row = buildRow(db, "child-first", { description: "Inspect parser" });
+
+  assert.equal(row.first_message, null, "描述不是首条消息，不应占用内容派生列");
+
+  // 内容派生列的回填路径（扫描器/事件链路同语义）在其上照常工作。
+  fillFirstMessageIfEmpty("child-first", "Find the parser");
+  const filled = db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get("child-first");
+  assert.equal(filled.first_message, "Find the parser");
+  assert.equal(filled.title, "Inspect parser", "回填首条消息不动自定义标题");
+});
+
+/** 从 `ensureSubagentSessionRow(inner.sessionId` 起按花括号配对取出实参块。 */
+function subagentRowCallArgs(source) {
+  const start = source.indexOf("ensureSubagentSessionRow(inner.sessionId");
+  assert.ok(start >= 0, "start() 里找不到 ensureSubagentSessionRow(inner.sessionId 调用点");
+  const open = source.indexOf("{", start);
+  assert.ok(open > start, "调用点后面找不到实参对象");
+  let depth = 0;
+  for (let i = open; i < source.length; i += 1) {
+    if (source[i] === "{") depth += 1;
+    else if (source[i] === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(open, i + 1);
+    }
+  }
+  throw new Error("建行调用的实参对象没有闭合");
+}
+
+test("start() 接线：标题来源只有 request.description，不传 firstMessage/元数据描述", async () => {
+  const source = await readFile(new URL("./subagent-runtime.ts", import.meta.url), "utf8");
+  const args = subagentRowCallArgs(source);
+
+  assert.match(args, /description: request\.description/, "标题来源必须是 request.description");
+  assert.doesNotMatch(args, /firstMessage/, "first_message 是内容派生列，建行时不能写");
+  assert.doesNotMatch(args, /fallbackDescription|displayName|metadata\.description/, "profile 显示名不算标题");
+  assert.match(args, /parentId: parentSessionId/, "父会话归属丢了，子会话会在聊天区当孤儿根");
+  assert.match(args, /taskId: taskForSession\(parentSessionId\)/, "任务归属继承丢了");
+  assert.doesNotMatch(source, /firstMessage: request\.description/, "描述不能占 first_message（那是内容派生列）");
+});

package/lib/task-scheduler.test.mjs

@@ -1,4 +1,5 @@
 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";
@@ -76,3 +77,29 @@ test("clearSchedulerLeaderForTesting 清空后可重新注册", () => {
   assert.equal(getLeaderInstanceId(), null);
   assert.equal(tryBecomeLeader("inst-b"), true);
 });
+
+// ── 派发时的归属失败不能静默 ──
+// assignSessionToTask 会拒绝（返回 false）：祖先属别的任务 / 会话解析不出。丢了返回值的话
+// 「派发了但会话没进任务区」在日志里毫无痕迹（reconcile 会把它当孤儿卡）。
+
+const schedulerSource = await readFile(new URL("./task-scheduler.ts", import.meta.url), "utf8");
+
+/** 取 [from, to) 之间的源码片段；锚点找不到就报错（避免静默退化成整文件切片）。 */
+function sliceBetween(text, from, to) {
+  const start = text.indexOf(from);
+  assert.ok(start >= 0, `切片起点不存在：${from}`);
+  const end = text.indexOf(to, start);
+  assert.ok(end > start, `切片终点不存在（或不在起点之后）：${to}`);
+  return text.slice(start, end);
+}
+
+test("派发会话归属失败不静默：检查 assignSessionToTask 返回值并 console.warn", () => {
+  const assignBlock = sliceBetween(
+    schedulerSource,
+    "const board = getBoard(card.boardId);",
+    "if (session.session.isRunning())",
+  );
+  assert.match(assignBlock, /const assigned = await assignSessionToTask\(/, "返回值必须接住");
+  assert.match(assignBlock, /if \(!assigned\)[\s\S]*?console\.warn\(/, "失败必须可见（console.warn）");
+  assert.match(assignBlock, /派发的会话未能归属任务/);
+});

package/lib/task-scheduler.ts

@@ -156,7 +156,14 @@ export async function dispatchCard(card: TaskCard): Promise<boolean> {
 
     const board = getBoard(card.boardId);
     if (board?.taskId) {
-      assignSessionToTask(session.realSessionId, board.taskId);
+      // 返回值不能丢：拒绝（祖先属别的任务 / 会话解析不出）时这个会话不会进任务区，
+      // 而 reconcile 按「卡在任务里」补卡——静默失败会让派发结果不可解释。
+      const assigned = await assignSessionToTask(session.realSessionId, board.taskId);
+      if (!assigned) {
+        console.warn(
+          `[task-scheduler] #${card.number} ${card.name} 派发的会话未能归属任务 task=${board.taskId} session=${session.realSessionId}`,
+        );
+      }
       // 注意：不在 assignSessionToTask 后 reconcile——此刻卡 sessionId 未落表，
       // reconcile 只能补会话卡、建不了 exec 线 → 造成「先出卡后出线」。
       // 统一在 updateCard(sessionId) 之后触发（补卡+建线同一次事务、一次广播）。

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