@deepseek-ai/dsh-schedule 0.1.6-alpha.2 → 0.1.7-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/schedule/schedule/README.md
-README.md: 962c343111849ef20fd085dbe8ba454e57a78f8b
-README.zh.md: 8913bc53d68ad2eb7406f1ce6780d69ec522b956
+README.md: 55a4c86b88ae5a28219fd927930ec68cc780185e
+README.zh.md: 4670803e88b61501a03e9635f6b260948c98610f

package/README.md

@@ -53,7 +53,7 @@ Input that cannot become a reminder — an empty prompt, more than one selector,
 
 ### When reminders fire
 
-Due reminders appear as ordinary follow-up messages after the conversation becomes idle; the agent never interrupts a running turn. An already-live idle agent can claim maintenance and deliver immediately without another resume. One-time reminders fire before any repeating batch, and several repeating reminders due at once arrive together in one message ordered by time. If the session is closed or cold when a reminder comes due, it stays overdue until a future live root agent resumes the session — nothing is sent outside the session. A repeating reminder that missed intervals while the session was away presents only its latest due occurrence, not a backlog. The optional Web catalog shows only active records and is not a delivery receipt; dispatch means the follow-up was queued and recorded, not that the model succeeded or the user read the answer.
+Due reminders appear as ordinary follow-up messages after the conversation becomes idle; the agent never interrupts a running turn. An already-live idle agent can claim maintenance and deliver immediately without another resume. One-time reminders fire before any repeating batch, and several repeating reminders due at once arrive together in one message ordered by time. If the session is closed or cold when a reminder comes due, it stays overdue until a future live root agent resumes the session — nothing is sent outside the session. A repeating reminder that missed intervals while the session was away presents only its latest due occurrence, not a backlog. The optional Web catalog shows only active records and is not a delivery receipt; dispatch means the follow-up was queued and recorded, not that the model succeeded or the user read the answer. Archiving a live session with active reminders is refused until they stop, and choosing to stop them deletes every active reminder; unarchiving does not bring them back.
 
 -----
 
@@ -122,6 +122,8 @@ The owner splits long waits into bounded timer segments and rereads the wall clo
 
 An overdue reminder first checkpoints persistence, then claims the Agent's idle maintenance phase through `runMaintenance()`; if a turn or another maintenance task owns the Agent, the claim is rejected, the record stays active, and the owner retries after `whenIdle()`. A successful maintenance task refolds, samples one decision time, builds the fixed framing, synchronously queues `followup()`, and appends the dispatch before releasing the phase. Dispatch means the follow-up was queued and recorded, not that the model succeeded or the user read the answer. Framing or synchronous follow-up failure writes no dispatch; an append failure faults the owner because the message may already be queued; a barrier rejection leaves dispatch pending for a later ordinary preflight. Agent or plugin disposal cancels timers and stops new work without deleting durable records.
 
+The plugin answers the Workspace registry's archive admission ([seam](../../workspace/workspace/README.md)) for every session it owns a runtime for, from that owner's own fold of the live log — the projection registry is a Client view and is not read here: `workspace/session-activity` reports the active records of the session's own suffix as the `schedule` family, one item per reminder with its prompt as label, and `workspace/session-stop` is a management delete in the [same serialized transaction and barriers](#management-pipeline) as the tool: it awaits `ctx.sessions.flush(session)` before reading the fold, appends the same `delete` change the `schedule_delete` tool records for each active reminder, asks the owner to redrive so its timers clear, then awaits a second barrier after the appends. A failed barrier rejects the stop; the registry logs it and keeps the archive, and the reminders stay for the archived-session `agent/pre-step` gate to block when they fire. The registry writes the archive before it dispatches the stop, so a crash between that write and the delete barrier leaves an archived session whose reminders are still recorded; the next unarchive shows them again, exactly as if the stop had never been requested. A session without a live agent, or a live agent without an owned runtime (published before this plugin loaded, or a runtime that stopped or faulted), reports nothing and has nothing to stop, because nothing of it is armed to fire.
+
 </details>
 
 -----

