@morlay/session-rdb 0.0.20 → 0.0.21-alpha.0

package/dist/{schema-BkQN5GyT.d.mts → backend-DpdtxYpz.d.mts}

@@ -1,6 +1,7 @@
 import z from "@deepseek-ai/schemastery";
-import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import { SessionAccess, SessionHandle, SessionHandleAppendOptions, SessionHandleFlushOptions, SessionHandleReadOptions, SessionHandleReadResult, SessionPersistence, SessionPersistenceCreateOptions, SessionPersistenceListOptions, SessionPersistenceOpenOptions, SessionPersistenceRevision, SessionPersistenceSnapshot, SessionPersistenceStatOptions, SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset, SessionSeq, SessionSeqCursor } from "@deepseek-ai/dsh-session";
+import { BranchAnchorMode, BranchBoundary, ForkFromOptions, SessionBranch, SessionBranchProvider } from "@morlay/session-branch";
 import { KvUnit } from "@deepseek-ai/dsh-storage";
 import { Context, Service } from "@deepseek-ai/cordis";
 import { SessionId as SessionId$1 } from "@deepseek-ai/dsh-session/types";
@@ -2775,13 +2776,13 @@ declare module '@deepseek-ai/cordis' {
  * it per domain name. A route naming an unregistered backend fails loud at
  * `open` with `backend-not-found`.
  */
-interface Config$2 {
+interface Config$3 {
   /** Default backend name for every domain without an explicit route. Required: there is no universally correct medium. */
   backend: string;
   /** Per-domain overrides: domain name → backend name. */
   routes?: Record<string, string>;
 }
-declare const Config$2: z<Config$2>;
+declare const Config$3: z<Config$3>;
 /**
  * The mounted domain facility. Opens declared domains over routed backends;
  * one facility instance owns the open-domain table and enforces single-open
@@ -2798,7 +2799,7 @@ declare class DomainFacility {
    * events attach here.
    * @param config - Validated plugin config.
    */
-  constructor(ctx: Context, config: Config$2);
+  constructor(ctx: Context, config: Config$3);
   /**
    * Open one declared domain. Steps, each failing the whole call: reject a
    * name that is already open (`already-open`); resolve the backend route
@@ -2876,13 +2877,13 @@ declare module '@deepseek-ai/cordis' {
  * `turn/end`, and session disposal) are policy, not tunables, and always
  * fire.
  */
-interface Config$1 {
+interface Config$2 {
   /** Committed events per session that force a durable checkpoint write between mandatory points. */
   writeEveryEvents: number;
   /** Longest time (milliseconds) a dirty checkpoint may stay unwritten between mandatory points. */
   writeIntervalMs: number;
 }
-declare const Config$1: z<Config$1>;
+declare const Config$2: z<Config$2>;
 /**
  * The persisted projection cache service. Opens the `session_projcache`
  * domain at init, checkpoints live sessions on a throttled write-behind
@@ -2893,12 +2894,12 @@ declare const Config$1: z<Config$1>;
  * failures log a warning and the cache self-heals on the next write.
  */
 declare class SessionProjectionCache extends Service {
-  config: Config$1;
+  config: Config$2;
   static inject: string[];
-  static Config: z<Config$1>;
+  static Config: z<Config$2>;
   private table?;
   private readonly dirty;
-  constructor(ctx: Context, config: Config$1);
+  constructor(ctx: Context, config: Config$2);
   /** Open the domain and install the write-behind listeners. */
   protected [Service.init](): Promise<void>;
   /**
@@ -3242,6 +3243,17 @@ declare class WorkspaceRegistry extends Service {
    * @returns resolution after durability.
    */
   archiveSession(sessionId: SessionId): Promise<void>;
+  /**
+   * Unarchive one session durably by dropping it from the registry-global
+   * archive set; the accounting slot was never touched, so the session
+   * returns to its recorded position. Unarchiving runs no session-existence
+   * check because removing an id cannot introduce an unknown one, so an
+   * entry whose session is gone still resolves. An id that is not archived
+   * resolves without writing.
+   * @param sessionId - The session to unarchive.
+   * @returns resolution after durability.
+   */
+  unarchiveSession(sessionId: SessionId): Promise<void>;
   /**
    * Whether a session is live, header-indexed, or present in a fresh
    * persistence listing. Only a definite miss returns false — a failing
@@ -3283,75 +3295,337 @@ declare class WorkspaceRegistry extends Service {
 }
 //#endregion
 //#region src/storage-takeover/types.d.ts
-/**
- * 一个会话的完整 checkpoint：上游 `CheckpointIdentity`（日志身份，唯一权威定义
- * 在被替换的 projcache spec 里）+ 上游 `ProjectionCheckpoint`（逐 key 行）+ 会话键。
- */
 interface StoredProjcacheEntry {
   sessionId: SessionId;
   identity: CheckpointIdentity;
   rows: ProjectionCheckpoint;
 }
-/**
- * storages 接管表的方言无关访问层：SQLite 与 PostgreSQL 两个 Backend 各提供
- * 同一实现，调用方（KV 后端与投影缓存服务）不感知介质差异。读方法返回持久
- * 值的语义视图，workspace 的写入在介质事务内整体替换。
- */
 interface StorageRepository {
-  /** 读一个域的版本戳；域从未打开时 undefined。 */
   readUnitVersion(name: string): Promise<number | undefined>;
-  /** 写入域的首次版本戳；已存在时保持原值。 */
   insertUnitVersion(name: string, version: number): Promise<void>;
-  /** 读全部 workspace 记录（按 workspace id）。 */
   listWorkspaces(): Promise<Array<{
     id: string;
     record: WorkspaceRecord;
   }>>;
-  /** 覆盖写一条 workspace 记录（含归属行）。 */
   putWorkspace(id: string, record: WorkspaceRecord): Promise<void>;
-  /** 删除一条 workspace 记录（缺失为 no-op）。 */
   deleteWorkspace(id: string): Promise<void>;
-  /** 读 workspace 单例；从未写入时 null。 */
   readWorkspaceState(): Promise<WorkspaceDomainState | null>;
-  /** 覆盖写 workspace 单例（显示顺序与归档集一并整体替换）。 */
   writeWorkspaceState(state: WorkspaceDomainState): Promise<void>;
-  /** 读全部投影 checkpoint（含逐 key 行）。 */
   loadProjcache(): Promise<StoredProjcacheEntry[]>;
-  /**
-   * 同步读一个会话的 checkpoint：只有同步驱动（SQLite）提供，读路径直接落到
-   * 介质；异步驱动（PostgreSQL）缺席，调用方退化为写穿镜像。上游的
-   * `cachedSnapshot` 系列是同步签名，这里的存在性就是"能否直读库"的开关。
-   * @param sessionId - 会话 id。
-   * @returns 该会话的 checkpoint，缺失时 `undefined`。
-   */
-  readProjcacheSync?(sessionId: string): StoredProjcacheEntry | undefined;
-  /**
-   * 同步读一个会话的标题列（`t_sessions.f_title` / `f_title_seq`，rdb 写路径与
-   * rewind 维护）：只有同步驱动提供，列表消费直接取会话数据，不依赖 checkpoint
-   * 行是否存在。
-   * @param sessionId - 会话 id。
-   * @returns 标题与其事件 seq，未写过标题时 `undefined`。
-   */
-  readSessionTitleSync?(sessionId: string): {
+  /** 不经 await、直接读的路径（供同步的 `cachedSnapshot` 消费）；宿主提供不了则缺省。 */
+  readProjcacheDirect?(sessionId: string): StoredProjcacheEntry | undefined;
+  readSessionTitleDirect?(sessionId: string): {
     title: string;
     seq: number;
   } | undefined;
-  /**
-   * 覆盖写一个会话的 checkpoint 行（先清旧行再写新行，同一事务）。记录头
-   * 不在这里：它与 `t_sessions` 行 1:1，identity 直接复用该行的列。
-   * @param sessionId - 会话 id。
-   * @param rows - 每个投影 key 一行。
-   */
   putProjcache(sessionId: string, rows: ProjectionCheckpoint): Promise<void>;
-  /**
-   * 清理陈旧 checkpoint 行：水位为负却已有事件的会话（旧版写入路径的产物，
-   * 会把有对话的会话误判为空白）。缓存是派生数据，删除只让该会话回到
-   * 「未知即可见」并等待下一次强制点重写。
-   * @returns 删除的行数。
-   */
   pruneStaleProjcache(): Promise<number>;
 }
 //#endregion
+//#region src/write-guard.d.ts
+declare class WriteGuard {
+  private readonly headSeqs;
+  confirmHead(id: SessionId, head: number): void;
+  assertNoConcurrentWriter(id: SessionId, storedHead: number): void;
+}
+//#endregion
+//#region src/schema.d.ts
+declare const SCHEMA_VERSION = 3;
+declare const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+declare const EVENT_ENCODING = "json";
+declare const tPersistenceState: any;
+declare const tSchemaMeta: any;
+declare const tSessions: any;
+declare const tEvents: any;
+declare const tSessionEvents: any;
+declare const tStorageUnits: any;
+declare const tWorkspaces: any;
+declare const tWorkspaceSessions: any;
+declare const tWorkspaceState: any;
+declare const tSessionProjcacheRows: any;
+declare const tEventUsage: any;
+type JournalMode = "wal" | "delete" | "truncate" | "persist";
+declare const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+type EventKind = "message" | "thinking" | "turn" | "tool" | "request" | "config" | "audit" | "lifecycle" | "inbox" | "compaction" | "llm" | "subagent" | "team" | "workflow" | "goal" | "schedule" | "todo" | "web";
+type EventRole = "user" | "assistant" | "tool";
+declare function eventKind(event: {
+  type: string;
+  data?: unknown;
+}): EventKind | "";
+declare function eventDimensions(event: SessionEvent): {
+  kind: string;
+  role: string;
+  name: string;
+  actionId: string;
+};
+//#endregion
+//#region src/branch.d.ts
+declare function locateTurnEnd(events: readonly SessionEvent[], atSeq?: number, mode?: BranchAnchorMode): number;
+interface LiveSessionHooks {
+  getSession(id: SessionId): Session | undefined;
+  getAgent(id: SessionId): LiveAgentLike | undefined;
+  flush(session: Session): Promise<boolean>;
+  warn?(message: string): void;
+  resetProjections?(session: Session): void;
+  resetTokenMeter?(session: Session): void;
+  refreshProjectionCache?(session: ProjectionCacheSession): Promise<void>;
+}
+interface ProjectionCacheSession {
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly inheritedEventCount: SessionLogOffset;
+  readonly headSeq?: number;
+  snapshotEvents(): readonly SessionEvent[];
+}
+interface LiveAgentLike {
+  session: Session;
+  requestHeaderLogged?: boolean;
+  inbox?: {
+    clear(): void;
+  };
+}
+declare function truncateLiveSession(session: Session, newLength: number): void;
+declare class SessionBranchRdbProvider implements SessionBranchProvider {
+  private readonly persistence;
+  private readonly live;
+  readonly name = "session-rdb";
+  constructor(persistence: SessionPersistenceRdb, live?: LiveSessionHooks);
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+  private rewindKeepLength;
+  private refreshProjectionCache;
+}
+declare class SessionBranchRdb extends SessionBranch {
+  static inject: string[];
+  private readonly warned;
+  constructor(ctx: import("@deepseek-ai/cordis").Context);
+  resetLiveDerivedState(session: Session): void;
+  private warnOnce;
+  private resetProjectionCells;
+  private resetTokenMeterFold;
+  private readonly provider;
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<import("@morlay/session-branch").BranchTimeline>;
+}
+//#endregion
+//#region src/index.d.ts
+interface SessionPersistenceRdbInternals {
+  readonly backend: Backend;
+  readonly writeGuard: WriteGuard;
+  create(meta: SessionHeader, inheritedEventCount?: number): Promise<SessionHandle>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  load(id: SessionId): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  inspect(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceRevision | undefined>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+}
+interface ProjectionCacheOptions {
+  writeEveryEvents?: number;
+  writeIntervalMs?: number;
+}
+type Config$1 = {
+  type: "sqlite";
+  path: string;
+  journalMode?: JournalMode;
+  busyTimeout?: number;
+  projectionCache?: ProjectionCacheOptions;
+} | {
+  type: "postgres";
+  connectionString: string;
+  schema?: string;
+  projectionCache?: ProjectionCacheOptions;
+};
+type SessionDeletionErrorCode = "SESSION_NOT_FOUND" | "SESSION_NOT_ARCHIVED" | "SESSION_LIVE";
+declare class SessionDeletionError extends Error {
+  readonly code: SessionDeletionErrorCode;
+  constructor(message: string, code: SessionDeletionErrorCode);
+}
+interface PendingSession {
+  readonly header: SessionHeader;
+  readonly revision: SessionPersistenceRevision;
+  readonly inheritedEventCount: SessionLogOffset;
+  readonly cursor: number;
+  readonly everAppended: boolean;
+}
+declare class RdbBackendTracker {
+  private readonly name;
+  private readonly writers;
+  private readonly pending;
+  private readonly openHandles;
+  private counter;
+  constructor(name: string);
+  registerCreated(header: SessionHeader, inheritedEventCount: SessionLogOffset): void;
+  updatePending(id: SessionId, cursor: number, everAppended: boolean): void;
+  claimWrite(id: SessionId): void;
+  releaseClaim(id: SessionId): void;
+  pendingOf(id: SessionId): PendingSession | undefined;
+  hasPending(id: SessionId): boolean;
+  pendingEntries(): IterableIterator<[SessionId, PendingSession]>;
+  materialized(id: SessionId): void;
+  adopt(handle: RdbSessionHandle): RdbSessionHandle;
+  release(handle: RdbSessionHandle, materialized: boolean): void;
+  writerOf(id: SessionId): RdbSessionHandle | undefined;
+  hasOpenHandle(id: SessionId): boolean;
+  flushAll(): Promise<void>;
+  closeAll(): Promise<void>;
+}
+declare class RdbSessionHandle implements SessionHandle {
+  private readonly persistence;
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly access: SessionAccess;
+  private readonly state;
+  private chain;
+  private closing;
+  private cursor;
+  private materialized;
+  private buffered;
+  private batchTimer;
+  private drainPaused;
+  private draining;
+  private tornTruncateTo;
+  private everAppended;
+  constructor(persistence: SessionPersistenceRdb, id: SessionId, header: SessionHeader, access: SessionAccess, state: {
+    cursor: number;
+    materialized: boolean;
+    inheritedEventCount: SessionLogOffset;
+    tornTruncateTo?: number;
+  });
+  get inheritedEventCount(): SessionLogOffset;
+  get cursorValue(): number;
+  read(offset?: number, length?: number, options?: SessionHandleReadOptions): Promise<SessionHandleReadResult>;
+  append(events: readonly SessionEvent[], options?: SessionHandleAppendOptions): Promise<void>;
+  flush(options?: SessionHandleFlushOptions): Promise<void>;
+  close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  enqueueLive(event: SessionEvent, reportBackgroundFailure: (error: unknown) => void): void;
+  resetAfterRewind(cursor: number, inheritedEventCount?: number): void;
+  drainLive(): Promise<void>;
+  private drainBuffered;
+  private enqueueChain;
+  private run;
+  private assertOpen;
+  static readonly LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
+}
+declare class SessionPersistenceRdb extends SessionPersistence {
+  config: Config$1;
+  static inject: string[];
+  static Config: z<Config$1>;
+  static readonly settingsNs = "session-rdb";
+  readonly name = "session-rdb";
+  readonly tracker: RdbBackendTracker;
+  private readonly backend;
+  private storeIdentity;
+  private readonly ready;
+  private readonly writeGuard;
+  private readonly reuseEventIds;
+  private readonly liveBuffers;
+  private readonly liveReady;
+  constructor(ctx: Context, config: Config$1, injectedBackend?: Backend);
+  private init;
+  create(header: SessionHeader, options?: SessionPersistenceCreateOptions): Promise<SessionHandle>;
+  open(id: SessionId, access: SessionAccess, options?: SessionPersistenceOpenOptions): Promise<SessionHandle>;
+  flush(): Promise<void>;
+  stat(id: SessionId, options?: SessionPersistenceStatOptions): Promise<SessionPersistenceSnapshot | undefined>;
+  list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
+  deleteSession(id: SessionId, signal?: AbortSignal): Promise<void>;
+  /** GC 通道：回收已无桥接行引用的事件行（孤儿），返回删除行数。 */
+  collectOrphans(): Promise<number>;
+  /** GC 通道：回收父已不存在的 subagent 会话（live 的跳过），返回删除的会话数。 */
+  collectOrphanSessions(): Promise<number>;
+  /** 用量统计：SQL 聚合的按天 × 模型桶与按会话行（事件行去重、排除孤儿行）。 */
+  usageReport(sinceMs?: number): Promise<UsageAggregate>;
+  /** GC 通道：VACUUM；调用方需先停止运行中的写路径（见 `registerSessionGc`）。 */
+  vacuum(): Promise<void>;
+  private unarchiveBeforeDeletion;
+  readRaw(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    filename: string;
+    content: string;
+  } | undefined>;
+  materializeEmpty(meta: SessionHeader, inheritedEventCount: SessionLogOffset): Promise<void>;
+  appendBatch(meta: SessionHeader, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent[], tornTruncateTo?: number): Promise<boolean>;
+  readLog(id: SessionId, options?: {
+    fromSeq?: number;
+  }, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: SessionEvent[];
+    tornFrom?: number;
+    incarnation: string;
+    revision: number;
+    storedCount: number;
+    migrated: boolean;
+  } | undefined>;
+  private rewriteMigratedLog;
+  listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
+    inheritedEventCount: number;
+  }>>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<SessionPersistenceRevision | undefined>;
+  createAndAppend(header: SessionHeader, events: readonly SessionEvent[], inheritedEventCount?: number): Promise<void>;
+  load(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  close(): Promise<void>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+  internals(): SessionPersistenceRdbInternals;
+  private rowRevision;
+  private installLiveRouting;
+  private ensureLiveHandle;
+}
+//#endregion
+//#region src/usage.d.ts
+/** 一段用量合计（token 字段直接取事件里模型报的 usage）。 */
+interface UsageTotals {
+  events: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  reasoningTokens: number;
+  totalTokens: number;
+}
+/** 一天 × 一个模型 × 是否子代理 的用量桶：总览、按天、按模型都由它折叠。 */
+interface UsageBucket extends UsageTotals {
+  day: string;
+  provider: string | null;
+  model: string | null;
+  subagent: boolean;
+}
+/** 一条会话的用量行。 */
+interface UsageSessionRow extends UsageTotals {
+  sessionId: string;
+  title: string | null;
+  subagent: boolean;
+  archived: boolean;
+}
+/** 后端的原始聚合结果。 */
+interface UsageAggregate {
+  buckets: UsageBucket[];
+  sessions: UsageSessionRow[];
+}
+//#endregion
 //#region src/backend.d.ts
 interface SessionRow {
   fSessionId: string;
@@ -3366,6 +3640,7 @@ interface SessionRow {
   fDelegationDepth: number | null;
   fIncarnation: string;
   fRevision: number;
+  fArchivedAt: number | null;
 }
 interface EventInsert {
   fEventId: string;
@@ -3396,7 +3671,6 @@ interface BackendTx {
   getHead(id: SessionId): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">>;
   getSeedLength(id: SessionId): Promise<number | null>;
   updateSeedLength(id: SessionId, seedLength: number): Promise<void>;
-  /** 从事件表重算会话标题（最后一条 `session/title`）并写回会话行。 */
   refreshTitle(id: SessionId): Promise<void>;
   insertEvents(events: EventInsert[]): Promise<void>;
   insertBridges(rows: Array<{
@@ -3412,54 +3686,33 @@ interface BackendTx {
     fEventId: string;
     fSequence: number;
   } | undefined>;
+  deleteSession(id: SessionId): Promise<void>;
+  /** 批量删除整条会话：桥接行、workspace 归属行、投影行与会话行。 */
+  deleteSessions(ids: SessionId[]): Promise<number>;
 }
 interface Backend {
   readonly kind: "sqlite" | "postgres";
   readonly storeIdentity: string;
-  /** storages 接管表（workspace 域与投影 checkpoint）的访问层：与事件日志同介质。 */
   readonly storage: StorageRepository;
   open(): Promise<void>;
   getSession(id: SessionId): Promise<SessionRow | undefined>;
   getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
+  getEventTypeAt(id: SessionId, sequence: number): Promise<string | undefined>;
+  getEventTypesBefore(id: SessionId, beforeSequence: number, limit: number): Promise<Array<Pick<EventRow, "fSequence" | "fType">>>;
   listSessions(): Promise<SessionRow[]>;
   transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
+  /** 删除已无桥接行引用的事件行（孤儿），返回删除行数。 */
+  collectOrphans(): Promise<number>;
+  /** 父会话已不存在（或没有父）的 subagent 会话：父被删后它们成了孤儿。 */
+  listOrphanSubagentSessions(): Promise<SessionId[]>;
+  /**
+   * 用量统计的原始聚合：按天×模型×subagent 的桶与按会话的行（事件行去重、排除孤儿）。
+   * @param sinceMs - 只算该时刻（含）之后的事件行；省略即全量。
+   */
+  usageReport(sinceMs?: number): Promise<UsageAggregate>;
+  /** 回收空间与统计（含 VACUUM）；不得在事务内执行。 */
+  vacuum(): Promise<void>;
   close(): Promise<void>;
 }
 //#endregion
-//#region src/write-guard.d.ts
-declare class WriteGuard {
-  private readonly headSeqs;
-  confirmHead(id: SessionId, head: number): void;
-  assertNoConcurrentWriter(id: SessionId, storedHead: number): void;
-}
-//#endregion
-//#region src/schema.d.ts
-declare const SCHEMA_VERSION = 3;
-declare const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
-declare const EVENT_ENCODING = "json";
-declare const tPersistenceState: any;
-declare const tSchemaMeta: any;
-declare const tSessions: any;
-declare const tEvents: any;
-declare const tSessionEvents: any;
-declare const tStorageUnits: any;
-declare const tWorkspaces: any;
-declare const tWorkspaceSessions: any;
-declare const tWorkspaceState: any;
-declare const tSessionProjcacheRows: any;
-type JournalMode = "wal" | "delete" | "truncate" | "persist";
-declare const DEFAULT_BUSY_TIMEOUT_MS = 5000;
-type EventKind = "message" | "thinking" | "turn" | "tool" | "request" | "config" | "audit" | "lifecycle" | "inbox" | "compaction" | "llm" | "subagent" | "team" | "workflow" | "goal" | "schedule" | "todo" | "web";
-type EventRole = "user" | "assistant" | "tool";
-declare function eventKind(event: {
-  type: string;
-  data?: unknown;
-}): EventKind | "";
-declare function eventDimensions(event: SessionEvent): {
-  kind: string;
-  role: string;
-  name: string;
-  actionId: string;
-};
-//#endregion
-export { EventRow as C, BackendTx as S, StorageRepository as T, tWorkspaceSessions as _, JournalMode as a, WriteGuard as b, eventDimensions as c, tPersistenceState as d, tSchemaMeta as f, tStorageUnits as g, tSessions as h, EventRole as i, eventKind as l, tSessionProjcacheRows as m, EVENT_ENCODING as n, SCHEMA_VERSION as o, tSessionEvents as p, EventKind as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, DEFAULT_BUSY_TIMEOUT_MS as t, tEvents as u, tWorkspaceState as v, SessionRow as w, Backend as x, tWorkspaces as y };
+export { tSessionProjcacheRows as A, eventDimensions as C, tPersistenceState as D, tEvents as E, tWorkspaces as F, WriteGuard as I, StorageRepository as L, tStorageUnits as M, tWorkspaceSessions as N, tSchemaMeta as O, tWorkspaceState as P, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as S, tEventUsage as T, EVENT_ENCODING as _, UsageAggregate as a, JournalMode as b, SessionDeletionError as c, SessionPersistenceRdbInternals as d, SessionBranchRdb as f, DEFAULT_BUSY_TIMEOUT_MS as g, truncateLiveSession as h, SessionRow as i, tSessions as j, tSessionEvents as k, SessionDeletionErrorCode as l, locateTurnEnd as m, BackendTx as n, Config$1 as o, SessionBranchRdbProvider as p, EventRow as r, ProjectionCacheOptions as s, Backend as t, SessionPersistenceRdb as u, EventKind as v, eventKind as w, SCHEMA_VERSION as x, EventRole as y };