@morlay/session-rdb 0.0.21-alpha.5 → 0.0.21-alpha.6

package/src/log.ts

@@ -30,6 +30,7 @@ export function rowToMeta(row: SessionRow): SessionHeader {
     isSeeded: row.fSeedLength !== null,
     ...(row.fOrigin !== null ? { origin: row.fOrigin as "subagent" } : {}),
     ...(row.fDelegationDepth === null ? {} : { delegationDepth: row.fDelegationDepth }),
+    ...(row.fAgentPreset === null ? {} : { agentPreset: row.fAgentPreset }),
   };
 }
 
@@ -47,6 +48,7 @@ export function sessionInsertRow(
   fSeedLength: number | null;
   fOrigin: string | null;
   fDelegationDepth: number | null;
+  fAgentPreset: string | null;
   fIncarnation: string;
   fRevision: number;
 } {
@@ -62,6 +64,7 @@ export function sessionInsertRow(
     fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
     fOrigin: meta.origin ?? null,
     fDelegationDepth: meta.delegationDepth ?? null,
+    fAgentPreset: meta.agentPreset ?? null,
     fIncarnation: incarnation,
     fRevision: 0,
   };
@@ -75,6 +78,7 @@ export function sessionConflictRow(storage: SessionStorageMetadata): {
   fSeedLength: number | null;
   fOrigin: string | null;
   fDelegationDepth: number | null;
+  fAgentPreset: string | null;
 } {
   const meta = storage.meta;
   return {
@@ -85,6 +89,7 @@ export function sessionConflictRow(storage: SessionStorageMetadata): {
     fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
     fOrigin: meta.origin ?? null,
     fDelegationDepth: meta.delegationDepth ?? null,
+    fAgentPreset: meta.agentPreset ?? null,
   };
 }
 
@@ -206,32 +211,23 @@ function isDeepEqualJson(a: unknown, b: unknown): boolean {
 }
 
 function toolResultRewriteContentOnly(original: SessionEvent, replacement: SessionEvent): boolean {
+  // V4 起 `content` 就是结果内容本身（工具身份在消息顶层的 `toolCallId`），所以「只改结果」的
+  // 重写等于「除了 `content` 之外逐字相同」。
   const originalData = original.data as Record<string, unknown>;
   const replacementData = replacement.data as Record<string, unknown>;
   const originalMessage = originalData["message"] as { content?: unknown } | undefined;
   const replacementMessage = replacementData["message"] as { content?: unknown } | undefined;
-  const originalContent = Array.isArray(originalMessage?.content)
-    ? originalMessage.content
-    : undefined;
-  const replacementContent = Array.isArray(replacementMessage?.content)
-    ? replacementMessage.content
-    : undefined;
-  if (originalContent === undefined || replacementContent === undefined) return false;
-  const originalRest = {
-    ...originalData,
-    message: {
-      ...originalMessage,
-      content: [{ ...(originalContent[0] as Record<string, unknown>), content: null }],
-    },
-  };
-  const replacementRest = {
-    ...replacementData,
-    message: {
-      ...replacementMessage,
-      content: [{ ...(replacementContent[0] as Record<string, unknown>), content: null }],
-    },
-  };
-  return isDeepEqualJson(originalRest, replacementRest);
+  if (!Array.isArray(originalMessage?.content) || !Array.isArray(replacementMessage?.content)) {
+    return false;
+  }
+  const rest = (data: Record<string, unknown>, message: Record<string, unknown>): unknown => ({
+    ...data,
+    message: { ...message, content: null },
+  });
+  return isDeepEqualJson(
+    rest(originalData, originalMessage as Record<string, unknown>),
+    rest(replacementData, replacementMessage as Record<string, unknown>),
+  );
 }
 
 export function findSurfaceRepairs(events: readonly SessionEvent[]): {
@@ -464,6 +460,95 @@ export function renameLegacyPtcEvents(events: SessionEvent[]): void {
   }
 }
 
+/**
+ * 把**旧代（v3 及更早）的消息形状**归一到当前格式（v4）：迁移链（严格）拒绝那些形状时，读路径仍要
+ * 能把它们读出来——只动字段与标记，不改坐标、不改内容。
+ *
+ * 三件事：
+ * - `system/message` 的 source：`{ kind: 'plugin', plugin: '@deepseek-ai/dsh-system-prompt' }` → `{ kind: 'system-prompt' }`
+ *   （v4 起 system 消息只认这个 kind）；
+ * - `tool/result` 的消息：v3 是 user 角色、结果块包在 `content[0]`；v4 是 `role: 'tool'` + 顶层
+ *   `toolCallId` + `content` 就是结果块；
+ * - 本仓库自己写过、上游已删除的事件类型（见 `LEGACY_OWN_EVENT_TYPES`）标 `ignorable: true`——v4 的
+ *   校验对未知类型只接受可忽略信封。
+ *
+ * 只认这张白名单：**其它未知类型保持 fail loud**（那是「数据来自更新的 harness」的信号，不能吞掉）。
+ */
+export function normalizeToCurrentShape(events: SessionEvent[]): void {
+  for (const event of events) {
+    const type = (event as { type: string }).type;
+    if (LEGACY_OWN_EVENT_TYPES.has(type)) {
+      (event as { ignorable?: true }).ignorable = true;
+      continue;
+    }
+    if (type === "system/message") {
+      const message = (event.data as unknown as Record<string, unknown>)["message"];
+      liftSystemMessageSource(message);
+      continue;
+    }
+    if (type === "tool/result") {
+      const message = (event.data as unknown as Record<string, unknown>)["message"];
+      liftToolResultMessage(message);
+    }
+  }
+}
+
+function liftSystemMessageSource(message: unknown): void {
+  if (typeof message !== "object" || message === null) return;
+  const record = message as Record<string, unknown>;
+  const source = record["source"];
+  if (typeof source !== "object" || source === null) return;
+  if ((source as Record<string, unknown>)["kind"] !== "plugin") return;
+  record["source"] = { kind: "system-prompt" };
+}
+
+function liftToolResultMessage(message: unknown): void {
+  if (typeof message !== "object" || message === null) return;
+  const record = message as Record<string, unknown>;
+  if (record["role"] === "tool" && typeof record["toolCallId"] === "string") return;
+  const source = record["source"] as Record<string, unknown> | undefined;
+  const block = Array.isArray(record["content"]) ? record["content"][0] : undefined;
+  if (typeof block !== "object" || block === null) return;
+  const lifted = block as Record<string, unknown>;
+  const callId = lifted["toolCallId"] ?? source?.["callId"];
+  if (typeof callId !== "string") return;
+  record["role"] = "tool";
+  record["toolCallId"] = callId;
+  record["content"] = Array.isArray(lifted["content"]) ? lifted["content"] : [];
+  if (typeof lifted["isError"] === "boolean") record["isError"] = lifted["isError"];
+  record["source"] = { kind: "tool", callId };
+}
+
+/**
+ * 本仓库写过、后来连同机制一起删除的事件类型：读的时候标 `ignorable: true` 让校验跳过它们。
+ * 新增历史类型时登记到这里——**不要**用「所有未知类型」代替（那会掩盖更新版本的未知事件）。
+ */
+export const LEGACY_OWN_EVENT_TYPES: ReadonlySet<string> = new Set(["session-branch/version"]);
+
+/** 行里是否还带着旧代消息形状（`session-branch/version` 这类自造事件也算）——写路径曾把回退视图的结果
+ * 以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
+export function hasLegacyShape(events: readonly SessionEvent[]): boolean {
+  for (const event of events) {
+    const type = (event as { type: string }).type;
+    if (LEGACY_OWN_EVENT_TYPES.has(type)) return true;
+    if (type === "system/message") {
+      const message = (event.data as unknown as Record<string, unknown>)["message"] as
+        | Record<string, unknown>
+        | undefined;
+      const source = message?.["source"] as Record<string, unknown> | undefined;
+      if (source?.["kind"] === "plugin") return true;
+      continue;
+    }
+    if (type === "tool/result") {
+      const message = (event.data as unknown as Record<string, unknown>)["message"] as
+        | Record<string, unknown>
+        | undefined;
+      if (message !== undefined && message["role"] !== "tool") return true;
+    }
+  }
+  return false;
+}
+
 export function repairReadView(events: SessionEvent[]): void {
   repairAssistantSettlement(events);
   repairRequestHeaders(events);

package/src/postgres.ts

@@ -13,6 +13,8 @@ import {
   type EventCountBucket,
   type EventInsert,
   type EventRow,
+  type SessionListRowsPage,
+  type SessionListRowsQuery,
   type SessionRow,
 } from "./backend.ts";
 import { toPostgresSchema } from "./adapters/index.ts";
@@ -283,7 +285,7 @@ export class PostgresBackend implements Backend {
       insertBridges: (rows) => this.insertBridges(tx, rows),
       updateHead: (id, headEventId, headSequence) =>
         this.updateHead(tx, id, headEventId, headSequence),
-      bumpRevision: (id) => this.bumpRevision(tx, id),
+      bumpRevision: (id, lastEventAt) => this.bumpRevision(tx, id, lastEventAt),
       refreshTitle: (id) => this.refreshTitle(tx, id),
       deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
       getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
@@ -425,11 +427,18 @@ export class PostgresBackend implements Backend {
   private async bumpRevision(
     exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
+    lastEventAt?: number,
   ): Promise<void> {
+    const sessions = this.tables["t_sessions"];
     await exec
-      .update(this.tables["t_sessions"])
-      .set({ fRevision: sql`${this.tables["t_sessions"].fRevision} + 1` })
-      .where(eq(this.tables["t_sessions"].fSessionId, id))
+      .update(sessions)
+      .set({
+        fRevision: sql`${sessions.fRevision} + 1`,
+        ...(lastEventAt === undefined
+          ? {}
+          : { fLastEventAt: sql`GREATEST(COALESCE(${sessions.fLastEventAt}, 0), ${lastEventAt})` }),
+      })
+      .where(eq(sessions.fSessionId, id))
       .execute();
   }
 
@@ -598,6 +607,57 @@ export class PostgresBackend implements Backend {
   }
 
   /** 用量聚合：与 SQLite 侧同形，读 `t_event_usage`，数值列回来是字符串。 */
+  async listSessionRows(query: SessionListRowsQuery = {}): Promise<SessionListRowsPage> {
+    const needle = query.query?.trim().toLowerCase() ?? "";
+    const like = `%${needle}%`;
+    const includeSubagents = query.includeSubagents === true;
+    const limit = query.limit ?? 20;
+    const offset = query.offset ?? 0;
+    const tSessions = this.tables["t_sessions"];
+    const tWorkspaces = this.tables["t_workspaces"];
+    const tWorkspaceSessions = this.tables["t_workspace_sessions"];
+    // 归属可能有多行（一个会话可在多个工作区）：取 position 最小的那条，避免放大结果行数。
+    const workspaceTitle = sql`(SELECT w.f_title FROM ${tWorkspaceSessions} b
+                                     JOIN ${tWorkspaces} w ON w.f_workspace_id = b.f_workspace_id
+                                    WHERE b.f_session_id = s.f_session_id
+                                    ORDER BY b.f_position LIMIT 1)`;
+    const where = sql`WHERE (${needle} = ''
+                          OR lower(COALESCE(s.f_title, '')) LIKE ${like}
+                          OR lower(COALESCE(${workspaceTitle}, '')) LIKE ${like})
+                        AND (${includeSubagents} OR s.f_origin IS DISTINCT FROM 'subagent')`;
+    const rows = (await this.db.execute(sql`
+      SELECT s.f_session_id AS session_id,
+             s.f_title AS title,
+             s.f_origin AS origin,
+             s.f_cwd AS cwd,
+             s.f_created_at AS created_at,
+             (s.f_archived_at IS NOT NULL) AS archived,
+             COALESCE(s.f_last_event_at, s.f_created_at) AS updated_at,
+             ${workspaceTitle} AS workspace
+        FROM ${tSessions} s
+        ${where}
+       ORDER BY updated_at DESC, s.f_session_id
+       LIMIT ${limit} OFFSET ${offset}
+    `)) as unknown as { rows: Array<Record<string, unknown>> };
+    const counted = (await this.db.execute(sql`
+      SELECT count(*) AS n FROM ${tSessions} s ${where}
+    `)) as unknown as { rows: Array<Record<string, unknown>> };
+    return {
+      items: rows.rows.map((row) => ({
+        sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
+        title: typeof row["title"] === "string" ? row["title"] : null,
+        origin: typeof row["origin"] === "string" ? row["origin"] : null,
+        cwd: typeof row["cwd"] === "string" ? row["cwd"] : null,
+        createdAt: numeric(row["created_at"]),
+        updatedAt: numeric(row["updated_at"]),
+        archived: row["archived"] === true,
+        subagent: row["origin"] === "subagent",
+        workspace: typeof row["workspace"] === "string" ? row["workspace"] : null,
+      })),
+      total: numeric(counted.rows[0]?.["n"] ?? 0),
+    };
+  }
+
   async usageReport(sinceMs?: number): Promise<UsageAggregate> {
     const usageSince = sinceMs === undefined ? sql`` : sql` AND u.f_created_at >= ${sinceMs}`;
     // 活动计数走派生表的「本地日」列（与桶的本地日口径一致）。
@@ -703,7 +763,7 @@ export class PostgresBackend implements Backend {
         ...tokenTotalsOf(row),
       })),
       sessions: tokenSessions.rows.map((row) => ({
-        sessionId: String(row["session_id"]),
+        sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
         title: text(row["title"]),
         subagent: row["subagent"] === true,
         archived: row["archived"] === true,

package/src/rows.ts

@@ -0,0 +1,125 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Backend } from "./backend.ts";
+
+/**
+ * 管理面的会话列表：**我们自己的**一条路由（完整语料，含归档），与官方 `session/list` 分开。
+ *
+ * 官方那条（`session/list` → `ctx.sessionQuery.listSessions`）按部署策略默认排除已归档——那是给上游
+ * UI 用的。归档集的管理动作要有完整列表，所以这里单独给一条：标题直接从会话列取，最后活动时间用
+ * 该会话最后一个事件的时间。
+ */
+export const SESSION_ROWS_PATH = "/api/session.rows";
+
+export interface SessionRowsItem {
+  sessionId: string;
+  title: string | null;
+  /** 会话 header 的 origin（`subagent` 表示子代理会话）。 */
+  origin: string | null;
+  cwd: string | null;
+  createdAt: number;
+  /** 最后一个事件的时间（无事件时等于 `createdAt`）。 */
+  updatedAt: number;
+  archived: boolean;
+  /** 所属工作区标题；不属于任何工作区时为 null。 */
+  workspace: string | null;
+}
+
+/** 请求：搜索、子代理过滤与分页都在后端做——前端分页等于每次拉全量，数据一多就崩。 */
+export interface SessionRowsRequest {
+  /** 匹配标题或所属工作区标题（大小写不敏感）。 */
+  query?: string;
+  includeSubagents?: boolean;
+  page?: number;
+  pageSize?: number;
+}
+
+export interface SessionRowsValue {
+  items: SessionRowsItem[];
+  /** 过滤后的总数（分页前），前端据此算页数。 */
+  total: number;
+  page: number;
+  pageSize: number;
+}
+
+/** 一页的条数上限：超过就按上限截断（这个接口给页面用，不是导出通道）。 */
+const MAX_PAGE_SIZE = 200;
+const DEFAULT_PAGE_SIZE = 20;
+
+export function registerSessionRows(ctx: Context, backend: Backend): void {
+  ctx.inject(["webServer", "connection"] as const, (webCtx) => {
+    const webServer = webCtx.webServer as unknown as {
+      register(route: {
+        kind: "exact";
+        path: string;
+        handler: (
+          req: import("node:http").IncomingMessage,
+          res: import("node:http").ServerResponse,
+        ) => void | Promise<void>;
+      }): () => void;
+    };
+    const connection = webCtx.get("connection") as unknown as {
+      requestRejection(request: {
+        headers: import("node:http").IncomingHttpHeaders;
+      }): number | undefined;
+    };
+    return webCtx.effect(
+      () =>
+        webServer.register({
+          kind: "exact",
+          path: SESSION_ROWS_PATH,
+          handler: async (req, res) => {
+            const rejection = connection.requestRejection(req);
+            if (rejection !== undefined) {
+              res.writeHead(rejection);
+              res.end(rejection === 401 ? "unauthorized" : "forbidden");
+              return;
+            }
+            if (req.method !== "POST") {
+              res.writeHead(405, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: "method not allowed" }));
+              return;
+            }
+            const chunks: Buffer[] = [];
+            for await (const chunk of req) chunks.push(chunk as Buffer);
+            const raw = Buffer.concat(chunks).toString("utf8");
+            let envelope: SessionRowsRequest = {};
+            if (raw !== "") {
+              try {
+                envelope = JSON.parse(raw) as SessionRowsRequest;
+              } catch {
+                res.writeHead(400, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: "request body is not JSON" }));
+                return;
+              }
+            }
+            const page = Number.isSafeInteger(envelope.page) && (envelope.page ?? 0) > 0 ? envelope.page! : 1;
+            const requested = envelope.pageSize;
+            const pageSize =
+              Number.isSafeInteger(requested) && (requested ?? 0) > 0
+                ? Math.min(requested!, MAX_PAGE_SIZE)
+                : DEFAULT_PAGE_SIZE;
+            try {
+              const { items, total } = await backend.listSessionRows({
+                ...(envelope.query === undefined ? {} : { query: envelope.query }),
+                ...(envelope.includeSubagents === undefined
+                  ? {}
+                  : { includeSubagents: envelope.includeSubagents }),
+                limit: pageSize,
+                offset: (page - 1) * pageSize,
+              });
+              res.writeHead(200, { "content-type": "application/json" });
+              res.end(JSON.stringify({ items, total, page, pageSize } satisfies SessionRowsValue));
+            } catch (error: unknown) {
+              res.writeHead(500, { "content-type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  error: error instanceof Error ? error.message : "session rows failed",
+                }),
+              );
+            }
+          },
+        }),
+      "session-rdb: session rows route",
+    );
+  });
+}

