@morlay/session-rdb 0.1.5 → 0.1.7

package/dist/usage.d.mts

@@ -1,2 +1,2 @@
-import { B as UsageTotals, F as UsageAggregate, G as emptyTotals, H as addActivityTotals, I as UsageBucket, It as SESSION_USAGE_PATH, J as resolveUsageSince, K as localDayKey, L as UsageRangeKey, M as COUNTED_EVENT_TYPES, N as SessionUsageReport, P as UsageActivityTotals, R as UsageSessionRow, U as addTokenTotals, V as addActivityCount, W as addTotals, q as registerSessionUsage, z as UsageTokenTotals } from "./log-DYyxRh7j.mjs";
+import { B as UsageTotals, F as UsageAggregate, G as emptyTotals, H as addActivityTotals, I as UsageBucket, J as resolveUsageSince, K as localDayKey, L as UsageRangeKey, Lt as SESSION_USAGE_PATH, M as COUNTED_EVENT_TYPES, N as SessionUsageReport, P as UsageActivityTotals, R as UsageSessionRow, U as addTokenTotals, V as addActivityCount, W as addTotals, q as registerSessionUsage, z as UsageTokenTotals } from "./log-C0q5svm7.mjs";
 export { COUNTED_EVENT_TYPES, SESSION_USAGE_PATH, SessionUsageReport, UsageActivityTotals, UsageAggregate, UsageBucket, UsageRangeKey, UsageSessionRow, UsageTokenTotals, UsageTotals, addActivityCount, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey, registerSessionUsage, resolveUsageSince };

package/drizzle/postgres/20261008103001_v3_schedule_tasks/migration.sql

@@ -0,0 +1,11 @@
+-- 见 SQLite 侧同名迁移的说明：官方 `schedule` 域的 `tasks` 表落进本库。
+CREATE TABLE "t_schedule_tasks" (
+	"f_id" text PRIMARY KEY,
+	"f_session_id" text NOT NULL,
+	"f_status" text NOT NULL,
+	"f_record" text NOT NULL,
+	"f_last_delivery" text,
+	"f_delivery_history" text
+);
+--> statement-breakpoint
+CREATE INDEX "idx_schedule_tasks_session_id" ON "t_schedule_tasks" USING btree ("f_session_id");

package/drizzle/sqlite/20261008103000_v3_schedule_tasks/migration.sql

