dsh-later 1.0.0 → 1.2.0

package/lib/types/user-tools.d.ts

@@ -19,9 +19,9 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
-import { foldScheduleEvents } from '@deepseek-ai/dsh-schedule';
 import type { ScheduleRecord, ScheduleView } from '@deepseek-ai/dsh-schedule';
 import type { UserScheduleDelivery } from './domain.js';
+import type { PausedEntry } from './ownership-store.js';
 /** 单 session 用户任务上限（PRD：防滥用）。 */
 export declare const DEFAULT_MAX_SCHEDULES = 100;
 /**
@@ -53,7 +53,7 @@ export declare function validatePrompt(raw: unknown, limits: PromptLimits): {
     value: string;
 } | UserScheduleError;
 /** 用户工具稳定的闭包错误集合（在 dsh-schedule 闭包之上追加本插件专用码）。 */
-export type UserScheduleErrorCode = 'invalid_prompt' | 'invalid_selector' | 'invalid_time_zone' | 'not_future' | 'time_out_of_range' | 'frequency_too_high' | 'invalid_rule' | 'schedule_not_found' | 'already_overdue' | 'quota_exceeded' | 'persistence_uncertain' | 'internal_error';
+export type UserScheduleErrorCode = 'invalid_prompt' | 'invalid_selector' | 'invalid_time_zone' | 'not_future' | 'time_out_of_range' | 'frequency_too_high' | 'invalid_rule' | 'schedule_not_found' | 'already_overdue' | 'quota_exceeded' | 'persistence_uncertain' | 'unsupported_kind' | 'not_paused' | 'internal_error';
 /** 封闭错误值。 */
 export interface UserScheduleError {
     readonly ok: false;
@@ -82,6 +82,21 @@ export type UserScheduleDeleteResult = UserScheduleResult<{
     readonly deleted: false;
     readonly code: 'schedule_not_found';
 }>;
+/** `user_schedule_pause` 成功响应（仅 after）。 */
+export type UserSchedulePauseResult = UserScheduleResult<{
+    readonly ok: true;
+    readonly uid: string;
+    readonly schedule_id: string;
+    readonly remaining_seconds: number;
+    readonly scheduled_at: string;
+}>;
+/** `user_schedule_resume` 成功响应：新 scheduleId + 原 uid。 */
+export type UserScheduleResumeResult = UserScheduleResult<{
+    readonly ok: true;
+    readonly uid: string;
+    readonly schedule_id: string;
+    readonly remaining_seconds: number;
+}>;
 /** `user_schedule_create` 的规范化输入。 */
 export interface UserScheduleCreateInput {
     readonly prompt: string;
@@ -121,15 +136,30 @@ export declare function foldOwnedDelivery(events: readonly SessionEvent[]): Read
  * 消除热路径（每次 drive / 每次工具调用）对全量日志的重复 O(n) 扫描。
  */
 export interface UserFoldState {
-    readonly folded: ReturnType<typeof foldScheduleEvents>;
+    /**
+     * `foldScheduleEvents` 的结果，按**本插件的读视图**收窄。
+     *
+     * 0.1.5 返回 `ScheduleRecord`；0.1.7 返回 `LegacyScheduleRecord`
+     * （`title` 可选，因为 title 成为必填前写入的历史事件没有该字段），
+     * 且 `ScheduleRecord` 联合新增了 daily/weekly/cron 三个本插件不产生的变体。
+     *
+     * 收窄到 `Legacy*` 视图对读路径是**语义正确**的：本插件只创建
+     * after/at/every，title 缺失时投影回退到 prompt（见 projection.ts）。
+     * 统一在此收口，避免每个消费点各写一次断言。
+     */
+    readonly folded: FoldedUserSchedules;
     readonly owned: ReadonlySet<string>;
     readonly delivery: ReadonlyMap<string, UserScheduleDelivery>;
 }
+/** fold 结果中本插件关心的字段面（`active` 按 Legacy 视图收窄）。 */
+export interface FoldedUserSchedules {
+    readonly active: readonly ScheduleRecord[];
+    readonly seenIds: ReadonlySet<string>;
+}
 /** fold 当前会话的完整用户调度状态（带缓存；调用方不得变更返回值）。
  *
- * 跨代兼容：0.1.1 暴露 `session.events` + `header.seedLength`；0.1.2 改名
- * 为 `session.ownEvents()` + `session.inheritedEventCount`。通过鸭子类型
- * （`(session as { ownEvents?; events? })`）双轨探测，不引入 `any`。
+ * 跨代 Session API 探测已收敛到 `upstream-compat.ts`（readOwnEvents /
+ * readInheritedEventCount）——新 rc 若再改名只动那一处。
  */
 export declare function foldUserState(session: Session): UserFoldState;
 /** 稳定内部错误（不透出异常细节）。 */
@@ -170,7 +200,18 @@ export interface UserScheduleCreateOptions {
 export declare function userScheduleCreate(input: unknown, agent: Agent, ctx: Context, maxSchedules?: number, options?: UserScheduleCreateOptions, limits?: PromptLimits): Promise<UserScheduleCreateResult>;
 /** `user_schedule_list` 核心实现。 */
 export declare function userScheduleList(agent: Agent, ctx: Context): Promise<UserScheduleListResult>;
-/** `user_schedule_delete` 核心实现。 */
+/** `user_schedule_delete` 核心实现。id 可为 scheduleId 或稳定 uid。 */
 export declare function userScheduleDelete(id: unknown, agent: Agent, ctx: Context): Promise<UserScheduleDeleteResult>;
 /** `user_schedule_edit`（改内容）核心实现：删旧建新，保留原时刻与 delivery。 */
 export declare function userScheduleEditPrompt(id: unknown, newPrompt: unknown, agent: Agent, ctx: Context, limits?: PromptLimits): Promise<UserScheduleCreateResult | UserScheduleError>;
+/**
+ * 暂停一条 **after** 提醒（方案 B）：sidecar 留档 + 日志 delete。
+ * 仅 kind==='after' 且未到点；恢复见 {@link userScheduleResume}。
+ */
+export declare function userSchedulePause(id: unknown, agent: Agent, ctx: Context): Promise<UserSchedulePauseResult>;
+/** 恢复一条暂停中的 after 提醒：`after_seconds = remaining` 重建；uid 不变。 */
+export declare function userScheduleResume(uid: unknown, agent: Agent, ctx: Context, maxSchedules?: number): Promise<UserScheduleResumeResult>;
+/** 测试/投影辅助：某会话全部暂停留档。 */
+export declare function listPausedForSession(sessionId: string): Readonly<Record<string, PausedEntry>>;
+/** 测试辅助：按 pause 前 schedule id 查留档。 */
+export declare function findPausedEntry(sessionId: string, scheduleId: string): PausedEntry | undefined;

package/lib/upstream-compat.js

@@ -0,0 +1,143 @@
+/**
+ * 已验证的内核代次（peer 枚举的唯一事实来源）。
+ *
+ * - `id`：semver 精确版本（发布 tag）
+ * - `peerRange`：写入 package.json 的范围（node-semver 预发布需显式枚举）
+ * - `sessionApi`：Session 读日志的形状（见 readOwnEvents / readInheritedEventCount）
+ */
+export const KERNEL_GENERATIONS = [
+    {
+        id: '0.1.1-rc.2',
+        peerRange: '^0.1.1-rc.2',
+        sessionApi: 'legacy-events',
+    },
+    {
+        id: '0.1.2-rc.1',
+        peerRange: '^0.1.2-rc.1',
+        sessionApi: 'own-events',
+    },
+    {
+        /**
+         * `0.1.5` 代次：Session 形状未变（仍 `ownEvents()` + `inheritedEventCount`），
+         * 且插件依赖的 `dsh-schedule` 导出面完整 —— 实测 `rc.1/rc.2/rc.3` 逐个
+         * `import()` 全部 15 个 host 模块均通过（见 docs/verification.md）。
+         */
+        id: '0.1.5-rc.1',
+        peerRange: '^0.1.5-rc.1',
+        sessionApi: 'own-events',
+    },
+    {
+        /**
+         * `0.1.7` 代次：Session 形状仍未变（`ownEvents()` + `inheritedEventCount`）；
+         * `dsh-schedule` 的三处破坏性变更（`allocateScheduleId` 删除、
+         * `renderEveryReminderBatchFraming` 改名 `renderRecurringReminderBatchFraming`、
+         * `createAfterScheduleRecord` 新增必填 `title`）**全部收敛在
+         * `schedule-compat.ts`**——调用点 `user-tools.ts` / `runtime.ts` 不含版本分支。
+         *
+         * 三条差异在 bridge 里按「存在性择一」（framing）或「统一用新语义」
+         * （UUID id、title 派生）处理，两代行为一致，故可安全同时声明这两个范围。
+         *
+         * 不单列 0.1.6-alpha.*：alpha 线无独立兼容面，且 0.1.7 已覆盖其功能面。
+         */
+        id: '0.1.7-rc.2',
+        peerRange: '^0.1.7-rc.2',
+        sessionApi: 'own-events',
+    },
+    {
+        /**
+         * `0.2.0` 代次：内核跨了次版本号（0.1 → 0.2），但本插件依赖的 API 面
+         * **全部保持**。逐项核对（见 docs/verification.md「0.2.0 兼容核对」）：
+         *
+         * - Session：形状未变（`ownEvents()` + `inheritedEventCount`）
+         * - dsh-schedule：0.1.7 的三处破坏性变更即为 0.2.0 现状；`foldScheduleEvents`
+         *   / `renderReminderFraming` / `resolveEveryOccurrence` / `decodeScheduleChange`
+         *   / `scheduleView` / `ScheduleId` 导出面完整，且
+         *   `renderRecurringReminderBatchFraming` 仍在 —— `schedule-compat.ts` 无需改动
+         * - dsh-llm：`createUserMessage` / `boundContextSummary` 仍在；`MessageSourceMap`
+         *   已无 `plugin` kind，仅剩 user/model/tool/system-prompt，而 dsh-schedule
+         *   声明的 `schedule` kind 经 module augmentation 并入 —— 0.1.7 分支继续适用
+         * - dsh-agent：`followup()`（next-turn）与 `steer()`（next-step）语义未变
+         * - dsh-tools：`defineTool` 仍在
+         *
+         * 实证：以 0.2.0-rc.2 类型面对 `src/**`（host 端）跑 `tsc --noEmit` **零错误**，
+         * 且本地 183 项测试全绿。
+         *
+         * 附带影响：0.2.0 内核开始**强制**校验本范围（peer 不满足即整插件不加载，
+         * 此前只是警告）。故这一代次的缺失曾让插件在 0.2.0 上完全失效。
+         */
+        id: '0.2.0-rc.2',
+        peerRange: '^0.2.0-rc.2',
+        sessionApi: 'own-events',
+    },
+];
+/**
+ * 随内核代次一起 bump 的 peer 包（宿主 hoisting 变化会波及这些运行时 import）。
+ * cordis / schemastery 等独立 semver 包**不**列入——它们不随内核 rc 枚举。
+ */
+export const KERNEL_SCOPED_PACKAGES = [
+    '@deepseek-ai/dsh-agent',
+    '@deepseek-ai/dsh-commands',
+    '@deepseek-ai/dsh-llm',
+    '@deepseek-ai/dsh-schedule',
+    '@deepseek-ai/dsh-session',
+    '@deepseek-ai/dsh-session-projection',
+    '@deepseek-ai/dsh-settings',
+    '@deepseek-ai/dsh-tools',
+];
+/** dsh-commands 在 0.1.1 之前还有一代 rc.0，peer 需额外并上。 */
+const EXTRA_PEER_RANGES = {
+    '@deepseek-ai/dsh-commands': ['^0.0.1-rc.1'],
+};
+/** 由 KERNEL_GENERATIONS 拼出的 peer 范围串（`a || b`）。 */
+export function peerRangeFor(packageName) {
+    const extras = EXTRA_PEER_RANGES[packageName] ?? [];
+    return [...extras, ...KERNEL_GENERATIONS.map((g) => g.peerRange)].join(' || ');
+}
+/** 全部需逐代枚举的 `{ package, range }`（sync-peer-matrix / 矩阵测试共用）。 */
+export function peerMatrixEntries() {
+    return KERNEL_SCOPED_PACKAGES.map((packageName) => ({
+        packageName,
+        range: peerRangeFor(packageName),
+    }));
+}
+/**
+ * 读取「本会话自有」事件日志（不含 fork 继承前缀时由调用方配合 offset）。
+ *
+ * - 0.1.2+：`session.ownEvents()`（推荐；仅 live 段）
+ * - 0.1.1：`session.events`（含 seed；配合 seedLength 切片）
+ */
+export function readOwnEvents(session) {
+    const surface = session;
+    if (typeof surface.ownEvents === 'function') {
+        return surface.ownEvents();
+    }
+    return surface.events ?? [];
+}
+/**
+ * 读取「fork 继承前缀长度」——`foldScheduleEvents` 第二参数。
+ *
+ * - 0.1.2+：`session.inheritedEventCount`（SessionLogOffset 品牌数字，运行时仍是 number）
+ * - 0.1.1：`session.header.seedLength`（等价物；此前实现漏了这条回退）
+ * - 均缺失：0（新建会话 / 测试假 Session）
+ *
+ * 统一以裸 `number` 返回：cache key 可用 `===`；传入 foldScheduleEvents 时
+ * 0.1.2 的 brandshape 校验接受 safe integer。
+ */
+export function readInheritedEventCount(session) {
+    const surface = session;
+    const modern = surface.inheritedEventCount;
+    if (typeof modern === 'number' && Number.isSafeInteger(modern) && modern >= 0) {
+        return modern;
+    }
+    const seed = surface.header?.seedLength;
+    if (typeof seed === 'number' && Number.isSafeInteger(seed) && seed >= 0) {
+        return seed;
+    }
+    return 0;
+}
+/** 探测到的 sessionApi 代次（诊断 / 测试用；不参与业务分支）。 */
+export function detectSessionApi(session) {
+    return typeof session.ownEvents === 'function'
+        ? 'own-events'
+        : 'legacy-events';
+}

package/lib/user-tools.js

@@ -1,7 +1,9 @@
-import { ScheduleId, ScheduleInputError, allocateScheduleId, createAfterScheduleRecord, createAtScheduleRecord, createEveryScheduleRecord, foldScheduleEvents, scheduleView, } from '@deepseek-ai/dsh-schedule';
+import { ScheduleId, ScheduleInputError, foldScheduleEvents, scheduleView, } from '@deepseek-ai/dsh-schedule';
+import { allocateScheduleIdCompat as allocateScheduleId, createAfterRecord as createAfterScheduleRecord, createAtRecord as createAtScheduleRecord, createEveryRecord as createEveryScheduleRecord, toChangePayload, asLegacySchedules, } from './schedule-compat.js';
 import { OWNED_EVENT } from './domain.js';
-import { allOwnership, getOwnership, recordOwnership, removeOwnership } from './ownership-store.js';
+import { allOwnership, allPaused, findPausedByScheduleId, findScheduleIdByUid, getOwnership, getPaused, newTaskUid, recordOwnership, recordPaused, removeOwnership, removePaused, } from './ownership-store.js';
 import { detectTimeZone } from './time-utils.js';
+import { readInheritedEventCount, readOwnEvents } from './upstream-compat.js';
 /** 单 session 用户任务上限（PRD：防滥用）。 */
 export const DEFAULT_MAX_SCHEDULES = 100;
 /**
@@ -153,18 +155,12 @@ export function foldOwnedDelivery(events) {
 const foldCache = new WeakMap();
 /** fold 当前会话的完整用户调度状态（带缓存；调用方不得变更返回值）。
  *
- * 跨代兼容：0.1.1 暴露 `session.events` + `header.seedLength`；0.1.2 改名
- * 为 `session.ownEvents()` + `session.inheritedEventCount`。通过鸭子类型
- * （`(session as { ownEvents?; events? })`）双轨探测，不引入 `any`。
+ * 跨代 Session API 探测已收敛到 `upstream-compat.ts`（readOwnEvents /
+ * readInheritedEventCount）——新 rc 若再改名只动那一处。
  */
 export function foldUserState(session) {
-    const sessAny = session;
-    const events = sessAny.ownEvents !== undefined ? sessAny.ownEvents() : sessAny.events ?? [];
-    // 0.1.2 上 Session.inheritedEventCount 是 SessionLogOffset（BrandedNumber），
-    // foldScheduleEvents 第二个参数需要它；0.1.1 上等价于 header.seedLength（number）。
-    // 接受任意 number，统一以 number 形式进入 cache key；foldScheduleEvents 内部会
-    // 自适应（要么收 number、要么要求 branded——后者 0.1.1 路径不会触达）。
-    const inheritedEventCount = session.inheritedEventCount ?? 0;
+    const events = readOwnEvents(session);
+    const inheritedEventCount = readInheritedEventCount(session);
     const cached = foldCache.get(session);
     if (cached !== undefined &&
         cached.events === events &&
@@ -172,11 +168,9 @@ export function foldUserState(session) {
         cached.inheritedEventCount === inheritedEventCount) {
         return cached.state;
     }
-    // 通过 dsh-schedule 的 foldScheduleEvents 入口：0.1.2 上第二个参数是
-    // SessionLogOffset，但 0.1.1 上是 number（已弃）。我们传 number，运行时
-    // 0.1.2 的 foldScheduleEvents 内部会做 brandshape 校验——若强校验失败，
-    // 改由 session.inheritedEventCount 透传。这里保留双轨探测的安全门。
-    const folded = foldScheduleEvents(events, inheritedEventCount);
+    // number 形式进入 foldScheduleEvents：0.1.2 brandshape 校验接受 safe integer；
+    // 0.1.1 直接收 number。
+    const folded = asLegacySchedules(foldScheduleEvents(events, inheritedEventCount));
     // 所有权与投递形态：sidecar 为准（新写入），日志中的历史 OWNED 事件作底
     // （读兼容，旧日志可能仍有残留行）。
     const sessionId = session.header?.id;
@@ -226,7 +220,10 @@ export function serializeScheduleView(view) {
         ...(view.kind === 'every' ? { every_seconds: view.everySeconds } : {}),
         scheduled_at: view.scheduledAt,
         state: view.state,
-        delivery_mode: view.deliveryMode,
+        // 0.1.5 内核给 'session-local'，0.1.7 改名为 'host'——两者语义相同
+        // （提醒永不离开所属会话）。wire 契约对外归一为 'session-local'，
+        // 避免内核改名传导到客户端与已存档的对话内容。
+        delivery_mode: 'session-local',
         source: 'user-tool',
     };
 }
@@ -302,12 +299,12 @@ export async function userScheduleCreate(input, agent, ctx, maxSchedules = DEFAU
         // 所有权写 sidecar（append 之前：投影 fold 在事件到达时按 sidecar 判定归属）。
         // flush 失败则回滚，避免 sidecar 与日志漂移。
         const sessionId = agent.session.header?.id;
-        recordOwnership(sessionId, id, trustedDelivery);
+        recordOwnership(sessionId, id, trustedDelivery, newTaskUid(), record.kind === 'after' ? record.afterSeconds : undefined);
         try {
             agent.session.append('schedule/change', {
                 version: 1,
                 operation: 'create',
-                schedule: record,
+                schedule: toChangePayload(record),
             });
         }
         catch {
@@ -345,13 +342,13 @@ export async function userScheduleList(agent, ctx) {
         return { ok: true, schedules };
     });
 }
-/** `user_schedule_delete` 核心实现。 */
+/** `user_schedule_delete` 核心实现。id 可为 scheduleId 或稳定 uid。 */
 export async function userScheduleDelete(id, agent, ctx) {
     if (typeof id !== 'string' || id.length === 0 || id.trim() !== id) {
         return { ok: false, code: 'invalid_rule', message: 'schedule id 必须是去空白非空字符串。' };
     }
-    const scheduleId = ScheduleId(id);
     return runUserScheduleTransaction(agent, async () => {
+        const sessionId = agent.session.header?.id;
         let folded;
         try {
             folded = foldUserState(agent.session).folded;
@@ -359,26 +356,40 @@ export async function userScheduleDelete(id, agent, ctx) {
         catch {
             return { ok: false, code: 'internal_error', message: '会话定时日志读取失败。' };
         }
-        if (!folded.active.some((record) => record.id === scheduleId)) {
-            return { ok: true, id, deleted: false, code: 'schedule_not_found' };
-        }
-        const sessionId = agent.session.header?.id;
-        try {
-            agent.session.append('schedule/change', {
-                version: 1,
-                operation: 'delete',
-                id: scheduleId,
-            });
+        // 1) 活动任务：uid → scheduleId
+        const activeId = resolveActiveScheduleId(sessionId, id);
+        if (folded.active.some((record) => record.id === activeId)) {
+            try {
+                agent.session.append('schedule/change', {
+                    version: 1,
+                    operation: 'delete',
+                    id: ScheduleId(activeId),
+                });
+            }
+            catch {
+                return internalError();
+            }
+            if (!(await flushSession(ctx, agent.session)))
+                return persistenceError();
+            removeOwnership(sessionId, activeId);
+            return { ok: true, id, deleted: true };
         }
-        catch {
-            return internalError();
+        // 2) 暂停项：wire id 即 uid，只清 sidecar。
+        //
+        // 这里**不能**像活动任务那样补一条 `schedule/change` delete 事件：
+        // dsh-schedule 的 fold 要求 delete 必须命中「仍 active」的 id，而该 id 在
+        // pause 时就已经被删掉了（见 userSchedulePause），补写会抛
+        // `schedule delete targets inactive id`，把整份日志读坏。
+        //
+        // 后果：投影 cell 不会因 sidecar 变化而重算，`paused[]` 镜像会停留在快照上。
+        // 因此 `viewUserScheduleProjection` 改为**以 sidecar 为准重读**（权威存储），
+        // 使删除即刻对客户端可见。
+        const paused = getPaused(sessionId, id);
+        if (paused !== undefined) {
+            removePaused(sessionId, id);
+            return { ok: true, id, deleted: true };
         }
-        if (!(await flushSession(ctx, agent.session)))
-            return persistenceError();
-        // flush 成功后再撤销所有权（失败时保留：日志里的 delete 可能未落盘，
-        // 运行时还要按 sidecar 继续追踪该任务）。
-        removeOwnership(sessionId, scheduleId);
-        return { ok: true, id, deleted: true };
+        return { ok: true, id, deleted: false, code: 'schedule_not_found' };
     });
 }
 /** `user_schedule_edit`（改内容）核心实现：删旧建新，保留原时刻与 delivery。 */
@@ -404,6 +415,34 @@ export async function userScheduleEditPrompt(id, newPrompt, agent, ctx, limits =
         }
         const existing = folded.active.find((record) => record.id === scheduleId);
         if (existing === undefined) {
+            /**
+             * 暂停项的编辑：只改 sidecar 里的 `prompt`。
+             *
+             * 为什么单独走一条路：暂停 = 日志 `delete` + sidecar 留档（方案 B），所以
+             * 暂停项**在日志里不存在**，`folded.active` 必然找不到它。但内容本就存在
+             * `PausedEntry.prompt`（resume 时用它重建记录），因此直接改写该字段即可——
+             * 不动时刻、不动剩余秒数、不动 uid、不产生任何会话事件。
+             *
+             * 这也消掉了"暂停了就不能改文案"这个反直觉的限制。
+             */
+            const sessionId = agent.session.header?.id;
+            const paused = getPaused(sessionId, id);
+            if (paused !== undefined) {
+                // 仅替换 prompt，其余字段（remainingSeconds / pausedAt / uid / 原窗口）
+                // 原样保留 → 冻结进度与恢复后的窗口都不受影响。
+                recordPaused(sessionId, { ...paused, prompt: trimmed });
+                // 复用与日志记录一致的序列化，避免两处形状漂移。
+                return {
+                    ok: true,
+                    ...serializeScheduleView(scheduleView({
+                        id: paused.lastScheduleId,
+                        kind: 'after',
+                        prompt: trimmed,
+                        afterSeconds: paused.originalAfterSeconds ?? paused.remainingSeconds,
+                        scheduledAt: paused.originalScheduledAt,
+                    }, Date.now())),
+                };
+            }
             return { ok: false, code: 'schedule_not_found', message: `未找到定时任务 ${scheduleId}。` };
         }
         // P0-4：已过期（overdue）的 at 任务禁止改内容——「保留原时刻」会让新记录
@@ -430,7 +469,13 @@ export async function userScheduleEditPrompt(id, newPrompt, agent, ctx, limits =
                 now);
             }
             else {
-                record = createEveryScheduleRecord(allocateScheduleId(folded), trimmed, existing.everySeconds ?? 300, now);
+                // 0.1.7 的 `ScheduleRecord` 联合新增 daily/weekly/cron（均无
+                // `everySeconds`）。本插件只创建 every，故其余变体按 300s 默认间隔
+                // 归一——它们只可能来自其他插件写入的日志，不是本插件的产物。
+                const everySeconds = existing.kind === 'every' && typeof existing.everySeconds === 'number'
+                    ? existing.everySeconds
+                    : 300;
+                record = createEveryScheduleRecord(allocateScheduleId(folded), trimmed, everySeconds, now);
             }
         }
         catch (error) {
@@ -438,13 +483,14 @@ export async function userScheduleEditPrompt(id, newPrompt, agent, ctx, limits =
         }
         const delivery = deliveries.get(scheduleId) ?? 'context';
         // 新所有权先写 sidecar（create 事件到达投影 fold 时按 sidecar 判定归属）；
-        // 旧条目在 flush 成功后再撤销（失败回滚两侧）。
+        // 旧条目在 flush 成功后再撤销（失败回滚两侧）。uid 跨编辑保留。
         const sessionId = agent.session.header?.id;
         const previousEntry = getOwnership(sessionId, scheduleId);
-        recordOwnership(sessionId, record.id, delivery);
+        // 编辑 after 会重置倒计时 → 窗口等于新 afterSeconds，不沿用 resume 旧窗口
+        recordOwnership(sessionId, record.id, delivery, previousEntry?.uid, record.kind === 'after' ? record.afterSeconds : undefined);
         try {
             agent.session.append('schedule/change', { version: 1, operation: 'delete', id: scheduleId });
-            agent.session.append('schedule/change', { version: 1, operation: 'create', schedule: record });
+            agent.session.append('schedule/change', { version: 1, operation: 'create', schedule: toChangePayload(record) });
         }
         catch {
             removeOwnership(sessionId, record.id);
@@ -461,3 +507,181 @@ export async function userScheduleEditPrompt(id, newPrompt, agent, ctx, limits =
         return { ok: true, ...serializeScheduleView(view) };
     });
 }
+/** 把 wire/命令里的 id 解析为当前 active 的日志 schedule id（uid 或 scheduleId）。 */
+function resolveActiveScheduleId(sessionId, id) {
+    if (getOwnership(sessionId, id) !== undefined)
+        return id;
+    const byUid = findScheduleIdByUid(sessionId, id);
+    return byUid ?? id;
+}
+/**
+ * 暂停一条 **after** 提醒（方案 B）：sidecar 留档 + 日志 delete。
+ * 仅 kind==='after' 且未到点；恢复见 {@link userScheduleResume}。
+ */
+export async function userSchedulePause(id, agent, ctx) {
+    if (typeof id !== 'string' || id.length === 0 || id.trim() !== id) {
+        return { ok: false, code: 'invalid_rule', message: 'schedule id 必须是去空白非空字符串。' };
+    }
+    return runUserScheduleTransaction(agent, async () => {
+        const sessionId = agent.session.header?.id;
+        let folded;
+        let owned;
+        let deliveryMap;
+        try {
+            const state = foldUserState(agent.session);
+            folded = state.folded;
+            owned = state.owned;
+            deliveryMap = state.delivery;
+        }
+        catch {
+            return { ok: false, code: 'internal_error', message: '会话定时日志读取失败。' };
+        }
+        const scheduleId = resolveActiveScheduleId(sessionId, id);
+        const existing = folded.active.find((record) => record.id === scheduleId);
+        if (existing === undefined || !owned.has(scheduleId)) {
+            return { ok: false, code: 'schedule_not_found', message: `未找到可暂停的定时任务 ${id}。` };
+        }
+        if (existing.kind !== 'after') {
+            return { ok: false, code: 'unsupported_kind', message: '仅支持暂停「再等 N 分钟」类（after）提醒。' };
+        }
+        const now = Date.now();
+        const target = Date.parse(existing.scheduledAt);
+        if (!Number.isFinite(target) || target <= now) {
+            return {
+                ok: false,
+                code: 'already_overdue',
+                message: '任务已到点，无法暂停；请删除或等待发送。',
+            };
+        }
+        const remainingSeconds = Math.max(1, Math.ceil((target - now) / 1000));
+        const ownership = getOwnership(sessionId, scheduleId);
+        const uid = ownership?.uid ?? newTaskUid();
+        const delivery = deliveryMap.get(scheduleId) ?? ownership?.delivery ?? 'context';
+        // 旧条目无 uid 时补写，保证 pause 后有稳定身份
+        if (ownership?.uid === undefined) {
+            recordOwnership(sessionId, scheduleId, delivery, uid);
+        }
+        /**
+         * 进度条总窗口（原间隔），**不能**用 `existing.afterSeconds`。
+         *
+         * resume 会用 `after_seconds = remaining` 重建记录（日志里的 afterSeconds
+         * 只是剩余），而把原窗口另行保存在 ownership.windowSeconds。若这里读日志的
+         * afterSeconds，每「恢复→再暂停」一轮窗口就缩水一次：
+         *   2 分钟任务 → 暂停(窗 120) → 恢复(日志 85) → 再暂停(窗被记成 85) …
+         * 表现为暂停后进度条比例越来越离谱（实测 29% → 2.3% 塌缩）。
+         * 故优先取 ownership 里保留的窗口，再回退日志值（首次暂停时两者相同）。
+         */
+        const windowSeconds = ownership?.windowSeconds ?? existing.afterSeconds;
+        const pausedEntry = {
+            uid,
+            prompt: existing.prompt,
+            delivery,
+            kind: 'after',
+            remainingSeconds,
+            originalScheduledAt: existing.scheduledAt,
+            ...(windowSeconds !== undefined ? { originalAfterSeconds: windowSeconds } : {}),
+            lastScheduleId: scheduleId,
+            pausedAt: now,
+        };
+        // sidecar 先写（投影 delete 后按 lastScheduleId 挂回 paused 列表）
+        recordPaused(sessionId, pausedEntry);
+        try {
+            agent.session.append('schedule/change', {
+                version: 1,
+                operation: 'delete',
+                id: ScheduleId(scheduleId),
+            });
+        }
+        catch {
+            removePaused(sessionId, uid);
+            return internalError();
+        }
+        if (!(await flushSession(ctx, agent.session))) {
+            removePaused(sessionId, uid);
+            return persistenceError();
+        }
+        removeOwnership(sessionId, scheduleId);
+        return {
+            ok: true,
+            uid,
+            schedule_id: scheduleId,
+            remaining_seconds: remainingSeconds,
+            scheduled_at: existing.scheduledAt,
+        };
+    });
+}
+/** 恢复一条暂停中的 after 提醒：`after_seconds = remaining` 重建；uid 不变。 */
+export async function userScheduleResume(uid, agent, ctx, maxSchedules = DEFAULT_MAX_SCHEDULES) {
+    if (typeof uid !== 'string' || uid.length === 0 || uid.trim() !== uid) {
+        return { ok: false, code: 'invalid_rule', message: 'uid 必须是去空白非空字符串。' };
+    }
+    return runUserScheduleTransaction(agent, async () => {
+        const sessionId = agent.session.header?.id;
+        const paused = getPaused(sessionId, uid);
+        if (paused === undefined) {
+            return { ok: false, code: 'not_paused', message: `未找到暂停中的任务 ${uid}。` };
+        }
+        let folded;
+        let owned;
+        try {
+            const state = foldUserState(agent.session);
+            folded = state.folded;
+            owned = state.owned;
+        }
+        catch {
+            return { ok: false, code: 'internal_error', message: '会话定时日志读取失败。' };
+        }
+        const activeCount = folded.active.filter((record) => owned.has(record.id)).length;
+        if (activeCount >= maxSchedules) {
+            return {
+                ok: false,
+                code: 'quota_exceeded',
+                message: `当前会话最多 ${maxSchedules} 个定时任务，请先删除部分任务。`,
+            };
+        }
+        const now = Date.now();
+        let record;
+        try {
+            record = createAfterScheduleRecord(ScheduleId(allocateScheduleId(folded)), paused.prompt, Math.max(1, paused.remainingSeconds), now);
+        }
+        catch (error) {
+            return toInputError(error);
+        }
+        // 先清 paused：投影 fold 在 append(create) 时读 sidecar；若 create 落地后才
+        // removePaused，视图会短暂同时出现「已暂停」+ 新活动行（实测重复行根因）。
+        removePaused(sessionId, uid);
+        // 保留原 after 窗口：日志 afterSeconds 只是 remaining，进度条需要原窗口才能接着跑
+        recordOwnership(sessionId, record.id, paused.delivery, uid, paused.originalAfterSeconds ?? paused.remainingSeconds);
+        try {
+            agent.session.append('schedule/change', {
+                version: 1,
+                operation: 'create',
+                schedule: toChangePayload(record),
+            });
+        }
+        catch {
+            removeOwnership(sessionId, record.id);
+            recordPaused(sessionId, paused);
+            return internalError();
+        }
+        if (!(await flushSession(ctx, agent.session))) {
+            removeOwnership(sessionId, record.id);
+            recordPaused(sessionId, paused);
+            return persistenceError();
+        }
+        return {
+            ok: true,
+            uid,
+            schedule_id: record.id,
+            remaining_seconds: Math.max(1, paused.remainingSeconds),
+        };
+    });
+}
+/** 测试/投影辅助：某会话全部暂停留档。 */
+export function listPausedForSession(sessionId) {
+    return allPaused(sessionId);
+}
+/** 测试辅助：按 pause 前 schedule id 查留档。 */
+export function findPausedEntry(sessionId, scheduleId) {
+    return findPausedByScheduleId(sessionId, scheduleId);
+}