package/src/schema.ts

@@ -160,8 +160,9 @@ export function eventDimensions(event: SessionEvent): {
     case "assistant/message":
       return { kind, role: "assistant", name: "", actionId: "" };
     case "tool/result": {
-      const message = data["message"] as { content?: Array<{ toolCallId?: string }> } | undefined;
-      return { kind, role: "tool", name: "", actionId: message?.content?.[0]?.toolCallId ?? "" };
+      // V4 起结果消息自己带 `toolCallId`（不再包在 content 的一个 `tool-result` 块里）。
+      const message = data["message"] as { toolCallId?: string } | undefined;
+      return { kind, role: "tool", name: "", actionId: message?.toolCallId ?? "" };
     }
     case "tool/call":
       return {

package/src/session-query.ts

@@ -1,11 +1,37 @@
 import type { Context } from "@deepseek-ai/cordis";
-import { SessionQueryEngine, SessionQueryError, type Config } from "@deepseek-ai/dsh-session-query";
+import {
+  SessionQueryEngine,
+  SessionQueryError,
+  type Config,
+  type SessionRecord,
+} from "@deepseek-ai/dsh-session-query";
 
 export class SessionQueryRdb extends SessionQueryEngine {
   constructor(ctx: Context, config: Config = {}) {
     super(ctx, config);
   }
 
+  /**
+   * 官方列表（`session/list`）**默认不含已归档**：归档是「收起来」的会话，列表与搜索都不该把它混进
+   * 日常集合（上游 client 再用 workspace registry 的归档集做「只看归档」的派生）。
+   *
+   * 完整语料（含归档）走我们自己的管理面路由 `SESSION_ROWS_PATH`——两条路分开，不在一处混。
+   */
+  override async listSessions(signal?: AbortSignal): Promise<SessionRecord[]> {
+    const records = await super.listSessions(signal);
+    const archived = this.archivedSessionIds();
+    if (archived.size === 0) return records;
+    return records.filter((record) => !archived.has(String(record.header.id)));
+  }
+
+  /** 归档集合来自 workspace registry；服务未就绪时保守返回空集（宁可多给，不可漏掉可见会话）。 */
+  private archivedSessionIds(): ReadonlySet<string> {
+    const registry = this.ctx.get("workspaceRegistry" as never) as unknown as
+      | { archivedSessionIds?: readonly string[] }
+      | undefined;
+    return new Set<string>(registry?.archivedSessionIds ?? []);
+  }
+
   override async searchSessions(): Promise<never> {
     throw searchDisabled();
   }

package/src/sqlite.ts

@@ -14,6 +14,9 @@ import {
   type EventCountBucket,
   type EventInsert,
   type EventRow,
+  type SessionListRowRecord,
+  type SessionListRowsPage,
+  type SessionListRowsQuery,
   type SessionRow,
 } from "./backend.ts";
 import { sessionConflictRow, sessionInsertRow, titleOfEventData, usageRowOf } from "./log.ts";
@@ -139,6 +142,20 @@ function backfillEventUsage(db: DatabaseSync): void {
             OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
 }
 
+function sessionListRowOf(row: Record<string, unknown>): SessionListRowRecord {
+  return {
+    sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
+    title: typeof row["title"] === "string" ? row["title"] : null,
+    origin: typeof row["origin"] === "string" ? row["origin"] : null,
+    cwd: typeof row["cwd"] === "string" ? row["cwd"] : null,
+    createdAt: Number(row["created_at"]),
+    updatedAt: Number(row["updated_at"]),
+    archived: row["archived"] === 1 || row["archived"] === true,
+    subagent: row["origin"] === "subagent",
+    workspace: typeof row["workspace"] === "string" ? row["workspace"] : null,
+  };
+}
+
 /** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
 function tokenTotalsOf(row: {
   input_tokens: number | null;
@@ -495,7 +512,7 @@ export class SqliteBackend implements Backend {
     insertEvents: (events) => this.insertEvents(events),
     insertBridges: (rows) => this.insertBridges(rows),
     updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
-    bumpRevision: (id) => this.bumpRevision(id),
+    bumpRevision: (id, lastEventAt) => this.bumpRevision(id, lastEventAt),
     refreshTitle: (id) => this.refreshTitle(id),
     deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
     getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence),
@@ -595,10 +612,15 @@ export class SqliteBackend implements Backend {
       .run();
   }
 
-  private async bumpRevision(id: SessionId): Promise<void> {
+  private async bumpRevision(id: SessionId, lastEventAt?: number): Promise<void> {
     this.db
       .update(tSessions)
-      .set({ fRevision: sql`${tSessions.fRevision} + 1` })
+      .set({
+        fRevision: sql`${tSessions.fRevision} + 1`,
+        ...(lastEventAt === undefined
+          ? {}
+          : { fLastEventAt: sql`MAX(COALESCE(${tSessions.fLastEventAt}, 0), ${lastEventAt})` }),
+      })
       .where(eq(tSessions.fSessionId, id))
       .run();
   }
@@ -692,6 +714,52 @@ export class SqliteBackend implements Backend {
    * 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
    * `f_created_at`（同一时刻写入，口径一致）。
    */
+  async listSessionRows(query: SessionListRowsQuery = {}): Promise<SessionListRowsPage> {
+    const needle = query.query?.trim().toLowerCase() ?? "";
+    const like = `%${needle}%`;
+    // 排序键用物化列：`f_last_event_at` 由写路径维护、老数据由迁移回填，没有事件的会话回落 createdAt。
+    // 早先这里对每行算一次「该会话最后事件时间」的相关子查询——243 行要 4.2s，分页也救不了（排序要求
+    // 全表先算出来）。
+    const where = `WHERE (? = '' OR lower(COALESCE(s.f_title, '')) LIKE ? OR lower(COALESCE(w.f_title, '')) LIKE ?)
+                     AND (? = 1 OR s.f_origin IS NOT 'subagent')`;
+    const filterParams = [needle, like, like, query.includeSubagents === true ? 1 : 0];
+    const limit = query.limit ?? 20;
+    const offset = query.offset ?? 0;
+    const rows = this.db.$client
+      .prepare(
+        `SELECT s.f_session_id AS session_id,
+                s.f_title AS title,
+                s.f_origin AS origin,
+                s.f_cwd AS cwd,
+                s.f_created_at AS created_at,
+                (s.f_archived_at IS NOT NULL) AS archived,
+                COALESCE(s.f_last_event_at, s.f_created_at) AS updated_at,
+                w.f_title AS workspace
+           FROM t_sessions s
+           LEFT JOIN t_workspaces w ON w.f_workspace_id = (
+                 SELECT b.f_workspace_id FROM t_workspace_sessions b
+                  WHERE b.f_session_id = s.f_session_id ORDER BY b.f_position LIMIT 1)
+          ${where}
+          ORDER BY updated_at DESC, s.f_session_id
+          LIMIT ? OFFSET ?`,
+      )
+      .all(...filterParams, limit, offset) as unknown as Array<Record<string, unknown>>;
+    const counted = this.db.$client
+      .prepare(
+        `SELECT count(*) AS n
+           FROM t_sessions s
+           LEFT JOIN t_workspaces w ON w.f_workspace_id = (
+                 SELECT b.f_workspace_id FROM t_workspace_sessions b
+                  WHERE b.f_session_id = s.f_session_id ORDER BY b.f_position LIMIT 1)
+          ${where}`,
+      )
+      .get(...filterParams) as { n: number };
+    return {
+      items: rows.map((row) => sessionListRowOf(row)),
+      total: Number(counted.n),
+    };
+  }
+
   async usageReport(sinceMs?: number): Promise<UsageAggregate> {
     const usageSince = sinceMs === undefined ? "" : " AND u.f_created_at >= ?";
     const params = sinceMs === undefined ? [] : [sinceMs];