package/README.zh.md

@@ -53,7 +53,7 @@ dsh web --patch apps/cli/config/examples/schedule/cordis.yml
 
 ### 提醒何时触发
 
-到期提醒会在会话空闲后作为普通 follow-up 消息出现；agent 绝不会中断正在运行的轮次。已经 live 且空闲的 agent 可以认领 maintenance 并立即交付，无需再次恢复。一次性提醒先于任何重复批次触发；同时到期的多条重复提醒会按时间顺序合并为一条消息。如果会话在提醒到期时已关闭或 cold，提醒会保持逾期，直到未来的 live 根 agent 恢复会话——会话之外不会发送任何内容。错过若干间隔的重复提醒只展示最新一个到期发生时点，不展示积压。可选 Web 目录只显示活动记录，并不充当交付回执；dispatch 表示 follow-up 已入队并被记录，不表示模型成功或用户已读取回答。
+到期提醒会在会话空闲后作为普通 follow-up 消息出现；agent 绝不会中断正在运行的轮次。已经 live 且空闲的 agent 可以认领 maintenance 并立即交付，无需再次恢复。一次性提醒先于任何重复批次触发；同时到期的多条重复提醒会按时间顺序合并为一条消息。如果会话在提醒到期时已关闭或 cold，提醒会保持逾期，直到未来的 live 根 agent 恢复会话——会话之外不会发送任何内容。错过若干间隔的重复提醒只展示最新一个到期发生时点，不展示积压。可选 Web 目录只显示活动记录，并不充当交付回执；dispatch 表示 follow-up 已入队并被记录，不表示模型成功或用户已读取回答。归档仍有活动提醒的活会话会被拒绝，直到这些提醒停止；选择停止它们会删除全部活动提醒，取消归档不会把它们带回来。
 
 -----
 
@@ -110,6 +110,7 @@ projection 只携带持久记录。它不持久化或传输 scheduled／overdue
 
 日历规范化是确定性的。夏令时缺口内的本地时间会被拒绝；重叠时选择第一次出现的较早时刻。Schedule 的时间校验不会读取浏览器、Session header 中的时区字段、模型 time-context、连接或进程时区，因此回放永不依赖环境时区状态。
 
+<a id="management-pipeline"></a>
 ### 管理流水线
 
 一条 agent 范围的队列把每项已接纳的管理事务与 live owner 的到期事务从 preflight 到任何 post-append barrier 全程串行化。`schedule_create` 建立检查点、分配永不复用的 id、追加 create 事件，再次建立检查点；被取消的调用方在追加前停止。每次成功的管理 preflight 还会要求 live owner 重新计算，这会在先前的 post-append barrier 返回 `persistence_uncertain` 后恢复所保留的 create 或 delete 批次。
@@ -122,6 +123,8 @@ owner 把长等待拆分为有界的 timer 段，并在每次唤醒后重新读
 
 逾期提醒首先为持久化建立检查点，然后通过 `runMaintenance()` 认领 agent 的 idle maintenance phase；如果某个轮次或另一项 maintenance task 已占用 agent，认领会失败，记录保持活动，owner 在 `whenIdle()` 后重试。获准的 maintenance task 会重新折叠、采样一个决策时点、构造固定 framing、同步将 `followup()` 入队，并在释放 phase 前追加 dispatch。dispatch 表示 follow-up 已入队并被记录，不表示模型成功或用户已读取回答。framing 构造或同步 follow-up 失败不会写入 dispatch；追加失败会使 owner 进入故障状态，因为消息可能已经入队；barrier 拒绝则把 dispatch 留给后续普通 preflight。agent 或插件执行资源释放时取消 timer 并停止新工作，但不删除持久记录。
 