@@ -0,0 +1,14 @@
+-- 官方 `schedule` 域（`dsh-schedule` 的 `tasks` 表）落进本库：web-app 在每份 profile 里挂那一行，
+-- 而 `storage-domain` 的 backend 路由指向 rdb——一个提醒一行，归属会话与状态是列，记录与投递回执存 JSON。
+-- 手写迁移（生成器产不出可用 diff，见 `.agents/debts/20260921-drizzle生成器与实体定义对不上.md`）：
+-- 本文件只含这次的真实改动，没有需要说明的略过段。
+CREATE TABLE `t_schedule_tasks` (
+	`f_id` text PRIMARY KEY,
+	`f_session_id` text NOT NULL,
+	`f_status` text NOT NULL,
+	`f_record` text NOT NULL,
+	`f_last_delivery` text,
+	`f_delivery_history` text
+);
+--> statement-breakpoint
+CREATE INDEX `idx_schedule_tasks_session_id` ON `t_schedule_tasks` (`f_session_id`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/session-rdb",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "RDB durable session backend for DeepSeek Harness: implements both session-persistence and session-branch (rewind / retry / fork) providers.",
   "keywords": [
     "branch",
@@ -25,60 +25,81 @@
   ],
   "type": "module",
   "exports": {
-    ".": "./dist/index.mjs",
-    "./artifact": "./dist/artifact.mjs",
-    "./deletion": "./dist/deletion.mjs",
-    "./export": "./dist/export.mjs",
-    "./gc": "./dist/gc.mjs",
-    "./import": "./dist/import.mjs",
-    "./storage": "./dist/storage.mjs",
-    "./testing": "./dist/testing.mjs",
-    "./usage": "./dist/usage.mjs",
-    "./invariant": "./dist/invariant.mjs",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./artifact": {
+      "types": "./dist/artifact.d.mts",
+      "default": "./dist/artifact.mjs"
+    },
+    "./deletion": {
+      "types": "./dist/deletion.d.mts",
+      "default": "./dist/deletion.mjs"
+    },
+    "./export": {
+      "types": "./dist/export.d.mts",
+      "default": "./dist/export.mjs"
+    },
+    "./gc": {
+      "types": "./dist/gc.d.mts",
+      "default": "./dist/gc.mjs"
+    },
+    "./import": {
+      "types": "./dist/import.d.mts",
+      "default": "./dist/import.mjs"
+    },
+    "./storage": {
+      "types": "./dist/storage.d.mts",
+      "default": "./dist/storage.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.mts",
+      "default": "./dist/testing.mjs"
+    },
+    "./usage": {
+      "types": "./dist/usage.d.mts",
+      "default": "./dist/usage.mjs"
+    },
     "./package.json": "./package.json",
     "./locale/*.json": "./locale/*.json"
   },
   "dependencies": {
-    "@morlay/session-branch": "0.1.5",
+    "@morlay/session-branch": "0.1.7",
     "drizzle-orm": "^1.0.0-rc.5-ab785fc",
     "fflate": "^0.8.2",
     "pg": "^8.23.0"
   },
   "devDependencies": {
-    "@deepseek-ai/cosmokit": "1.8.5",
-    "@deepseek-ai/dsh-compaction": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-projection-cache": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-turn-outline": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-storage": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-storage-domain": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-token-meter": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-workspace": "0.2.0-rc.2",
+    "@deepseek-ai/cosmokit": "^1.8.6",
+    "@deepseek-ai/dsh-agent-loop-testkit": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-compaction": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-turn-outline": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-storage": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-storage-domain": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-token-meter": "^0.2.1-rc.1",
     "@types/pg": "^8.23.1",
     "drizzle-kit": "1.0.0-rc.5-ab785fc"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/cosmokit": "^1.8.5",
-    "@deepseek-ai/dsh-invariants": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-scope": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-session": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-format": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-format-catalog": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-persistence": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-session-query": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-storage": "^0.2.0-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.4"
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/cosmokit": "^1.8.6",
+    "@deepseek-ai/dsh-llm": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-schedule": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-scope": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-format": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-format-catalog": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-projection": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-projection-cache": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session-query": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-storage": "^0.2.1-rc.1",
+    "@deepseek-ai/dsh-workspace": "^0.2.1-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.5"
   },