+本插件为每个它拥有 runtime 的会话回答 Workspace 注册表的归档准入（[接缝](../../workspace/workspace/README.zh.md)），答案来自该 owner 对活日志的自有 fold——投影注册表是 Client 视图，这里不读它：`workspace/session-activity` 把会话自身后缀中的活动记录作为 `schedule` 族报告，每条提醒一项、以其 prompt 作名称；`workspace/session-stop` 是与工具处于[同一串行事务与屏障](#management-pipeline)之下的管理删除：先 await `ctx.sessions.flush(session)` 再读取 fold，为每条活动提醒追加与 `schedule_delete` 工具所记录的相同的 `delete` 变更，请求 owner 重新驱动以清除其 timer，然后在追加之后 await 第二道屏障。屏障失败会让该 stop 拒绝；注册表记录日志并保留归档，这些提醒留给已归档会话的 `agent/pre-step` 门禁在触发时拦下。注册表先写入归档再派发 stop，因此在该写入与删除屏障之间崩溃会留下一个提醒仍被记录的已归档会话；下次取消归档时它们会再次出现，与从未请求过 stop 时完全一样。没有活 agent 的会话，或没有归属 runtime 的活 agent（在本插件加载前发布，或其 runtime 已停止、已故障），不报告任何内容也没有可停的东西，因为它没有任何已武装、可触发的提醒。
+
 </details>
 
 -----

package/lib/index.js

@@ -2,6 +2,34 @@ import { z } from "zod";
 import { SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region lib/types/persistence.js
+/** Schedule-owned use of the shared session durability barrier. */
+/** Failure to prove that the current live prefix reached a persistence listener. */
+var SchedulePersistenceError = class extends Error {
+	/**
+	* Construct a contained persistence failure.
+	* @param cause - Rejection returned by the shared barrier, when present.
+	*/
+	constructor(cause) {
+		super("Schedule persistence did not complete.", cause === void 0 ? void 0 : { cause });
+		this.name = "SchedulePersistenceError";
+	}
+};
+/**
+* Require one successful shared persistence checkpoint.
+* @param ctx - Context carrying the live session store.
+* @param session - Exact live session to checkpoint.
+* @returns After at least one listener explicitly acknowledges completed durability work.
+*/
+async function flushSchedulePersistence(ctx, session) {
+	try {
+		if (!await ctx.sessions.flush(session)) throw new SchedulePersistenceError();
+	} catch (error) {
+		if (error instanceof SchedulePersistenceError) throw error;
+		throw new SchedulePersistenceError(error);
+	}
+}
+//#endregion
 //#region lib/types/domain.js
 /**
 * Strict Schedule decoding, replay, time validation, and framing.
@@ -670,34 +698,6 @@ const scheduleProjectionDefinition = {
 	stateVersion: 2
 };
 //#endregion
-//#region lib/types/persistence.js
-/** Schedule-owned use of the shared session durability barrier. */
-/** Failure to prove that the current live prefix reached a persistence listener. */
-var SchedulePersistenceError = class extends Error {
-	/**
-	* Construct a contained persistence failure.
-	* @param cause - Rejection returned by the shared barrier, when present.
-	*/
-	constructor(cause) {
-		super("Schedule persistence did not complete.", cause === void 0 ? void 0 : { cause });
-		this.name = "SchedulePersistenceError";
-	}
-};
-/**
-* Require one successful shared persistence checkpoint.
-* @param ctx - Context carrying the live session store.
-* @param session - Exact live session to checkpoint.
-* @returns After at least one listener explicitly acknowledges completed durability work.
-*/
-async function flushSchedulePersistence(ctx, session) {
-	try {
-		if (!await ctx.sessions.flush(session)) throw new SchedulePersistenceError();
-	} catch (error) {
-		if (error instanceof SchedulePersistenceError) throw error;
-		throw new SchedulePersistenceError(error);
-	}
-}
-//#endregion
 //#region lib/types/transaction.js
 /** Agent-scoped serialization for Schedule reads and durable mutations. */
 const tails = /* @__PURE__ */ new WeakMap();
@@ -784,6 +784,15 @@ var ScheduleRuntime = class {
 	start() {
 		this.requestDrive();
 	}
+	/**
+	* Active records of the exact runtime suffix, folded from the live log the
+	* way every drive folds it: the owner answers for what its timers can fire.
+	* @returns the active records in create order, or nothing while this runtime is stopping, faulted, or reading a corrupt stream.
+	*/
+	activeRecords() {
+		if (this.stopping || this.faulted) return void 0;
+		return this.readFolded()?.active;
+	}
 	/** Recompute the live projection after a committed mutation or idle transition. */
 	requestDrive() {
 		if (this.stopping || this.faulted) return;
@@ -926,10 +935,7 @@ var ScheduleRuntime = class {
 							type: "text",
 							text: decision.kind === "one-shot" ? renderReminderFraming(decision.record) : renderEveryReminderBatchFraming(decision.reminders)
 						}],
-						source: {
-							kind: "plugin",
-							plugin: "schedule"
-						}
+						source: { kind: "schedule" }
 					});
 					this.agent.followup(message);
 				} catch (error) {
@@ -1447,13 +1453,71 @@ const inject = [
 	"tools",
 	"sessionPersistence"
 ];
-/** Install Schedule only for root agents published after this plugin loads. */
+/**
+* Install Schedule only for root agents published after this plugin loads,
+* and answer the Workspace registry's archive admission for every session
+* this plugin owns a runtime for. The owner answers from its own fold of the
+* live log, so a session without a live agent or without an owned runtime
+* — nothing armed that could fire — reports nothing and has nothing to stop.
+* Active reminders count as activity. A stop request is a management delete
+* in the agent's transaction queue, serialized with the tools and the
+* owner's due transaction: it awaits the shared persistence barrier before
+* reading the fold, appends the same durable `schedule/change` delete the
+* `schedule_delete` tool records for every active reminder, and awaits a
+* second barrier after the appends. A failed barrier rejects the stop, which
+* the registry logs, leaving the reminders for the archived-session gate to
+* block when they fire.
+*/
 function apply(ctx) {
 	ctx.inject(["sessionProjections"], (projectionCtx) => {
 		projectionCtx.sessionProjections.register(scheduleProjectionDefinition);
 	});
 	const runtimes = /* @__PURE__ */ new Map();
 	let stopping = false;
+	/** The owned runtime's active records for a session id; none without a live agent or an owned runtime. */
+	const activeReminders = (sessionId) => {
+		const agent = ctx.agents.get(sessionId);
+		const active = agent === void 0 ? void 0 : runtimes.get(agent)?.runtime.activeRecords();
+		return agent === void 0 || active === void 0 ? void 0 : {
+			agent,
+			active
+		};
+	};
+	ctx.effect(() => {
+		const stopActivity = ctx.on("workspace/session-activity", async ({ sessionId }, next) => {
+			const reminders = activeReminders(sessionId);
+			const rest = await next();
+			if (reminders === void 0 || reminders.active.length === 0) return rest;
+			return [{
+				kind: "schedule",
+				items: reminders.active.map((record) => ({
+					id: record.id,
+					label: record.prompt
+				}))
+			}, ...rest];
+		});
+		const stopStop = ctx.on("workspace/session-stop", async ({ sessionId }) => {
+			const owned = activeReminders(sessionId);
+			if (owned === void 0) return;
+			const { agent } = owned;
+			await runScheduleTransaction(agent, async () => {
+				await flushSchedulePersistence(ctx, agent.session);
+				const active = activeReminders(sessionId)?.active ?? [];
+				if (active.length === 0) return;
+				for (const record of active) agent.session.append("schedule/change", {
+					version: 1,
+					operation: "delete",
+					id: record.id
+				});
+				runtimes.get(agent)?.runtime.requestDrive();
+				await flushSchedulePersistence(ctx, agent.session);
+			});
+		});
+		return () => {
+			stopStop();
+			stopActivity();
+		};
+	}, "schedule.archiveAdmission()");
 	ctx.effect(() => {
 		const stopCreated = ctx.on("agent/created", ({ agent }) => {
 			if (stopping || runtimes.has(agent) || !ctx.agents.roots().includes(agent)) return;
@@ -1472,18 +1536,21 @@ function apply(ctx) {
 					try {
 						await runtime.dispose();
 					} finally {
-						if (runtimes.get(agent) === cleanup) runtimes.delete(agent);
+						if (runtimes.get(agent)?.cleanup === cleanup) runtimes.delete(agent);
 					}
 				};
 			}, "schedule.runtime()");
-			runtimes.set(agent, cleanup);
+			runtimes.set(agent, {
+				runtime,
+				cleanup
+			});
 		});
 		return async () => {
 			stopping = true;
 			stopCreated();
-			const cleanups = [...runtimes.values()];
+			const owned = [...runtimes.values()];
 			runtimes.clear();
-			await Promise.allSettled(cleanups.map((cleanup) => Promise.resolve(cleanup())));
+			await Promise.allSettled(owned.map(({ cleanup }) => Promise.resolve(cleanup())));
 		};
 	}, "schedule.lifecycle()");
 }

package/lib/types/index.d.ts

@@ -10,6 +10,20 @@ export { registerScheduleTools } from './tools.ts';
 export declare const name = "schedule";
 /** Services required before future root agents can receive Schedule. */
 export declare const inject: string[];
-/** Install Schedule only for root agents published after this plugin loads. */
+/**
+ * Install Schedule only for root agents published after this plugin loads,
+ * and answer the Workspace registry's archive admission for every session
+ * this plugin owns a runtime for. The owner answers from its own fold of the
+ * live log, so a session without a live agent or without an owned runtime
+ * — nothing armed that could fire — reports nothing and has nothing to stop.
+ * Active reminders count as activity. A stop request is a management delete
+ * in the agent's transaction queue, serialized with the tools and the
+ * owner's due transaction: it awaits the shared persistence barrier before
+ * reading the fold, appends the same durable `schedule/change` delete the
+ * `schedule_delete` tool records for every active reminder, and awaits a
+ * second barrier after the appends. A failed barrier rejects the stop, which
+ * the registry logs, leaving the reminders for the archived-session gate to
+ * block when they fire.
+ */
 export declare function apply(ctx: Context): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -2,22 +2,78 @@
  * Agent-scoped durable one-shot and fixed-rate reminders over the session event log.
  * @module @deepseek-ai/dsh-schedule
  */