-  "inlinedDependencies": {
-    "@jridgewell/sourcemap-codec": "1.6.0",
-    "chai": "6.2.2",
-    "expect-type": "1.4.0",
-    "magic-string": "1.4.1",
-    "tinybench": "6.1.4",
-    "vitest": "5.0.0",
-    "zod": "4.6.5"
+  "engines": {
+    "dsh": ">= 0.2.1-rc.1 < 0.2.2"
   },
   "scripts": {
     "build": "pnpm exec tsdown",

package/src/branch.ts

@@ -312,7 +312,7 @@ export class SessionBranchRdbProvider implements SessionBranchProvider {
       throw error;
     }
     // fork 不动统计：继承前缀的消耗是父会话真实发生的那一次，子会话只记自己新产生的
-    // （写路径旁路累加，见 ADR-统计只记真实发生的用量）。
+    // （写路径旁路累加，见 ADR-fork不继承统计）。
     return childId;
   }
 

package/src/entities/v3/index.ts

@@ -7,6 +7,7 @@ import { storageUnits } from "./storage-units.ts";
 import { workspaces } from "./workspaces.ts";
 import { workspaceSessions } from "./workspace-sessions.ts";
 import { workspaceState } from "./workspace-state.ts";
+import { scheduleTasks } from "./schedule-tasks.ts";
 import { sessionProjcacheRows } from "./session-projcache-rows.ts";
 import { eventUsage } from "./event-usage.ts";
 import { sessionUsage } from "./session-usage.ts";
@@ -21,6 +22,7 @@ export { storageUnits };
 export { workspaces };
 export { workspaceSessions };
 export { workspaceState };
+export { scheduleTasks };
 export { sessionProjcacheRows };
 export { eventUsage };
 export { sessionUsage };
@@ -36,6 +38,7 @@ export const sqliteTableDefs = [
   workspaces,
   workspaceSessions,
   workspaceState,
+  scheduleTasks,
   sessionProjcacheRows,
   eventUsage,
   sessionUsage,
@@ -52,6 +55,7 @@ export const postgresTableDefs = [
   workspaces,
   workspaceSessions,
   workspaceState,
+  scheduleTasks,
   sessionProjcacheRows,
   eventUsage,
   sessionUsage,

package/src/entities/v3/schedule-tasks.ts

@@ -0,0 +1,16 @@
+import type { TableDef } from "../../adapters/types.ts";
+
+// 官方 `schedule` 域的 `tasks` 表：一个提醒一行（key = `ScheduleId`）。归属会话与状态是可查的列，
+// 记录本体与投递回执按上游契约原样存 JSON（它们只有上游 `dsh-schedule` 自己消费，拆列没有第二个读法）。
+export const scheduleTasks: TableDef = {
+  name: "t_schedule_tasks",
+  columns: {
+    f_id: { type: "text", primaryKey: true },
+    f_session_id: { type: "text", notNull: true },
+    f_status: { type: "text", notNull: true },
+    f_record: { type: "text", notNull: true },
+    f_last_delivery: { type: "text" },
+    f_delivery_history: { type: "text" },
+  },
+  indexes: { idx_schedule_tasks_session_id: { columns: ["f_session_id"] } },
+};

package/src/index.ts

@@ -1099,7 +1099,8 @@ export class SessionPersistenceRdb extends SessionPersistence {
     }
   }
 
-  // 重算一个会话的两张汇总表（fork 之后；best-effort，同 `recordSessionStats`）。
+  // 重算一个会话的两张汇总表（旧日志重写后；best-effort，同 `recordSessionStats`）——
+  // fork 与 rewind 都不动统计。
   async rebuildSessionStats(id: SessionId): Promise<void> {
     try {
       await this.backend.rebuildSessionStats(id);

package/src/schema.ts

@@ -28,6 +28,8 @@ export const tWorkspaceSessions = sqliteTables["t_workspace_sessions"]!;
 
 export const tWorkspaceState = sqliteTables["t_workspace_state"]!;
 
+export const tScheduleTasks = sqliteTables["t_schedule_tasks"]!;
+
 export const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"]!;
 
 export const tEventUsage = sqliteTables["t_event_usage"]!;

package/src/sqlite.ts

@@ -38,6 +38,7 @@ import {
   tEventUsage,
   tEvents,
   tPersistenceState,
+  tScheduleTasks,
   tSessionEvents,
   tSessionProjcacheRows,
   tSessions,
@@ -430,6 +431,7 @@ export class SqliteBackend implements Backend {
         t_workspaces: tWorkspaces,
         t_workspace_sessions: tWorkspaceSessions,
         t_workspace_state: tWorkspaceState,
+        t_schedule_tasks: tScheduleTasks,
         t_session_projcache_row: tSessionProjcacheRows,
       },
     });
@@ -824,7 +826,8 @@ export class SqliteBackend implements Backend {
   }
 
   // 用量聚合：只读三张派生统计表——事件级用量行给去重口径的总量与「天 × 模型」桶，`t_session_usage` /
-  // `t_session_counts` 给按会话的行（含 fork 继承前缀）；归属、本地日与「是否被引用」都是物化列，不再现算、也不
+  // `t_session_counts` 给按会话的行（**含 fork 继承前缀**，见 ADR-fork不继承统计）；归属、本地日与「是否被引用」
+  // 都是物化列，不再现算、也不
   // 回连事件表。事件级按毫秒过滤、汇总表按本地日过滤，`sinceMs` 对齐本地零点时两者等价。
   async usageReport(sinceMs?: number): Promise<UsageAggregate> {
     const usageSince = sinceMs === undefined ? "" : " AND f_created_at >= ?";
@@ -999,7 +1002,7 @@ export class SqliteBackend implements Backend {
     }
   }
 
-  // 按会话重算两张汇总表（rewind / fork 之后）：先删该会话的行，再从事件表重算。
+  // 按会话重算两张汇总表（旧日志重写后）：先删该会话的行，再从事件表重算——rewind 与 fork 不走这里。
   async rebuildSessionStats(id: SessionId): Promise<void> {
     this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
     this.db.$client

package/src/storage-takeover/repository.ts

@@ -12,6 +12,7 @@ import type {
   CheckpointIdentity,
   ProjectionCheckpoint,
   ProjectionCheckpointRow,
+  ScheduleTask,
   StorageRepository,
   StoredProjcacheEntry,
   WorkspaceDomainState,
@@ -89,6 +90,39 @@ function pendingMutationOf(row: {
   return { operation, workspaceId: (row.fPendingWorkspaceId ?? "") as WorkspaceId };
 }
 
+interface ScheduleTaskRowRecord {
+  fId: string;
+  fSessionId: string;
+  fStatus: string;
+  fRecord: string;
+  fLastDelivery: string | null;
+  fDeliveryHistory: string | null;
+}
+
+// 行的读写映射：形状校验在 KV 那一层做（`storage-backend.ts` 的 `scheduleTaskOf`），这里只按列拆装——
+// 归属会话与状态是列，其余三段保持上游契约的 JSON 原样（读回时 `dsh-schedule` 的域 schema 还会再校验）。
+function taskFromRow(row: ScheduleTaskRowRecord): ScheduleTask {
+  return {
+    sessionId: row.fSessionId as SessionId,
+    record: JSON.parse(row.fRecord),
+    status: row.fStatus === "inactive" ? "inactive" : "active",
+    ...(row.fLastDelivery === null ? {} : { lastDelivery: JSON.parse(row.fLastDelivery) }),
+    ...(row.fDeliveryHistory === null ? {} : { deliveryHistory: JSON.parse(row.fDeliveryHistory) }),
+  } as ScheduleTask;
+}
+
+function rowFromTask(id: string, task: ScheduleTask): ScheduleTaskRowRecord {
+  return {
+    fId: id,
+    fSessionId: task.sessionId,
+    fStatus: task.status === "inactive" ? "inactive" : "active",
+    fRecord: JSON.stringify(task.record),
+    fLastDelivery: task.lastDelivery === undefined ? null : JSON.stringify(task.lastDelivery),
+    fDeliveryHistory:
+      task.deliveryHistory === undefined ? null : JSON.stringify(task.deliveryHistory),
+  };
+}
+
 export function createStorageRepository(host: StorageRepositoryHost): StorageRepository {
   const tables = host.tables as Record<string, any>;
   const tUnits = tables["t_storage_units"]!;
@@ -96,6 +130,7 @@ export function createStorageRepository(host: StorageRepositoryHost): StorageRep
   const tWorkspaces = tables["t_workspaces"]!;
   const tWorkspaceSessions = tables["t_workspace_sessions"]!;
   const tWorkspaceState = tables["t_workspace_state"]!;
+  const tScheduleTasks = tables["t_schedule_tasks"]!;
   const tProjcacheRows = tables["t_session_projcache_row"]!;
 
   const sessionIdentity = {
@@ -338,6 +373,32 @@ export function createStorageRepository(host: StorageRepositoryHost): StorageRep
       });
     },
 
+    async listScheduleTasks(): Promise<Array<{ id: string; task: ScheduleTask }>> {
+      const db = await dbx();
+      const rows = await allRows<ScheduleTaskRowRecord>(db.select().from(tScheduleTasks));
+      return rows.map((row) => ({ id: row.fId, task: taskFromRow(row) }));
+    },
+
+    async putScheduleTask(id: string, task: ScheduleTask): Promise<void> {
+      await host.writeAtomically(async () => {
+        const db = await dbx();
+        const values = rowFromTask(id, task);
+        await runQuery(
+          db
+            .insert(tScheduleTasks)
+            .values(values)
+            .onConflictDoUpdate({ target: tScheduleTasks.fId, set: values }),
+        );
+      });
+    },
+
+    async deleteScheduleTask(id: string): Promise<void> {
+      await host.writeAtomically(async () => {
+        const db = await dbx();
+        await runQuery(db.delete(tScheduleTasks).where(eq(tScheduleTasks.fId, id)));
+      });
+    },
+
     async loadProjcache(): Promise<StoredProjcacheEntry[]> {
       const db = await dbx();
       const rows = await allRows<ProjcacheRowRecord>(db.select().from(tProjcacheRows));

package/src/storage-takeover/storage-backend.ts

@@ -1,36 +1,35 @@
 import { StorageError } from "@deepseek-ai/dsh-storage";
 import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { ScheduleTask } from "@deepseek-ai/dsh-schedule";
 import type { WorkspaceId } from "@deepseek-ai/dsh-workspace";
 import type { KvFacet, KvUnit, KvUnitDescriptor, StorageBackend } from "@deepseek-ai/dsh-storage";
 import type { StorageRepository, WorkspaceRecord, WorkspaceDomainState } from "./types.ts";
 
 export const RDB_STORAGE_BACKEND = "rdb";
 
+// 本后端服务哪些域：一个域一个显式映射（表结构显式维护，未知域名 fail loud——见
+// `.agents/adrs/20260917-接管storages到rdb语义表.md`）。官方那几行谁读哪个域是上游的事，
+// 这里只回答"这个域的数据落在哪张表"。
 const WORKSPACE_UNIT = "workspace";
 const WORKSPACE_TABLE = "workspaces";
+const SCHEDULE_UNIT = "schedule";
+const SCHEDULE_TABLE = "tasks";
+
+// 本后端对 unit 的内部约定：关闭时把域名让回后端（上游 `KvUnit` 没有这个入口，它归"谁能再开一次"这件事）。
+interface ReleasableKvUnit extends KvUnit {
+  onClose(release: () => void): void;
+}
 
 export class RdbStorageBackend implements StorageBackend {
   readonly kv: KvFacet = { open: (descriptor) => this.openUnit(descriptor) };
 
-  private readonly open = new Map<string, WorkspaceKvUnit>();
+  private readonly open = new Map<string, ReleasableKvUnit>();
   private closed = false;
 
   constructor(private readonly repository: StorageRepository) {}
 
   private async openUnit(descriptor: KvUnitDescriptor): Promise<KvUnit> {
     if (this.closed) throw new StorageError("closed", "rdb storage backend is closed");
-    if (descriptor.name !== WORKSPACE_UNIT) {
-      throw new Error(
-        `rdb storage backend serves only the '${WORKSPACE_UNIT}' domain (requested '${descriptor.name}')`,
-      );
-    }
-    if (!descriptor.tables.includes(WORKSPACE_TABLE) || descriptor.hasGlobal !== true) {
-      throw new Error(
-        `rdb storage backend expects the '${WORKSPACE_UNIT}' domain shape ` +
-          `(table '${WORKSPACE_TABLE}' plus a global slot)`,
-      );
-    }
-
     if (descriptor.layout !== undefined && descriptor.layout !== "single") {
       throw new Error(
         `rdb storage backend serves only the 'single' layout (domain '${descriptor.name}' ` +
@@ -41,7 +40,7 @@ export class RdbStorageBackend implements StorageBackend {
       throw new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`);
     }
 
-    const unit = new WorkspaceKvUnit(this.repository, descriptor);
+    const unit = this.unitFor(descriptor);
     this.open.set(descriptor.name, unit);
     try {
       const stored = await this.repository.readUnitVersion(descriptor.name);
@@ -64,6 +63,31 @@ export class RdbStorageBackend implements StorageBackend {
     return unit;
   }
 
+  private unitFor(descriptor: KvUnitDescriptor): ReleasableKvUnit {
+    if (descriptor.name === WORKSPACE_UNIT) {
+      if (!descriptor.tables.includes(WORKSPACE_TABLE) || descriptor.hasGlobal !== true) {
+        throw new Error(
+          `rdb storage backend expects the '${WORKSPACE_UNIT}' domain shape ` +
+            `(table '${WORKSPACE_TABLE}' plus a global slot)`,
+        );
+      }
+      return new WorkspaceKvUnit(this.repository, descriptor);
+    }
+    if (descriptor.name === SCHEDULE_UNIT) {
+      if (!descriptor.tables.includes(SCHEDULE_TABLE) || descriptor.hasGlobal !== false) {
+        throw new Error(
+          `rdb storage backend expects the '${SCHEDULE_UNIT}' domain shape ` +
+            `(table '${SCHEDULE_TABLE}' without a global slot)`,
+        );
+      }
+      return new ScheduleKvUnit(this.repository, descriptor);
+    }
+    throw new Error(
+      `rdb storage backend serves only the '${WORKSPACE_UNIT}' and '${SCHEDULE_UNIT}' domains ` +
+        `(requested '${descriptor.name}')`,
+    );
+  }
+
   async close(): Promise<void> {
     this.closed = true;
     const units = [...this.open.values()];
@@ -72,21 +96,65 @@ export class RdbStorageBackend implements StorageBackend {
   }
 }
 
-class WorkspaceKvUnit implements KvUnit {
+// 一个 KV unit 的公共形态：关闭后拒写、关闭前把已接受的写排干、关闭回调把名字让回给后端。
+// 域自己的读写在子类里（`unitFor` 的返回类型就地校验它们合得上 `KvUnit`）。
+abstract class TrackedKvUnit {
   private closed = false;
 
   private readonly inflight = new Set<Promise<void>>();
+
   private onClosed: (() => void) | undefined;
 
   constructor(
-    private readonly repository: StorageRepository,
-    private readonly descriptor: KvUnitDescriptor,
+    protected readonly repository: StorageRepository,
+    protected readonly descriptor: KvUnitDescriptor,
   ) {}
 
+  // 这个 unit 认的表名（由各自的域决定）。
+  protected abstract readonly tables: readonly string[];
+
   onClose(release: () => void): void {
     this.onClosed = release;
   }
 
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.inflight.size > 0) {
+      await Promise.allSettled(this.inflight);
+    }
+    this.onClosed?.();
+  }
+
+  protected async track(operation: Promise<unknown>): Promise<void> {
+    const settled = operation.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.inflight.add(settled);
+    try {
+      await operation;
+    } finally {
+      this.inflight.delete(settled);
+    }
+  }
+
+  protected assertOpen(): void {
+    if (this.closed) {
+      throw new StorageError("closed", `kv unit '${this.descriptor.name}' is closed`);
+    }
+  }
+
+  protected assertTable(table: string): void {
+    if (!this.tables.includes(table)) {
+      throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
+    }
+  }
+}
+
+class WorkspaceKvUnit extends TrackedKvUnit {
+  protected readonly tables = [WORKSPACE_TABLE];
+
   async loadAll(): Promise<{ tables: Record<string, Record<string, unknown>>; global: unknown }> {
     this.assertOpen();
     const records: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
@@ -113,39 +181,35 @@ class WorkspaceKvUnit implements KvUnit {
     this.assertOpen();
     await this.track(this.repository.writeWorkspaceState(workspaceStateOf(value)));
   }
+}
 
-  async close(): Promise<void> {
-    if (this.closed) return;
-    this.closed = true;
-    while (this.inflight.size > 0) {
-      await Promise.allSettled(this.inflight);
+class ScheduleKvUnit extends TrackedKvUnit {
+  protected readonly tables = [SCHEDULE_TABLE];
+
+  async loadAll(): Promise<{ tables: Record<string, Record<string, unknown>>; global: unknown }> {
+    this.assertOpen();
+    const records: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (const { id, task } of await this.repository.listScheduleTasks()) {
+      records[id] = task;
     }
-    this.onClosed?.();
+    // 这个域没有 global 槽（`scheduleDomain` 不声明）：`null` = "从未写过"，域层不会读它。
+    return { tables: { [SCHEDULE_TABLE]: records }, global: null };
   }
 
-  private async track(operation: Promise<unknown>): Promise<void> {
-    const settled = operation.then(
-      () => undefined,
-      () => undefined,
-    );
-    this.inflight.add(settled);
-    try {
-      await operation;
-    } finally {
-      this.inflight.delete(settled);
-    }
+  async putRecord(table: string, key: string, value: unknown): Promise<void> {
+    this.assertOpen();
+    this.assertTable(table);
+    await this.track(this.repository.putScheduleTask(key, scheduleTaskOf(value)));
   }
 
-  private assertOpen(): void {
-    if (this.closed) {
-      throw new StorageError("closed", `kv unit '${this.descriptor.name}' is closed`);
-    }
+  async deleteRecord(table: string, key: string): Promise<void> {
+    this.assertOpen();
+    this.assertTable(table);
+    await this.track(this.repository.deleteScheduleTask(key));
   }
 
-  private assertTable(table: string): void {
-    if (table !== WORKSPACE_TABLE) {
-      throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
-    }
+  setGlobal(_value: unknown): Promise<void> {
+    throw new Error(`unit '${this.descriptor.name}' declares no global slot`);
   }
 }
 
@@ -191,3 +255,17 @@ function workspaceStateOf(value: unknown): WorkspaceDomainState {
     ...(state.pendingMutation === undefined ? {} : { pendingMutation: state.pendingMutation }),
   };
 }
+
+function scheduleTaskOf(value: unknown): ScheduleTask {
+  const task = value as Partial<ScheduleTask> | null;
+  if (
+    typeof task !== "object" ||
+    task === null ||
+    typeof task.sessionId !== "string" ||
+    typeof task.record !== "object" ||
+    task.record === null
+  ) {
+    throw new TypeError("schedule task does not match the stored shape");
+  }
+  return task as ScheduleTask;
+}

package/src/storage-takeover/types.ts

@@ -1,4 +1,5 @@
 import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { ScheduleTask } from "@deepseek-ai/dsh-schedule";
 import type { CheckpointIdentity } from "@deepseek-ai/dsh-session-projection-cache";
 import type {
   ProjectionCheckpoint,
@@ -10,6 +11,7 @@ export type {
   CheckpointIdentity,
   ProjectionCheckpoint,
   ProjectionCheckpointRow,
+  ScheduleTask,
   WorkspaceDomainState,
   WorkspaceRecord,
 };
@@ -35,6 +37,13 @@ export interface StorageRepository {
 
   writeWorkspaceState(state: WorkspaceDomainState): Promise<void>;
 
+  // 官方 `schedule` 域的 `tasks` 表：一个提醒一行（key 是 `ScheduleId`）。
+  listScheduleTasks(): Promise<Array<{ id: string; task: ScheduleTask }>>;
+
+  putScheduleTask(id: string, task: ScheduleTask): Promise<void>;
+
+  deleteScheduleTask(id: string): Promise<void>;
+
   loadProjcache(): Promise<StoredProjcacheEntry[]>;
 
   // 不经 await、直接读的路径（供同步的 `cachedSnapshot` 消费）；宿主提供不了则缺省。