+import { flushSchedulePersistence } from "./persistence.js";
 import { scheduleProjectionDefinition } from "./projection.js";
 import { ScheduleRuntime } from "./runtime.js";
 import { registerScheduleTools } from "./tools.js";
+import { runScheduleTransaction } from "./transaction.js";
 export { SCHEDULE_CHANGE_VERSION, MIN_EVERY_INTERVAL_SECONDS, ScheduleId, ScheduleInputError, ScheduleLogError, allocateScheduleId, createAfterScheduleRecord, createAtScheduleRecord, createEveryScheduleRecord, decodeScheduleChange, foldScheduleEvents, renderReminderFraming, renderEveryReminderBatchFraming, resolveEveryOccurrence, scheduleView, } from "./domain.js";
 export { registerScheduleTools } from "./tools.js";
 /** Cordis function-plugin name. */
 export const name = 'schedule';
 /** Services required before future root agents can receive Schedule. */
 export const inject = ['agents', 'sessions', 'tools', 'sessionPersistence'];
-/** Install Schedule only for root agents published after this plugin loads. */
+/**
+ * Install Schedule only for root agents published after this plugin loads,
+ * and answer the Workspace registry's archive admission for every session
+ * this plugin owns a runtime for. The owner answers from its own fold of the
+ * live log, so a session without a live agent or without an owned runtime
+ * — nothing armed that could fire — reports nothing and has nothing to stop.
+ * Active reminders count as activity. A stop request is a management delete
+ * in the agent's transaction queue, serialized with the tools and the
+ * owner's due transaction: it awaits the shared persistence barrier before
+ * reading the fold, appends the same durable `schedule/change` delete the
+ * `schedule_delete` tool records for every active reminder, and awaits a
+ * second barrier after the appends. A failed barrier rejects the stop, which
+ * the registry logs, leaving the reminders for the archived-session gate to
+ * block when they fire.
+ */
 export function apply(ctx) {
     ctx.inject(['sessionProjections'], (projectionCtx) => {
         projectionCtx.sessionProjections.register(scheduleProjectionDefinition);
     });
     const runtimes = new Map();
     let stopping = false;
+    /** The owned runtime's active records for a session id; none without a live agent or an owned runtime. */
+    const activeReminders = (sessionId) => {
+        const agent = ctx.agents.get(sessionId);
+        const active = agent === undefined ? undefined : runtimes.get(agent)?.runtime.activeRecords();
+        return agent === undefined || active === undefined ? undefined : { agent, active };
+    };
+    ctx.effect(() => {
+        const stopActivity = ctx.on('workspace/session-activity', async ({ sessionId }, next) => {
+            const reminders = activeReminders(sessionId);
+            const rest = await next();
+            if (reminders === undefined || reminders.active.length === 0)
+                return rest;
+            const own = {
+                kind: 'schedule',
+                items: reminders.active.map(record => ({ id: record.id, label: record.prompt })),
+            };
+            return [own, ...rest];
+        });
+        const stopStop = ctx.on('workspace/session-stop', async ({ sessionId }) => {
+            const owned = activeReminders(sessionId);
+            if (owned === undefined)
+                return;
+            const { agent } = owned;
+            await runScheduleTransaction(agent, async () => {
+                await flushSchedulePersistence(ctx, agent.session);
+                const active = activeReminders(sessionId)?.active ?? [];
+                if (active.length === 0)
+                    return;
+                for (const record of active) {
+                    agent.session.append('schedule/change', { version: 1, operation: 'delete', id: record.id });
+                }
+                runtimes.get(agent)?.runtime.requestDrive();
+                await flushSchedulePersistence(ctx, agent.session);
+            });
+        });
+        return () => {
+            stopStop();
+            stopActivity();
+        };
+    }, 'schedule.archiveAdmission()');
     ctx.effect(() => {
         const stopCreated = ctx.on('agent/created', ({ agent }) => {
             if (stopping || runtimes.has(agent) || !ctx.agents.roots().includes(agent))
@@ -39,19 +95,19 @@ export function apply(ctx) {
                         await runtime.dispose();
                     }
                     finally {
-                        if (runtimes.get(agent) === cleanup)
+                        if (runtimes.get(agent)?.cleanup === cleanup)
                             runtimes.delete(agent);
                     }
                 };
             }, 'schedule.runtime()');
-            runtimes.set(agent, cleanup);
+            runtimes.set(agent, { runtime, cleanup });
         });
         return async () => {
             stopping = true;
             stopCreated();
-            const cleanups = [...runtimes.values()];
+            const owned = [...runtimes.values()];
             runtimes.clear();
-            await Promise.allSettled(cleanups.map(cleanup => Promise.resolve(cleanup())));
+            await Promise.allSettled(owned.map(({ cleanup }) => Promise.resolve(cleanup())));
         };
     }, 'schedule.lifecycle()');
 }

package/lib/types/runtime.d.ts

@@ -4,6 +4,15 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ContextFormed } from '@deepseek-ai/dsh-llm';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'schedule': {
+            kind: 'schedule';
+        } & ContextFormed;
+    }
+}
+import type { ScheduleRecord } from './types.ts';
 /** Largest delay that Node timers represent without clamping. */
 export declare const MAX_TIMER_DELAY_MS = 2147483647;
 /** One process-local, disposable projection of an exact agent's durable schedules. */
@@ -26,6 +35,12 @@ export declare class ScheduleRuntime {
     constructor(ctx: Context, agent: Agent);
     /** Begin the initial durability preflight and timer derivation. */
     start(): void;
+    /**
+     * Active records of the exact runtime suffix, folded from the live log the
+     * way every drive folds it: the owner answers for what its timers can fire.
+     * @returns the active records in create order, or nothing while this runtime is stopping, faulted, or reading a corrupt stream.
+     */
+    activeRecords(): readonly ScheduleRecord[] | undefined;
     /** Recompute the live projection after a committed mutation or idle transition. */
     requestDrive(): void;
     /** Stop future work, cancel timers, and await every outstanding runtime promise. */

package/lib/types/runtime.js

@@ -66,6 +66,16 @@ export class ScheduleRuntime {
     start() {
         this.requestDrive();
     }
+    /**
+     * Active records of the exact runtime suffix, folded from the live log the
+     * way every drive folds it: the owner answers for what its timers can fire.
+     * @returns the active records in create order, or nothing while this runtime is stopping, faulted, or reading a corrupt stream.
+     */
+    activeRecords() {
+        if (this.stopping || this.faulted)
+            return undefined;
+        return this.readFolded()?.active;
+    }
     /** Recompute the live projection after a committed mutation or idle transition. */
     requestDrive() {
         if (this.stopping || this.faulted)
@@ -235,7 +245,7 @@ export class ScheduleRuntime {
                         : renderEveryReminderBatchFraming(decision.reminders);
                     const message = createUserMessage({
                         content: [{ type: 'text', text }],
-                        source: { kind: 'plugin', plugin: 'schedule' },
+                        source: { kind: 'schedule' },
                     });
                     this.agent.followup(message);
                 }

package/lib/types/types.d.ts

@@ -169,6 +169,12 @@ export type ScheduleDeleteResult = {
 };
 /** Canonical `schedule_delete` value. */
 export type ScheduleDeleteValue = ScheduleDeleteResult | ScheduleToolError;
+declare module '@deepseek-ai/dsh-workspace/types' {
+    interface SessionActivityKindMap {
+        /** A scheduled follow-up for this session is still active. */
+        schedule: true;
+    }
+}
 declare module '@deepseek-ai/dsh-session/types' {
     interface SessionEventMap {
         /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-schedule",
   "description": "Agent-scoped durable after, at, and fixed-rate reminders over the session event log",
-  "version": "0.1.6-alpha.2",
+  "version": "0.1.7-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -37,33 +37,35 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-brand": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-agent": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-llm": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session-projection": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-tools": "^0.1.6-alpha.2",
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-invariants": "^0.1.6-alpha.2"
+    "@deepseek-ai/dsh-invariants": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-llm": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session-projection": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-tools": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-workspace": "^0.1.7-alpha.1",
+    "@deepseek-ai/cordis": "^4.0.3",
+    "@deepseek-ai/dsh-brand": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-agent": "^0.1.7-alpha.1"
   },
   "dependencies": {
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.3",
-    "@deepseek-ai/dsh-agent": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-agent-loop": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-agent-loop-testkit": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-brand": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-invariants": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-llm": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-session-projection": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.6-alpha.2",
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-tools": "^0.1.6-alpha.2"
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.4",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-brand": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-agent-loop-testkit": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-llm": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-session-projection": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-tools": "^0.1.7-alpha.1",
+    "@deepseek-ai/cordis": "^4.0.3",
+    "@deepseek-ai/dsh-workspace": "^0.1.7-alpha.1",
+    "@deepseek-ai/dsh-agent": "^0.1.7-alpha.1"
   }
 }